From 119063de01f1189f4325f7a6e165c84e24451223 Mon Sep 17 00:00:00 2001 From: Brad Moylan Date: Tue, 28 Nov 2023 15:58:49 -0800 Subject: [PATCH 1/2] improvement: Use HTTP-method-specific functions on client requests --- .../verification/server/services.conjure.go | 573 ++++++------------ .../com/palantir/services/services.conjure.go | 6 +- .../com/palantir/services/services.conjure.go | 6 +- .../com/palantir/services/services.conjure.go | 6 +- .../com/palantir/services/services.conjure.go | 6 +- .../com/palantir/services/services.conjure.go | 6 +- conjure/servicewriter.go | 16 +- .../auth/api/services.conjure.go | 30 +- .../binary/api/services.conjure.go | 24 +- .../testgenerated/cli/api/services.conjure.go | 60 +- .../client/api/services.conjure.go | 27 +- .../post/api/services.conjure.go | 3 +- .../queryparam/api/services.conjure.go | 3 +- .../server/api/services.conjure.go | 87 +-- 14 files changed, 293 insertions(+), 560 deletions(-) diff --git a/conjure-go-verifier/conjure/verification/server/services.conjure.go b/conjure-go-verifier/conjure/verification/server/services.conjure.go index dc7450739..93a72a249 100644 --- a/conjure-go-verifier/conjure/verification/server/services.conjure.go +++ b/conjure-go-verifier/conjure/verification/server/services.conjure.go @@ -113,10 +113,9 @@ func NewAutoDeserializeConfirmServiceClient(client httpclient.Client) AutoDeseri func (c *autoDeserializeConfirmServiceClient) Confirm(ctx context.Context, endpointArg EndpointName, indexArg int, bodyArg interface{}) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("Confirm")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/%s/%s", url.PathEscape(fmt.Sprint(endpointArg)), url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "confirm failed") } return nil @@ -125,10 +124,9 @@ func (c *autoDeserializeConfirmServiceClient) Confirm(ctx context.Context, endpo func (c *autoDeserializeConfirmServiceClient) ReceiveBearerTokenExample(ctx context.Context, indexArg int, bodyArg types.BearerTokenExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveBearerTokenExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveBearerTokenExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveBearerTokenExample failed") } return nil @@ -137,10 +135,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveBearerTokenExample(ctx cont func (c *autoDeserializeConfirmServiceClient) ReceiveBinaryExample(ctx context.Context, indexArg int, bodyArg types.BinaryExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveBinaryExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveBinaryExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveBinaryExample failed") } return nil @@ -149,10 +146,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveBinaryExample(ctx context.C func (c *autoDeserializeConfirmServiceClient) ReceiveBooleanExample(ctx context.Context, indexArg int, bodyArg types.BooleanExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveBooleanExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveBooleanExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveBooleanExample failed") } return nil @@ -161,10 +157,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveBooleanExample(ctx context. func (c *autoDeserializeConfirmServiceClient) ReceiveDateTimeExample(ctx context.Context, indexArg int, bodyArg types.DateTimeExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveDateTimeExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveDateTimeExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveDateTimeExample failed") } return nil @@ -173,10 +168,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveDateTimeExample(ctx context func (c *autoDeserializeConfirmServiceClient) ReceiveDoubleExample(ctx context.Context, indexArg int, bodyArg types.DoubleExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveDoubleExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveDoubleExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveDoubleExample failed") } return nil @@ -185,10 +179,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveDoubleExample(ctx context.C func (c *autoDeserializeConfirmServiceClient) ReceiveIntegerExample(ctx context.Context, indexArg int, bodyArg types.IntegerExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveIntegerExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveIntegerExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveIntegerExample failed") } return nil @@ -197,10 +190,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveIntegerExample(ctx context. func (c *autoDeserializeConfirmServiceClient) ReceiveRidExample(ctx context.Context, indexArg int, bodyArg types.RidExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveRidExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveRidExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveRidExample failed") } return nil @@ -209,10 +201,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveRidExample(ctx context.Cont func (c *autoDeserializeConfirmServiceClient) ReceiveSafeLongExample(ctx context.Context, indexArg int, bodyArg types.SafeLongExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveSafeLongExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveSafeLongExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveSafeLongExample failed") } return nil @@ -221,10 +212,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveSafeLongExample(ctx context func (c *autoDeserializeConfirmServiceClient) ReceiveStringExample(ctx context.Context, indexArg int, bodyArg types.StringExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveStringExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveStringExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveStringExample failed") } return nil @@ -233,10 +223,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveStringExample(ctx context.C func (c *autoDeserializeConfirmServiceClient) ReceiveUuidExample(ctx context.Context, indexArg int, bodyArg types.UuidExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveUuidExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveUuidExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveUuidExample failed") } return nil @@ -245,10 +234,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveUuidExample(ctx context.Con func (c *autoDeserializeConfirmServiceClient) ReceiveAnyExample(ctx context.Context, indexArg int, bodyArg types.AnyExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveAnyExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveAnyExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveAnyExample failed") } return nil @@ -257,10 +245,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveAnyExample(ctx context.Cont func (c *autoDeserializeConfirmServiceClient) ReceiveEnumExample(ctx context.Context, indexArg int, bodyArg types.EnumExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveEnumExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveEnumExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveEnumExample failed") } return nil @@ -269,10 +256,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveEnumExample(ctx context.Con func (c *autoDeserializeConfirmServiceClient) ReceiveListExample(ctx context.Context, indexArg int, bodyArg types.ListExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveListExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveListExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveListExample failed") } return nil @@ -281,10 +267,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveListExample(ctx context.Con func (c *autoDeserializeConfirmServiceClient) ReceiveSetStringExample(ctx context.Context, indexArg int, bodyArg types.SetStringExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveSetStringExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveSetStringExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveSetStringExample failed") } return nil @@ -293,10 +278,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveSetStringExample(ctx contex func (c *autoDeserializeConfirmServiceClient) ReceiveSetDoubleExample(ctx context.Context, indexArg int, bodyArg types.SetDoubleExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveSetDoubleExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveSetDoubleExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveSetDoubleExample failed") } return nil @@ -305,10 +289,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveSetDoubleExample(ctx contex func (c *autoDeserializeConfirmServiceClient) ReceiveMapExample(ctx context.Context, indexArg int, bodyArg types.MapExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveMapExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveMapExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveMapExample failed") } return nil @@ -317,10 +300,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveMapExample(ctx context.Cont func (c *autoDeserializeConfirmServiceClient) ReceiveOptionalExample(ctx context.Context, indexArg int, bodyArg types.OptionalExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveOptionalExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveOptionalExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveOptionalExample failed") } return nil @@ -329,10 +311,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveOptionalExample(ctx context func (c *autoDeserializeConfirmServiceClient) ReceiveOptionalBooleanExample(ctx context.Context, indexArg int, bodyArg types.OptionalBooleanExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveOptionalBooleanExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveOptionalBooleanExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveOptionalBooleanExample failed") } return nil @@ -341,10 +322,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveOptionalBooleanExample(ctx func (c *autoDeserializeConfirmServiceClient) ReceiveOptionalIntegerExample(ctx context.Context, indexArg int, bodyArg types.OptionalIntegerExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveOptionalIntegerExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveOptionalIntegerExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveOptionalIntegerExample failed") } return nil @@ -353,10 +333,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveOptionalIntegerExample(ctx func (c *autoDeserializeConfirmServiceClient) ReceiveLongFieldNameOptionalExample(ctx context.Context, indexArg int, bodyArg types.LongFieldNameOptionalExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveLongFieldNameOptionalExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveLongFieldNameOptionalExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveLongFieldNameOptionalExample failed") } return nil @@ -365,12 +344,11 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveLongFieldNameOptionalExampl func (c *autoDeserializeConfirmServiceClient) ReceiveRawOptionalExample(ctx context.Context, indexArg int, bodyArg types.RawOptionalExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveRawOptionalExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveRawOptionalExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) if bodyArg.Value != nil { requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) } - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveRawOptionalExample failed") } return nil @@ -379,10 +357,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveRawOptionalExample(ctx cont func (c *autoDeserializeConfirmServiceClient) ReceiveStringAliasExample(ctx context.Context, indexArg int, bodyArg types.StringAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveStringAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveStringAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveStringAliasExample failed") } return nil @@ -391,10 +368,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveStringAliasExample(ctx cont func (c *autoDeserializeConfirmServiceClient) ReceiveDoubleAliasExample(ctx context.Context, indexArg int, bodyArg types.DoubleAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveDoubleAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveDoubleAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveDoubleAliasExample failed") } return nil @@ -403,10 +379,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveDoubleAliasExample(ctx cont func (c *autoDeserializeConfirmServiceClient) ReceiveIntegerAliasExample(ctx context.Context, indexArg int, bodyArg types.IntegerAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveIntegerAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveIntegerAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveIntegerAliasExample failed") } return nil @@ -415,10 +390,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveIntegerAliasExample(ctx con func (c *autoDeserializeConfirmServiceClient) ReceiveBooleanAliasExample(ctx context.Context, indexArg int, bodyArg types.BooleanAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveBooleanAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveBooleanAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveBooleanAliasExample failed") } return nil @@ -427,10 +401,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveBooleanAliasExample(ctx con func (c *autoDeserializeConfirmServiceClient) ReceiveSafeLongAliasExample(ctx context.Context, indexArg int, bodyArg types.SafeLongAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveSafeLongAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveSafeLongAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveSafeLongAliasExample failed") } return nil @@ -439,10 +412,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveSafeLongAliasExample(ctx co func (c *autoDeserializeConfirmServiceClient) ReceiveRidAliasExample(ctx context.Context, indexArg int, bodyArg types.RidAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveRidAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveRidAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveRidAliasExample failed") } return nil @@ -451,10 +423,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveRidAliasExample(ctx context func (c *autoDeserializeConfirmServiceClient) ReceiveBearerTokenAliasExample(ctx context.Context, indexArg int, bodyArg types.BearerTokenAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveBearerTokenAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveBearerTokenAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveBearerTokenAliasExample failed") } return nil @@ -463,10 +434,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveBearerTokenAliasExample(ctx func (c *autoDeserializeConfirmServiceClient) ReceiveUuidAliasExample(ctx context.Context, indexArg int, bodyArg types.UuidAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveUuidAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveUuidAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveUuidAliasExample failed") } return nil @@ -475,10 +445,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveUuidAliasExample(ctx contex func (c *autoDeserializeConfirmServiceClient) ReceiveReferenceAliasExample(ctx context.Context, indexArg int, bodyArg types.ReferenceAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveReferenceAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveReferenceAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveReferenceAliasExample failed") } return nil @@ -487,10 +456,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveReferenceAliasExample(ctx c func (c *autoDeserializeConfirmServiceClient) ReceiveDateTimeAliasExample(ctx context.Context, indexArg int, bodyArg types.DateTimeAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveDateTimeAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveDateTimeAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveDateTimeAliasExample failed") } return nil @@ -499,10 +467,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveDateTimeAliasExample(ctx co func (c *autoDeserializeConfirmServiceClient) ReceiveBinaryAliasExample(ctx context.Context, indexArg int, bodyArg func() io.ReadCloser) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveBinaryAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveBinaryAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithRawRequestBodyProvider(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveBinaryAliasExample failed") } return nil @@ -511,10 +478,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveBinaryAliasExample(ctx cont func (c *autoDeserializeConfirmServiceClient) ReceiveKebabCaseObjectExample(ctx context.Context, indexArg int, bodyArg types.KebabCaseObjectExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveKebabCaseObjectExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveKebabCaseObjectExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveKebabCaseObjectExample failed") } return nil @@ -523,10 +489,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveKebabCaseObjectExample(ctx func (c *autoDeserializeConfirmServiceClient) ReceiveSnakeCaseObjectExample(ctx context.Context, indexArg int, bodyArg types.SnakeCaseObjectExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveSnakeCaseObjectExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveSnakeCaseObjectExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveSnakeCaseObjectExample failed") } return nil @@ -535,12 +500,11 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveSnakeCaseObjectExample(ctx func (c *autoDeserializeConfirmServiceClient) ReceiveOptionalBearerTokenAliasExample(ctx context.Context, indexArg int, bodyArg types.OptionalBearerTokenAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveOptionalBearerTokenAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveOptionalBearerTokenAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) if bodyArg.Value != nil { requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) } - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveOptionalBearerTokenAliasExample failed") } return nil @@ -549,12 +513,11 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveOptionalBearerTokenAliasExa func (c *autoDeserializeConfirmServiceClient) ReceiveOptionalBooleanAliasExample(ctx context.Context, indexArg int, bodyArg types.OptionalBooleanAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveOptionalBooleanAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveOptionalBooleanAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) if bodyArg.Value != nil { requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) } - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveOptionalBooleanAliasExample failed") } return nil @@ -563,12 +526,11 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveOptionalBooleanAliasExample func (c *autoDeserializeConfirmServiceClient) ReceiveOptionalDateTimeAliasExample(ctx context.Context, indexArg int, bodyArg types.OptionalDateTimeAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveOptionalDateTimeAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveOptionalDateTimeAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) if bodyArg.Value != nil { requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) } - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveOptionalDateTimeAliasExample failed") } return nil @@ -577,12 +539,11 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveOptionalDateTimeAliasExampl func (c *autoDeserializeConfirmServiceClient) ReceiveOptionalDoubleAliasExample(ctx context.Context, indexArg int, bodyArg types.OptionalDoubleAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveOptionalDoubleAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveOptionalDoubleAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) if bodyArg.Value != nil { requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) } - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveOptionalDoubleAliasExample failed") } return nil @@ -591,12 +552,11 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveOptionalDoubleAliasExample( func (c *autoDeserializeConfirmServiceClient) ReceiveOptionalIntegerAliasExample(ctx context.Context, indexArg int, bodyArg types.OptionalIntegerAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveOptionalIntegerAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveOptionalIntegerAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) if bodyArg.Value != nil { requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) } - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveOptionalIntegerAliasExample failed") } return nil @@ -605,12 +565,11 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveOptionalIntegerAliasExample func (c *autoDeserializeConfirmServiceClient) ReceiveOptionalRidAliasExample(ctx context.Context, indexArg int, bodyArg types.OptionalRidAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveOptionalRidAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveOptionalRidAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) if bodyArg.Value != nil { requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) } - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveOptionalRidAliasExample failed") } return nil @@ -619,12 +578,11 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveOptionalRidAliasExample(ctx func (c *autoDeserializeConfirmServiceClient) ReceiveOptionalSafeLongAliasExample(ctx context.Context, indexArg int, bodyArg types.OptionalSafeLongAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveOptionalSafeLongAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveOptionalSafeLongAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) if bodyArg.Value != nil { requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) } - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveOptionalSafeLongAliasExample failed") } return nil @@ -633,12 +591,11 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveOptionalSafeLongAliasExampl func (c *autoDeserializeConfirmServiceClient) ReceiveOptionalStringAliasExample(ctx context.Context, indexArg int, bodyArg types.OptionalStringAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveOptionalStringAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveOptionalStringAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) if bodyArg.Value != nil { requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) } - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveOptionalStringAliasExample failed") } return nil @@ -647,12 +604,11 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveOptionalStringAliasExample( func (c *autoDeserializeConfirmServiceClient) ReceiveOptionalUuidAliasExample(ctx context.Context, indexArg int, bodyArg types.OptionalUuidAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveOptionalUuidAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveOptionalUuidAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) if bodyArg.Value != nil { requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) } - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveOptionalUuidAliasExample failed") } return nil @@ -661,12 +617,11 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveOptionalUuidAliasExample(ct func (c *autoDeserializeConfirmServiceClient) ReceiveOptionalAnyAliasExample(ctx context.Context, indexArg int, bodyArg types.OptionalAnyAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveOptionalAnyAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveOptionalAnyAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) if bodyArg.Value != nil { requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) } - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveOptionalAnyAliasExample failed") } return nil @@ -675,10 +630,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveOptionalAnyAliasExample(ctx func (c *autoDeserializeConfirmServiceClient) ReceiveListBearerTokenAliasExample(ctx context.Context, indexArg int, bodyArg types.ListBearerTokenAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveListBearerTokenAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveListBearerTokenAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveListBearerTokenAliasExample failed") } return nil @@ -687,10 +641,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveListBearerTokenAliasExample func (c *autoDeserializeConfirmServiceClient) ReceiveListBinaryAliasExample(ctx context.Context, indexArg int, bodyArg types.ListBinaryAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveListBinaryAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveListBinaryAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveListBinaryAliasExample failed") } return nil @@ -699,10 +652,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveListBinaryAliasExample(ctx func (c *autoDeserializeConfirmServiceClient) ReceiveListBooleanAliasExample(ctx context.Context, indexArg int, bodyArg types.ListBooleanAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveListBooleanAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveListBooleanAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveListBooleanAliasExample failed") } return nil @@ -711,10 +663,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveListBooleanAliasExample(ctx func (c *autoDeserializeConfirmServiceClient) ReceiveListDateTimeAliasExample(ctx context.Context, indexArg int, bodyArg types.ListDateTimeAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveListDateTimeAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveListDateTimeAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveListDateTimeAliasExample failed") } return nil @@ -723,10 +674,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveListDateTimeAliasExample(ct func (c *autoDeserializeConfirmServiceClient) ReceiveListDoubleAliasExample(ctx context.Context, indexArg int, bodyArg types.ListDoubleAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveListDoubleAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveListDoubleAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveListDoubleAliasExample failed") } return nil @@ -735,10 +685,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveListDoubleAliasExample(ctx func (c *autoDeserializeConfirmServiceClient) ReceiveListIntegerAliasExample(ctx context.Context, indexArg int, bodyArg types.ListIntegerAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveListIntegerAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveListIntegerAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveListIntegerAliasExample failed") } return nil @@ -747,10 +696,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveListIntegerAliasExample(ctx func (c *autoDeserializeConfirmServiceClient) ReceiveListRidAliasExample(ctx context.Context, indexArg int, bodyArg types.ListRidAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveListRidAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveListRidAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveListRidAliasExample failed") } return nil @@ -759,10 +707,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveListRidAliasExample(ctx con func (c *autoDeserializeConfirmServiceClient) ReceiveListSafeLongAliasExample(ctx context.Context, indexArg int, bodyArg types.ListSafeLongAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveListSafeLongAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveListSafeLongAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveListSafeLongAliasExample failed") } return nil @@ -771,10 +718,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveListSafeLongAliasExample(ct func (c *autoDeserializeConfirmServiceClient) ReceiveListStringAliasExample(ctx context.Context, indexArg int, bodyArg types.ListStringAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveListStringAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveListStringAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveListStringAliasExample failed") } return nil @@ -783,10 +729,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveListStringAliasExample(ctx func (c *autoDeserializeConfirmServiceClient) ReceiveListUuidAliasExample(ctx context.Context, indexArg int, bodyArg types.ListUuidAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveListUuidAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveListUuidAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveListUuidAliasExample failed") } return nil @@ -795,10 +740,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveListUuidAliasExample(ctx co func (c *autoDeserializeConfirmServiceClient) ReceiveListAnyAliasExample(ctx context.Context, indexArg int, bodyArg types.ListAnyAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveListAnyAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveListAnyAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveListAnyAliasExample failed") } return nil @@ -807,10 +751,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveListAnyAliasExample(ctx con func (c *autoDeserializeConfirmServiceClient) ReceiveListOptionalAnyAliasExample(ctx context.Context, indexArg int, bodyArg types.ListOptionalAnyAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveListOptionalAnyAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveListOptionalAnyAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveListOptionalAnyAliasExample failed") } return nil @@ -819,10 +762,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveListOptionalAnyAliasExample func (c *autoDeserializeConfirmServiceClient) ReceiveSetBearerTokenAliasExample(ctx context.Context, indexArg int, bodyArg types.SetBearerTokenAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveSetBearerTokenAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveSetBearerTokenAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveSetBearerTokenAliasExample failed") } return nil @@ -831,10 +773,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveSetBearerTokenAliasExample( func (c *autoDeserializeConfirmServiceClient) ReceiveSetBinaryAliasExample(ctx context.Context, indexArg int, bodyArg types.SetBinaryAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveSetBinaryAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveSetBinaryAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveSetBinaryAliasExample failed") } return nil @@ -843,10 +784,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveSetBinaryAliasExample(ctx c func (c *autoDeserializeConfirmServiceClient) ReceiveSetBooleanAliasExample(ctx context.Context, indexArg int, bodyArg types.SetBooleanAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveSetBooleanAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveSetBooleanAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveSetBooleanAliasExample failed") } return nil @@ -855,10 +795,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveSetBooleanAliasExample(ctx func (c *autoDeserializeConfirmServiceClient) ReceiveSetDateTimeAliasExample(ctx context.Context, indexArg int, bodyArg types.SetDateTimeAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveSetDateTimeAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveSetDateTimeAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveSetDateTimeAliasExample failed") } return nil @@ -867,10 +806,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveSetDateTimeAliasExample(ctx func (c *autoDeserializeConfirmServiceClient) ReceiveSetDoubleAliasExample(ctx context.Context, indexArg int, bodyArg types.SetDoubleAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveSetDoubleAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveSetDoubleAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveSetDoubleAliasExample failed") } return nil @@ -879,10 +817,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveSetDoubleAliasExample(ctx c func (c *autoDeserializeConfirmServiceClient) ReceiveSetIntegerAliasExample(ctx context.Context, indexArg int, bodyArg types.SetIntegerAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveSetIntegerAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveSetIntegerAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveSetIntegerAliasExample failed") } return nil @@ -891,10 +828,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveSetIntegerAliasExample(ctx func (c *autoDeserializeConfirmServiceClient) ReceiveSetRidAliasExample(ctx context.Context, indexArg int, bodyArg types.SetRidAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveSetRidAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveSetRidAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveSetRidAliasExample failed") } return nil @@ -903,10 +839,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveSetRidAliasExample(ctx cont func (c *autoDeserializeConfirmServiceClient) ReceiveSetSafeLongAliasExample(ctx context.Context, indexArg int, bodyArg types.SetSafeLongAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveSetSafeLongAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveSetSafeLongAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveSetSafeLongAliasExample failed") } return nil @@ -915,10 +850,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveSetSafeLongAliasExample(ctx func (c *autoDeserializeConfirmServiceClient) ReceiveSetStringAliasExample(ctx context.Context, indexArg int, bodyArg types.SetStringAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveSetStringAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveSetStringAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveSetStringAliasExample failed") } return nil @@ -927,10 +861,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveSetStringAliasExample(ctx c func (c *autoDeserializeConfirmServiceClient) ReceiveSetUuidAliasExample(ctx context.Context, indexArg int, bodyArg types.SetUuidAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveSetUuidAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveSetUuidAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveSetUuidAliasExample failed") } return nil @@ -939,10 +872,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveSetUuidAliasExample(ctx con func (c *autoDeserializeConfirmServiceClient) ReceiveSetAnyAliasExample(ctx context.Context, indexArg int, bodyArg types.SetAnyAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveSetAnyAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveSetAnyAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveSetAnyAliasExample failed") } return nil @@ -951,10 +883,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveSetAnyAliasExample(ctx cont func (c *autoDeserializeConfirmServiceClient) ReceiveSetOptionalAnyAliasExample(ctx context.Context, indexArg int, bodyArg types.SetOptionalAnyAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveSetOptionalAnyAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveSetOptionalAnyAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveSetOptionalAnyAliasExample failed") } return nil @@ -963,10 +894,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveSetOptionalAnyAliasExample( func (c *autoDeserializeConfirmServiceClient) ReceiveMapBearerTokenAliasExample(ctx context.Context, indexArg int, bodyArg types.MapBearerTokenAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveMapBearerTokenAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveMapBearerTokenAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveMapBearerTokenAliasExample failed") } return nil @@ -975,10 +905,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveMapBearerTokenAliasExample( func (c *autoDeserializeConfirmServiceClient) ReceiveMapBinaryAliasExample(ctx context.Context, indexArg int, bodyArg types.MapBinaryAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveMapBinaryAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveMapBinaryAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveMapBinaryAliasExample failed") } return nil @@ -987,10 +916,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveMapBinaryAliasExample(ctx c func (c *autoDeserializeConfirmServiceClient) ReceiveMapBooleanAliasExample(ctx context.Context, indexArg int, bodyArg types.MapBooleanAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveMapBooleanAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveMapBooleanAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveMapBooleanAliasExample failed") } return nil @@ -999,10 +927,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveMapBooleanAliasExample(ctx func (c *autoDeserializeConfirmServiceClient) ReceiveMapDateTimeAliasExample(ctx context.Context, indexArg int, bodyArg types.MapDateTimeAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveMapDateTimeAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveMapDateTimeAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveMapDateTimeAliasExample failed") } return nil @@ -1011,10 +938,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveMapDateTimeAliasExample(ctx func (c *autoDeserializeConfirmServiceClient) ReceiveMapDoubleAliasExample(ctx context.Context, indexArg int, bodyArg types.MapDoubleAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveMapDoubleAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveMapDoubleAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveMapDoubleAliasExample failed") } return nil @@ -1023,10 +949,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveMapDoubleAliasExample(ctx c func (c *autoDeserializeConfirmServiceClient) ReceiveMapIntegerAliasExample(ctx context.Context, indexArg int, bodyArg types.MapIntegerAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveMapIntegerAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveMapIntegerAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveMapIntegerAliasExample failed") } return nil @@ -1035,10 +960,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveMapIntegerAliasExample(ctx func (c *autoDeserializeConfirmServiceClient) ReceiveMapRidAliasExample(ctx context.Context, indexArg int, bodyArg types.MapRidAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveMapRidAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveMapRidAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveMapRidAliasExample failed") } return nil @@ -1047,10 +971,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveMapRidAliasExample(ctx cont func (c *autoDeserializeConfirmServiceClient) ReceiveMapSafeLongAliasExample(ctx context.Context, indexArg int, bodyArg types.MapSafeLongAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveMapSafeLongAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveMapSafeLongAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveMapSafeLongAliasExample failed") } return nil @@ -1059,10 +982,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveMapSafeLongAliasExample(ctx func (c *autoDeserializeConfirmServiceClient) ReceiveMapStringAliasExample(ctx context.Context, indexArg int, bodyArg types.MapStringAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveMapStringAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveMapStringAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveMapStringAliasExample failed") } return nil @@ -1071,10 +993,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveMapStringAliasExample(ctx c func (c *autoDeserializeConfirmServiceClient) ReceiveMapUuidAliasExample(ctx context.Context, indexArg int, bodyArg types.MapUuidAliasExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveMapUuidAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveMapUuidAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveMapUuidAliasExample failed") } return nil @@ -1083,10 +1004,9 @@ func (c *autoDeserializeConfirmServiceClient) ReceiveMapUuidAliasExample(ctx con func (c *autoDeserializeConfirmServiceClient) ReceiveMapEnumExampleAlias(ctx context.Context, indexArg int, bodyArg types.MapEnumExampleAlias) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveMapEnumExampleAlias")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/confirm/receiveMapEnumExampleAlias/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "receiveMapEnumExampleAlias failed") } return nil @@ -1187,10 +1107,9 @@ func (c *autoDeserializeServiceClient) ReceiveBearerTokenExample(ctx context.Con var returnVal *types.BearerTokenExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveBearerTokenExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveBearerTokenExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveBearerTokenExample failed") } if returnVal == nil { @@ -1204,10 +1123,9 @@ func (c *autoDeserializeServiceClient) ReceiveBinaryExample(ctx context.Context, var returnVal *types.BinaryExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveBinaryExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveBinaryExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveBinaryExample failed") } if returnVal == nil { @@ -1221,10 +1139,9 @@ func (c *autoDeserializeServiceClient) ReceiveBooleanExample(ctx context.Context var returnVal *types.BooleanExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveBooleanExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveBooleanExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveBooleanExample failed") } if returnVal == nil { @@ -1238,10 +1155,9 @@ func (c *autoDeserializeServiceClient) ReceiveDateTimeExample(ctx context.Contex var returnVal *types.DateTimeExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveDateTimeExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveDateTimeExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveDateTimeExample failed") } if returnVal == nil { @@ -1255,10 +1171,9 @@ func (c *autoDeserializeServiceClient) ReceiveDoubleExample(ctx context.Context, var returnVal *types.DoubleExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveDoubleExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveDoubleExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveDoubleExample failed") } if returnVal == nil { @@ -1272,10 +1187,9 @@ func (c *autoDeserializeServiceClient) ReceiveIntegerExample(ctx context.Context var returnVal *types.IntegerExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveIntegerExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveIntegerExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveIntegerExample failed") } if returnVal == nil { @@ -1289,10 +1203,9 @@ func (c *autoDeserializeServiceClient) ReceiveRidExample(ctx context.Context, in var returnVal *types.RidExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveRidExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveRidExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveRidExample failed") } if returnVal == nil { @@ -1306,10 +1219,9 @@ func (c *autoDeserializeServiceClient) ReceiveSafeLongExample(ctx context.Contex var returnVal *types.SafeLongExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveSafeLongExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveSafeLongExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveSafeLongExample failed") } if returnVal == nil { @@ -1323,10 +1235,9 @@ func (c *autoDeserializeServiceClient) ReceiveStringExample(ctx context.Context, var returnVal *types.StringExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveStringExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveStringExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveStringExample failed") } if returnVal == nil { @@ -1340,10 +1251,9 @@ func (c *autoDeserializeServiceClient) ReceiveUuidExample(ctx context.Context, i var returnVal *types.UuidExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveUuidExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveUuidExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveUuidExample failed") } if returnVal == nil { @@ -1357,10 +1267,9 @@ func (c *autoDeserializeServiceClient) ReceiveAnyExample(ctx context.Context, in var returnVal *types.AnyExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveAnyExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveAnyExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveAnyExample failed") } if returnVal == nil { @@ -1374,10 +1283,9 @@ func (c *autoDeserializeServiceClient) ReceiveEnumExample(ctx context.Context, i var returnVal *types.EnumExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveEnumExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveEnumExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveEnumExample failed") } if returnVal == nil { @@ -1391,10 +1299,9 @@ func (c *autoDeserializeServiceClient) ReceiveListExample(ctx context.Context, i var returnVal *types.ListExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveListExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveListExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveListExample failed") } if returnVal == nil { @@ -1408,10 +1315,9 @@ func (c *autoDeserializeServiceClient) ReceiveSetStringExample(ctx context.Conte var returnVal *types.SetStringExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveSetStringExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveSetStringExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveSetStringExample failed") } if returnVal == nil { @@ -1425,10 +1331,9 @@ func (c *autoDeserializeServiceClient) ReceiveSetDoubleExample(ctx context.Conte var returnVal *types.SetDoubleExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveSetDoubleExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveSetDoubleExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveSetDoubleExample failed") } if returnVal == nil { @@ -1442,10 +1347,9 @@ func (c *autoDeserializeServiceClient) ReceiveMapExample(ctx context.Context, in var returnVal *types.MapExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveMapExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveMapExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveMapExample failed") } if returnVal == nil { @@ -1459,10 +1363,9 @@ func (c *autoDeserializeServiceClient) ReceiveOptionalExample(ctx context.Contex var returnVal *types.OptionalExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveOptionalExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveOptionalExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveOptionalExample failed") } if returnVal == nil { @@ -1476,10 +1379,9 @@ func (c *autoDeserializeServiceClient) ReceiveOptionalBooleanExample(ctx context var returnVal *types.OptionalBooleanExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveOptionalBooleanExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveOptionalBooleanExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveOptionalBooleanExample failed") } if returnVal == nil { @@ -1493,10 +1395,9 @@ func (c *autoDeserializeServiceClient) ReceiveOptionalIntegerExample(ctx context var returnVal *types.OptionalIntegerExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveOptionalIntegerExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveOptionalIntegerExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveOptionalIntegerExample failed") } if returnVal == nil { @@ -1510,10 +1411,9 @@ func (c *autoDeserializeServiceClient) ReceiveLongFieldNameOptionalExample(ctx c var returnVal *types.LongFieldNameOptionalExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveLongFieldNameOptionalExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveLongFieldNameOptionalExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveLongFieldNameOptionalExample failed") } if returnVal == nil { @@ -1527,10 +1427,9 @@ func (c *autoDeserializeServiceClient) ReceiveRawOptionalExample(ctx context.Con var returnVal types.RawOptionalExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveRawOptionalExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveRawOptionalExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveRawOptionalExample failed") } return returnVal, nil @@ -1541,10 +1440,9 @@ func (c *autoDeserializeServiceClient) ReceiveStringAliasExample(ctx context.Con var returnVal *types.StringAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveStringAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveStringAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveStringAliasExample failed") } if returnVal == nil { @@ -1558,10 +1456,9 @@ func (c *autoDeserializeServiceClient) ReceiveDoubleAliasExample(ctx context.Con var returnVal *types.DoubleAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveDoubleAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveDoubleAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveDoubleAliasExample failed") } if returnVal == nil { @@ -1575,10 +1472,9 @@ func (c *autoDeserializeServiceClient) ReceiveIntegerAliasExample(ctx context.Co var returnVal *types.IntegerAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveIntegerAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveIntegerAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveIntegerAliasExample failed") } if returnVal == nil { @@ -1592,10 +1488,9 @@ func (c *autoDeserializeServiceClient) ReceiveBooleanAliasExample(ctx context.Co var returnVal *types.BooleanAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveBooleanAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveBooleanAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveBooleanAliasExample failed") } if returnVal == nil { @@ -1609,10 +1504,9 @@ func (c *autoDeserializeServiceClient) ReceiveSafeLongAliasExample(ctx context.C var returnVal *types.SafeLongAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveSafeLongAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveSafeLongAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveSafeLongAliasExample failed") } if returnVal == nil { @@ -1626,10 +1520,9 @@ func (c *autoDeserializeServiceClient) ReceiveRidAliasExample(ctx context.Contex var returnVal *types.RidAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveRidAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveRidAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveRidAliasExample failed") } if returnVal == nil { @@ -1643,10 +1536,9 @@ func (c *autoDeserializeServiceClient) ReceiveBearerTokenAliasExample(ctx contex var returnVal *types.BearerTokenAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveBearerTokenAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveBearerTokenAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveBearerTokenAliasExample failed") } if returnVal == nil { @@ -1660,10 +1552,9 @@ func (c *autoDeserializeServiceClient) ReceiveUuidAliasExample(ctx context.Conte var returnVal *types.UuidAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveUuidAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveUuidAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveUuidAliasExample failed") } if returnVal == nil { @@ -1677,10 +1568,9 @@ func (c *autoDeserializeServiceClient) ReceiveReferenceAliasExample(ctx context. var returnVal *types.ReferenceAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveReferenceAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveReferenceAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveReferenceAliasExample failed") } if returnVal == nil { @@ -1694,10 +1584,9 @@ func (c *autoDeserializeServiceClient) ReceiveDateTimeAliasExample(ctx context.C var returnVal *types.DateTimeAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveDateTimeAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveDateTimeAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveDateTimeAliasExample failed") } if returnVal == nil { @@ -1709,10 +1598,9 @@ func (c *autoDeserializeServiceClient) ReceiveDateTimeAliasExample(ctx context.C func (c *autoDeserializeServiceClient) ReceiveBinaryAliasExample(ctx context.Context, indexArg int) (io.ReadCloser, error) { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveBinaryAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveBinaryAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithRawResponseBody()) - resp, err := c.client.Do(ctx, requestParams...) + resp, err := c.client.Get(ctx, requestParams...) if err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveBinaryAliasExample failed") } @@ -1724,10 +1612,9 @@ func (c *autoDeserializeServiceClient) ReceiveKebabCaseObjectExample(ctx context var returnVal *types.KebabCaseObjectExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveKebabCaseObjectExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveKebabCaseObjectExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveKebabCaseObjectExample failed") } if returnVal == nil { @@ -1741,10 +1628,9 @@ func (c *autoDeserializeServiceClient) ReceiveSnakeCaseObjectExample(ctx context var returnVal *types.SnakeCaseObjectExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveSnakeCaseObjectExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveSnakeCaseObjectExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveSnakeCaseObjectExample failed") } if returnVal == nil { @@ -1758,10 +1644,9 @@ func (c *autoDeserializeServiceClient) ReceiveOptionalBearerTokenAliasExample(ct var returnVal types.OptionalBearerTokenAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveOptionalBearerTokenAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveOptionalBearerTokenAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveOptionalBearerTokenAliasExample failed") } return returnVal, nil @@ -1772,10 +1657,9 @@ func (c *autoDeserializeServiceClient) ReceiveOptionalBooleanAliasExample(ctx co var returnVal types.OptionalBooleanAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveOptionalBooleanAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveOptionalBooleanAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveOptionalBooleanAliasExample failed") } return returnVal, nil @@ -1786,10 +1670,9 @@ func (c *autoDeserializeServiceClient) ReceiveOptionalDateTimeAliasExample(ctx c var returnVal types.OptionalDateTimeAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveOptionalDateTimeAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveOptionalDateTimeAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveOptionalDateTimeAliasExample failed") } return returnVal, nil @@ -1800,10 +1683,9 @@ func (c *autoDeserializeServiceClient) ReceiveOptionalDoubleAliasExample(ctx con var returnVal types.OptionalDoubleAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveOptionalDoubleAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveOptionalDoubleAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveOptionalDoubleAliasExample failed") } return returnVal, nil @@ -1814,10 +1696,9 @@ func (c *autoDeserializeServiceClient) ReceiveOptionalIntegerAliasExample(ctx co var returnVal types.OptionalIntegerAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveOptionalIntegerAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveOptionalIntegerAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveOptionalIntegerAliasExample failed") } return returnVal, nil @@ -1828,10 +1709,9 @@ func (c *autoDeserializeServiceClient) ReceiveOptionalRidAliasExample(ctx contex var returnVal types.OptionalRidAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveOptionalRidAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveOptionalRidAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveOptionalRidAliasExample failed") } return returnVal, nil @@ -1842,10 +1722,9 @@ func (c *autoDeserializeServiceClient) ReceiveOptionalSafeLongAliasExample(ctx c var returnVal types.OptionalSafeLongAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveOptionalSafeLongAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveOptionalSafeLongAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveOptionalSafeLongAliasExample failed") } return returnVal, nil @@ -1856,10 +1735,9 @@ func (c *autoDeserializeServiceClient) ReceiveOptionalStringAliasExample(ctx con var returnVal types.OptionalStringAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveOptionalStringAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveOptionalStringAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveOptionalStringAliasExample failed") } return returnVal, nil @@ -1870,10 +1748,9 @@ func (c *autoDeserializeServiceClient) ReceiveOptionalUuidAliasExample(ctx conte var returnVal types.OptionalUuidAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveOptionalUuidAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveOptionalUuidAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveOptionalUuidAliasExample failed") } return returnVal, nil @@ -1884,10 +1761,9 @@ func (c *autoDeserializeServiceClient) ReceiveOptionalAnyAliasExample(ctx contex var returnVal types.OptionalAnyAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveOptionalAnyAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveOptionalAnyAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "receiveOptionalAnyAliasExample failed") } return returnVal, nil @@ -1897,10 +1773,9 @@ func (c *autoDeserializeServiceClient) ReceiveListBearerTokenAliasExample(ctx co var returnVal types.ListBearerTokenAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveListBearerTokenAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveListBearerTokenAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveListBearerTokenAliasExample failed") } if returnVal == nil { @@ -1913,10 +1788,9 @@ func (c *autoDeserializeServiceClient) ReceiveListBinaryAliasExample(ctx context var returnVal types.ListBinaryAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveListBinaryAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveListBinaryAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveListBinaryAliasExample failed") } if returnVal == nil { @@ -1929,10 +1803,9 @@ func (c *autoDeserializeServiceClient) ReceiveListBooleanAliasExample(ctx contex var returnVal types.ListBooleanAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveListBooleanAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveListBooleanAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveListBooleanAliasExample failed") } if returnVal == nil { @@ -1945,10 +1818,9 @@ func (c *autoDeserializeServiceClient) ReceiveListDateTimeAliasExample(ctx conte var returnVal types.ListDateTimeAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveListDateTimeAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveListDateTimeAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveListDateTimeAliasExample failed") } if returnVal == nil { @@ -1961,10 +1833,9 @@ func (c *autoDeserializeServiceClient) ReceiveListDoubleAliasExample(ctx context var returnVal types.ListDoubleAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveListDoubleAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveListDoubleAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveListDoubleAliasExample failed") } if returnVal == nil { @@ -1977,10 +1848,9 @@ func (c *autoDeserializeServiceClient) ReceiveListIntegerAliasExample(ctx contex var returnVal types.ListIntegerAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveListIntegerAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveListIntegerAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveListIntegerAliasExample failed") } if returnVal == nil { @@ -1993,10 +1863,9 @@ func (c *autoDeserializeServiceClient) ReceiveListRidAliasExample(ctx context.Co var returnVal types.ListRidAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveListRidAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveListRidAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveListRidAliasExample failed") } if returnVal == nil { @@ -2009,10 +1878,9 @@ func (c *autoDeserializeServiceClient) ReceiveListSafeLongAliasExample(ctx conte var returnVal types.ListSafeLongAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveListSafeLongAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveListSafeLongAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveListSafeLongAliasExample failed") } if returnVal == nil { @@ -2025,10 +1893,9 @@ func (c *autoDeserializeServiceClient) ReceiveListStringAliasExample(ctx context var returnVal types.ListStringAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveListStringAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveListStringAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveListStringAliasExample failed") } if returnVal == nil { @@ -2041,10 +1908,9 @@ func (c *autoDeserializeServiceClient) ReceiveListUuidAliasExample(ctx context.C var returnVal types.ListUuidAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveListUuidAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveListUuidAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveListUuidAliasExample failed") } if returnVal == nil { @@ -2057,10 +1923,9 @@ func (c *autoDeserializeServiceClient) ReceiveListAnyAliasExample(ctx context.Co var returnVal types.ListAnyAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveListAnyAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveListAnyAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveListAnyAliasExample failed") } if returnVal == nil { @@ -2073,10 +1938,9 @@ func (c *autoDeserializeServiceClient) ReceiveListOptionalAnyAliasExample(ctx co var returnVal types.ListOptionalAnyAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveListOptionalAnyAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveListOptionalAnyAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveListOptionalAnyAliasExample failed") } if returnVal == nil { @@ -2089,10 +1953,9 @@ func (c *autoDeserializeServiceClient) ReceiveSetBearerTokenAliasExample(ctx con var returnVal types.SetBearerTokenAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveSetBearerTokenAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveSetBearerTokenAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveSetBearerTokenAliasExample failed") } if returnVal == nil { @@ -2105,10 +1968,9 @@ func (c *autoDeserializeServiceClient) ReceiveSetBinaryAliasExample(ctx context. var returnVal types.SetBinaryAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveSetBinaryAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveSetBinaryAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveSetBinaryAliasExample failed") } if returnVal == nil { @@ -2121,10 +1983,9 @@ func (c *autoDeserializeServiceClient) ReceiveSetBooleanAliasExample(ctx context var returnVal types.SetBooleanAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveSetBooleanAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveSetBooleanAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveSetBooleanAliasExample failed") } if returnVal == nil { @@ -2137,10 +1998,9 @@ func (c *autoDeserializeServiceClient) ReceiveSetDateTimeAliasExample(ctx contex var returnVal types.SetDateTimeAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveSetDateTimeAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveSetDateTimeAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveSetDateTimeAliasExample failed") } if returnVal == nil { @@ -2153,10 +2013,9 @@ func (c *autoDeserializeServiceClient) ReceiveSetDoubleAliasExample(ctx context. var returnVal types.SetDoubleAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveSetDoubleAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveSetDoubleAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveSetDoubleAliasExample failed") } if returnVal == nil { @@ -2169,10 +2028,9 @@ func (c *autoDeserializeServiceClient) ReceiveSetIntegerAliasExample(ctx context var returnVal types.SetIntegerAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveSetIntegerAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveSetIntegerAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveSetIntegerAliasExample failed") } if returnVal == nil { @@ -2185,10 +2043,9 @@ func (c *autoDeserializeServiceClient) ReceiveSetRidAliasExample(ctx context.Con var returnVal types.SetRidAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveSetRidAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveSetRidAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveSetRidAliasExample failed") } if returnVal == nil { @@ -2201,10 +2058,9 @@ func (c *autoDeserializeServiceClient) ReceiveSetSafeLongAliasExample(ctx contex var returnVal types.SetSafeLongAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveSetSafeLongAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveSetSafeLongAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveSetSafeLongAliasExample failed") } if returnVal == nil { @@ -2217,10 +2073,9 @@ func (c *autoDeserializeServiceClient) ReceiveSetStringAliasExample(ctx context. var returnVal types.SetStringAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveSetStringAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveSetStringAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveSetStringAliasExample failed") } if returnVal == nil { @@ -2233,10 +2088,9 @@ func (c *autoDeserializeServiceClient) ReceiveSetUuidAliasExample(ctx context.Co var returnVal types.SetUuidAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveSetUuidAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveSetUuidAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveSetUuidAliasExample failed") } if returnVal == nil { @@ -2249,10 +2103,9 @@ func (c *autoDeserializeServiceClient) ReceiveSetAnyAliasExample(ctx context.Con var returnVal types.SetAnyAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveSetAnyAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveSetAnyAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveSetAnyAliasExample failed") } if returnVal == nil { @@ -2265,10 +2118,9 @@ func (c *autoDeserializeServiceClient) ReceiveSetOptionalAnyAliasExample(ctx con var returnVal types.SetOptionalAnyAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveSetOptionalAnyAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveSetOptionalAnyAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveSetOptionalAnyAliasExample failed") } if returnVal == nil { @@ -2281,10 +2133,9 @@ func (c *autoDeserializeServiceClient) ReceiveMapBearerTokenAliasExample(ctx con var returnVal types.MapBearerTokenAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveMapBearerTokenAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveMapBearerTokenAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveMapBearerTokenAliasExample failed") } if returnVal == nil { @@ -2297,10 +2148,9 @@ func (c *autoDeserializeServiceClient) ReceiveMapBinaryAliasExample(ctx context. var returnVal types.MapBinaryAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveMapBinaryAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveMapBinaryAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveMapBinaryAliasExample failed") } if returnVal == nil { @@ -2313,10 +2163,9 @@ func (c *autoDeserializeServiceClient) ReceiveMapBooleanAliasExample(ctx context var returnVal types.MapBooleanAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveMapBooleanAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveMapBooleanAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveMapBooleanAliasExample failed") } if returnVal == nil { @@ -2329,10 +2178,9 @@ func (c *autoDeserializeServiceClient) ReceiveMapDateTimeAliasExample(ctx contex var returnVal types.MapDateTimeAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveMapDateTimeAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveMapDateTimeAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveMapDateTimeAliasExample failed") } if returnVal == nil { @@ -2345,10 +2193,9 @@ func (c *autoDeserializeServiceClient) ReceiveMapDoubleAliasExample(ctx context. var returnVal types.MapDoubleAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveMapDoubleAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveMapDoubleAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveMapDoubleAliasExample failed") } if returnVal == nil { @@ -2361,10 +2208,9 @@ func (c *autoDeserializeServiceClient) ReceiveMapIntegerAliasExample(ctx context var returnVal types.MapIntegerAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveMapIntegerAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveMapIntegerAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveMapIntegerAliasExample failed") } if returnVal == nil { @@ -2377,10 +2223,9 @@ func (c *autoDeserializeServiceClient) ReceiveMapRidAliasExample(ctx context.Con var returnVal types.MapRidAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveMapRidAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveMapRidAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveMapRidAliasExample failed") } if returnVal == nil { @@ -2393,10 +2238,9 @@ func (c *autoDeserializeServiceClient) ReceiveMapSafeLongAliasExample(ctx contex var returnVal types.MapSafeLongAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveMapSafeLongAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveMapSafeLongAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveMapSafeLongAliasExample failed") } if returnVal == nil { @@ -2409,10 +2253,9 @@ func (c *autoDeserializeServiceClient) ReceiveMapStringAliasExample(ctx context. var returnVal types.MapStringAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveMapStringAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveMapStringAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveMapStringAliasExample failed") } if returnVal == nil { @@ -2425,10 +2268,9 @@ func (c *autoDeserializeServiceClient) ReceiveMapUuidAliasExample(ctx context.Co var returnVal types.MapUuidAliasExample var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveMapUuidAliasExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveMapUuidAliasExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveMapUuidAliasExample failed") } if returnVal == nil { @@ -2441,10 +2283,9 @@ func (c *autoDeserializeServiceClient) ReceiveMapEnumExampleAlias(ctx context.Co var returnVal types.MapEnumExampleAlias var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("ReceiveMapEnumExampleAlias")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/body/receiveMapEnumExampleAlias/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "receiveMapEnumExampleAlias failed") } if returnVal == nil { @@ -2479,10 +2320,9 @@ func NewSingleHeaderServiceClient(client httpclient.Client) SingleHeaderServiceC func (c *singleHeaderServiceClient) HeaderBearertoken(ctx context.Context, indexArg int, headerArg bearertoken.Token) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("HeaderBearertoken")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/single-header-param/headerBearertoken/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithHeader("Some-Header", fmt.Sprint(headerArg))) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "headerBearertoken failed") } return nil @@ -2491,10 +2331,9 @@ func (c *singleHeaderServiceClient) HeaderBearertoken(ctx context.Context, index func (c *singleHeaderServiceClient) HeaderBoolean(ctx context.Context, indexArg int, headerArg bool) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("HeaderBoolean")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/single-header-param/headerBoolean/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithHeader("Some-Header", fmt.Sprint(headerArg))) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "headerBoolean failed") } return nil @@ -2503,10 +2342,9 @@ func (c *singleHeaderServiceClient) HeaderBoolean(ctx context.Context, indexArg func (c *singleHeaderServiceClient) HeaderDatetime(ctx context.Context, indexArg int, headerArg datetime.DateTime) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("HeaderDatetime")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/single-header-param/headerDatetime/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithHeader("Some-Header", fmt.Sprint(headerArg))) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "headerDatetime failed") } return nil @@ -2515,10 +2353,9 @@ func (c *singleHeaderServiceClient) HeaderDatetime(ctx context.Context, indexArg func (c *singleHeaderServiceClient) HeaderDouble(ctx context.Context, indexArg int, headerArg float64) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("HeaderDouble")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/single-header-param/headerDouble/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithHeader("Some-Header", fmt.Sprint(headerArg))) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "headerDouble failed") } return nil @@ -2527,10 +2364,9 @@ func (c *singleHeaderServiceClient) HeaderDouble(ctx context.Context, indexArg i func (c *singleHeaderServiceClient) HeaderInteger(ctx context.Context, indexArg int, headerArg int) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("HeaderInteger")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/single-header-param/headerInteger/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithHeader("Some-Header", fmt.Sprint(headerArg))) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "headerInteger failed") } return nil @@ -2539,10 +2375,9 @@ func (c *singleHeaderServiceClient) HeaderInteger(ctx context.Context, indexArg func (c *singleHeaderServiceClient) HeaderRid(ctx context.Context, indexArg int, headerArg rid.ResourceIdentifier) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("HeaderRid")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/single-header-param/headerRid/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithHeader("Some-Header", fmt.Sprint(headerArg))) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "headerRid failed") } return nil @@ -2551,10 +2386,9 @@ func (c *singleHeaderServiceClient) HeaderRid(ctx context.Context, indexArg int, func (c *singleHeaderServiceClient) HeaderSafelong(ctx context.Context, indexArg int, headerArg safelong.SafeLong) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("HeaderSafelong")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/single-header-param/headerSafelong/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithHeader("Some-Header", fmt.Sprint(headerArg))) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "headerSafelong failed") } return nil @@ -2563,10 +2397,9 @@ func (c *singleHeaderServiceClient) HeaderSafelong(ctx context.Context, indexArg func (c *singleHeaderServiceClient) HeaderString(ctx context.Context, indexArg int, headerArg string) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("HeaderString")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/single-header-param/headerString/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithHeader("Some-Header", fmt.Sprint(headerArg))) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "headerString failed") } return nil @@ -2575,10 +2408,9 @@ func (c *singleHeaderServiceClient) HeaderString(ctx context.Context, indexArg i func (c *singleHeaderServiceClient) HeaderUuid(ctx context.Context, indexArg int, headerArg uuid.UUID) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("HeaderUuid")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/single-header-param/headerUuid/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithHeader("Some-Header", fmt.Sprint(headerArg))) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "headerUuid failed") } return nil @@ -2587,12 +2419,11 @@ func (c *singleHeaderServiceClient) HeaderUuid(ctx context.Context, indexArg int func (c *singleHeaderServiceClient) HeaderOptionalOfString(ctx context.Context, indexArg int, headerArg *string) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("HeaderOptionalOfString")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/single-header-param/headerOptionalOfString/%s", url.PathEscape(fmt.Sprint(indexArg)))) if headerArg != nil { requestParams = append(requestParams, httpclient.WithHeader("Some-Header", fmt.Sprint(*headerArg))) } - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "headerOptionalOfString failed") } return nil @@ -2601,10 +2432,9 @@ func (c *singleHeaderServiceClient) HeaderOptionalOfString(ctx context.Context, func (c *singleHeaderServiceClient) HeaderAliasString(ctx context.Context, indexArg int, headerArg types.AliasString) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("HeaderAliasString")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/single-header-param/headerAliasString/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithHeader("Some-Header", fmt.Sprint(headerArg))) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "headerAliasString failed") } return nil @@ -2613,10 +2443,9 @@ func (c *singleHeaderServiceClient) HeaderAliasString(ctx context.Context, index func (c *singleHeaderServiceClient) HeaderEnumExample(ctx context.Context, indexArg int, headerArg types.EnumExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("HeaderEnumExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/single-header-param/headerEnumExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) requestParams = append(requestParams, httpclient.WithHeader("Some-Header", fmt.Sprint(headerArg))) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "headerEnumExample failed") } return nil @@ -2646,9 +2475,8 @@ func NewSinglePathParamServiceClient(client httpclient.Client) SinglePathParamSe func (c *singlePathParamServiceClient) PathParamBoolean(ctx context.Context, indexArg int, paramArg bool) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("PathParamBoolean")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/single-path-param/pathParamBoolean/%s/%s", url.PathEscape(fmt.Sprint(indexArg)), url.PathEscape(fmt.Sprint(paramArg)))) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "pathParamBoolean failed") } return nil @@ -2657,9 +2485,8 @@ func (c *singlePathParamServiceClient) PathParamBoolean(ctx context.Context, ind func (c *singlePathParamServiceClient) PathParamDatetime(ctx context.Context, indexArg int, paramArg datetime.DateTime) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("PathParamDatetime")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/single-path-param/pathParamDatetime/%s/%s", url.PathEscape(fmt.Sprint(indexArg)), url.PathEscape(fmt.Sprint(paramArg)))) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "pathParamDatetime failed") } return nil @@ -2668,9 +2495,8 @@ func (c *singlePathParamServiceClient) PathParamDatetime(ctx context.Context, in func (c *singlePathParamServiceClient) PathParamDouble(ctx context.Context, indexArg int, paramArg float64) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("PathParamDouble")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/single-path-param/pathParamDouble/%s/%s", url.PathEscape(fmt.Sprint(indexArg)), url.PathEscape(fmt.Sprint(paramArg)))) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "pathParamDouble failed") } return nil @@ -2679,9 +2505,8 @@ func (c *singlePathParamServiceClient) PathParamDouble(ctx context.Context, inde func (c *singlePathParamServiceClient) PathParamInteger(ctx context.Context, indexArg int, paramArg int) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("PathParamInteger")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/single-path-param/pathParamInteger/%s/%s", url.PathEscape(fmt.Sprint(indexArg)), url.PathEscape(fmt.Sprint(paramArg)))) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "pathParamInteger failed") } return nil @@ -2690,9 +2515,8 @@ func (c *singlePathParamServiceClient) PathParamInteger(ctx context.Context, ind func (c *singlePathParamServiceClient) PathParamRid(ctx context.Context, indexArg int, paramArg rid.ResourceIdentifier) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("PathParamRid")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/single-path-param/pathParamRid/%s/%s", url.PathEscape(fmt.Sprint(indexArg)), url.PathEscape(fmt.Sprint(paramArg)))) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "pathParamRid failed") } return nil @@ -2701,9 +2525,8 @@ func (c *singlePathParamServiceClient) PathParamRid(ctx context.Context, indexAr func (c *singlePathParamServiceClient) PathParamSafelong(ctx context.Context, indexArg int, paramArg safelong.SafeLong) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("PathParamSafelong")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/single-path-param/pathParamSafelong/%s/%s", url.PathEscape(fmt.Sprint(indexArg)), url.PathEscape(fmt.Sprint(paramArg)))) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "pathParamSafelong failed") } return nil @@ -2712,9 +2535,8 @@ func (c *singlePathParamServiceClient) PathParamSafelong(ctx context.Context, in func (c *singlePathParamServiceClient) PathParamString(ctx context.Context, indexArg int, paramArg string) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("PathParamString")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/single-path-param/pathParamString/%s/%s", url.PathEscape(fmt.Sprint(indexArg)), url.PathEscape(fmt.Sprint(paramArg)))) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "pathParamString failed") } return nil @@ -2723,9 +2545,8 @@ func (c *singlePathParamServiceClient) PathParamString(ctx context.Context, inde func (c *singlePathParamServiceClient) PathParamUuid(ctx context.Context, indexArg int, paramArg uuid.UUID) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("PathParamUuid")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/single-path-param/pathParamUuid/%s/%s", url.PathEscape(fmt.Sprint(indexArg)), url.PathEscape(fmt.Sprint(paramArg)))) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "pathParamUuid failed") } return nil @@ -2734,9 +2555,8 @@ func (c *singlePathParamServiceClient) PathParamUuid(ctx context.Context, indexA func (c *singlePathParamServiceClient) PathParamAliasString(ctx context.Context, indexArg int, paramArg types.AliasString) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("PathParamAliasString")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/single-path-param/pathParamAliasString/%s/%s", url.PathEscape(fmt.Sprint(indexArg)), url.PathEscape(fmt.Sprint(paramArg)))) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "pathParamAliasString failed") } return nil @@ -2745,9 +2565,8 @@ func (c *singlePathParamServiceClient) PathParamAliasString(ctx context.Context, func (c *singlePathParamServiceClient) PathParamEnumExample(ctx context.Context, indexArg int, paramArg types.EnumExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("PathParamEnumExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/single-path-param/pathParamEnumExample/%s/%s", url.PathEscape(fmt.Sprint(indexArg)), url.PathEscape(fmt.Sprint(paramArg)))) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "pathParamEnumExample failed") } return nil @@ -2777,12 +2596,11 @@ func NewSingleQueryParamServiceClient(client httpclient.Client) SingleQueryParam func (c *singleQueryParamServiceClient) QueryParamBoolean(ctx context.Context, indexArg int, someQueryArg bool) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("QueryParamBoolean")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/single-query-param/queryParamBoolean/%s", url.PathEscape(fmt.Sprint(indexArg)))) queryParams := make(url.Values) queryParams.Set("foo", fmt.Sprint(someQueryArg)) requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "queryParamBoolean failed") } return nil @@ -2791,12 +2609,11 @@ func (c *singleQueryParamServiceClient) QueryParamBoolean(ctx context.Context, i func (c *singleQueryParamServiceClient) QueryParamDouble(ctx context.Context, indexArg int, someQueryArg float64) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("QueryParamDouble")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/single-query-param/queryParamDouble/%s", url.PathEscape(fmt.Sprint(indexArg)))) queryParams := make(url.Values) queryParams.Set("foo", fmt.Sprint(someQueryArg)) requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "queryParamDouble failed") } return nil @@ -2805,12 +2622,11 @@ func (c *singleQueryParamServiceClient) QueryParamDouble(ctx context.Context, in func (c *singleQueryParamServiceClient) QueryParamInteger(ctx context.Context, indexArg int, someQueryArg int) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("QueryParamInteger")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/single-query-param/queryParamInteger/%s", url.PathEscape(fmt.Sprint(indexArg)))) queryParams := make(url.Values) queryParams.Set("foo", fmt.Sprint(someQueryArg)) requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "queryParamInteger failed") } return nil @@ -2819,12 +2635,11 @@ func (c *singleQueryParamServiceClient) QueryParamInteger(ctx context.Context, i func (c *singleQueryParamServiceClient) QueryParamRid(ctx context.Context, indexArg int, someQueryArg rid.ResourceIdentifier) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("QueryParamRid")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/single-query-param/queryParamRid/%s", url.PathEscape(fmt.Sprint(indexArg)))) queryParams := make(url.Values) queryParams.Set("foo", fmt.Sprint(someQueryArg)) requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "queryParamRid failed") } return nil @@ -2833,12 +2648,11 @@ func (c *singleQueryParamServiceClient) QueryParamRid(ctx context.Context, index func (c *singleQueryParamServiceClient) QueryParamSafelong(ctx context.Context, indexArg int, someQueryArg safelong.SafeLong) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("QueryParamSafelong")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/single-query-param/queryParamSafelong/%s", url.PathEscape(fmt.Sprint(indexArg)))) queryParams := make(url.Values) queryParams.Set("foo", fmt.Sprint(someQueryArg)) requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "queryParamSafelong failed") } return nil @@ -2847,12 +2661,11 @@ func (c *singleQueryParamServiceClient) QueryParamSafelong(ctx context.Context, func (c *singleQueryParamServiceClient) QueryParamString(ctx context.Context, indexArg int, someQueryArg string) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("QueryParamString")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/single-query-param/queryParamString/%s", url.PathEscape(fmt.Sprint(indexArg)))) queryParams := make(url.Values) queryParams.Set("foo", fmt.Sprint(someQueryArg)) requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "queryParamString failed") } return nil @@ -2861,12 +2674,11 @@ func (c *singleQueryParamServiceClient) QueryParamString(ctx context.Context, in func (c *singleQueryParamServiceClient) QueryParamUuid(ctx context.Context, indexArg int, someQueryArg uuid.UUID) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("QueryParamUuid")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/single-query-param/queryParamUuid/%s", url.PathEscape(fmt.Sprint(indexArg)))) queryParams := make(url.Values) queryParams.Set("foo", fmt.Sprint(someQueryArg)) requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "queryParamUuid failed") } return nil @@ -2875,14 +2687,13 @@ func (c *singleQueryParamServiceClient) QueryParamUuid(ctx context.Context, inde func (c *singleQueryParamServiceClient) QueryParamOptionalOfString(ctx context.Context, indexArg int, someQueryArg *string) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("QueryParamOptionalOfString")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/single-query-param/queryParamOptionalOfString/%s", url.PathEscape(fmt.Sprint(indexArg)))) queryParams := make(url.Values) if someQueryArg != nil { queryParams.Set("foo", fmt.Sprint(*someQueryArg)) } requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "queryParamOptionalOfString failed") } return nil @@ -2891,12 +2702,11 @@ func (c *singleQueryParamServiceClient) QueryParamOptionalOfString(ctx context.C func (c *singleQueryParamServiceClient) QueryParamAliasString(ctx context.Context, indexArg int, someQueryArg types.AliasString) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("QueryParamAliasString")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/single-query-param/queryParamAliasString/%s", url.PathEscape(fmt.Sprint(indexArg)))) queryParams := make(url.Values) queryParams.Set("foo", fmt.Sprint(someQueryArg)) requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "queryParamAliasString failed") } return nil @@ -2905,12 +2715,11 @@ func (c *singleQueryParamServiceClient) QueryParamAliasString(ctx context.Contex func (c *singleQueryParamServiceClient) QueryParamEnumExample(ctx context.Context, indexArg int, someQueryArg types.EnumExample) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("QueryParamEnumExample")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/single-query-param/queryParamEnumExample/%s", url.PathEscape(fmt.Sprint(indexArg)))) queryParams := make(url.Values) queryParams.Set("foo", fmt.Sprint(someQueryArg)) requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "queryParamEnumExample failed") } return nil diff --git a/conjure/cycles/testdata/cycle-within-pkg/conjure/com/palantir/services/services.conjure.go b/conjure/cycles/testdata/cycle-within-pkg/conjure/com/palantir/services/services.conjure.go index 6f7f3286b..384b55247 100644 --- a/conjure/cycles/testdata/cycle-within-pkg/conjure/com/palantir/services/services.conjure.go +++ b/conjure/cycles/testdata/cycle-within-pkg/conjure/com/palantir/services/services.conjure.go @@ -32,11 +32,10 @@ func (c *myServiceClient) Endpoint1(ctx context.Context, authHeader bearertoken. var returnVal *foo.Type4 var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("Endpoint1")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithHeader("Authorization", fmt.Sprint("Bearer ", authHeader))) requestParams = append(requestParams, httpclient.WithPathf("/endpoint1", url.PathEscape(fmt.Sprint(arg1Arg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "Endpoint1 failed") } if returnVal == nil { @@ -48,11 +47,10 @@ func (c *myServiceClient) Endpoint1(ctx context.Context, authHeader bearertoken. func (c *myServiceClient) Endpoint2(ctx context.Context, authHeader bearertoken.Token, arg1Arg foo.Type1) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("Endpoint2")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithHeader("Authorization", fmt.Sprint("Bearer ", authHeader))) requestParams = append(requestParams, httpclient.WithPathf("/endpoint2")) requestParams = append(requestParams, httpclient.WithJSONRequest(arg1Arg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "Endpoint2 failed") } return nil diff --git a/conjure/cycles/testdata/no-cycles/conjure/com/palantir/services/services.conjure.go b/conjure/cycles/testdata/no-cycles/conjure/com/palantir/services/services.conjure.go index f90a02bb0..451254229 100644 --- a/conjure/cycles/testdata/no-cycles/conjure/com/palantir/services/services.conjure.go +++ b/conjure/cycles/testdata/no-cycles/conjure/com/palantir/services/services.conjure.go @@ -32,11 +32,10 @@ func (c *myServiceClient) Endpoint1(ctx context.Context, authHeader bearertoken. var returnVal *foo.Type4 var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("Endpoint1")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithHeader("Authorization", fmt.Sprint("Bearer ", authHeader))) requestParams = append(requestParams, httpclient.WithPathf("/endpoint1", url.PathEscape(fmt.Sprint(arg1Arg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "Endpoint1 failed") } if returnVal == nil { @@ -48,11 +47,10 @@ func (c *myServiceClient) Endpoint1(ctx context.Context, authHeader bearertoken. func (c *myServiceClient) Endpoint2(ctx context.Context, authHeader bearertoken.Token, arg1Arg foo.Type1) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("Endpoint2")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithHeader("Authorization", fmt.Sprint("Bearer ", authHeader))) requestParams = append(requestParams, httpclient.WithPathf("/endpoint2")) requestParams = append(requestParams, httpclient.WithJSONRequest(arg1Arg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "Endpoint2 failed") } return nil diff --git a/conjure/cycles/testdata/pkg-cycle-disconnected/conjure/com/palantir/services/services.conjure.go b/conjure/cycles/testdata/pkg-cycle-disconnected/conjure/com/palantir/services/services.conjure.go index 9d2111db4..2bdfe9e9e 100644 --- a/conjure/cycles/testdata/pkg-cycle-disconnected/conjure/com/palantir/services/services.conjure.go +++ b/conjure/cycles/testdata/pkg-cycle-disconnected/conjure/com/palantir/services/services.conjure.go @@ -33,11 +33,10 @@ func (c *myServiceClient) Endpoint1(ctx context.Context, authHeader bearertoken. var returnVal *foo.Type4 var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("Endpoint1")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithHeader("Authorization", fmt.Sprint("Bearer ", authHeader))) requestParams = append(requestParams, httpclient.WithPathf("/endpoint1", url.PathEscape(fmt.Sprint(arg1Arg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "Endpoint1 failed") } if returnVal == nil { @@ -49,11 +48,10 @@ func (c *myServiceClient) Endpoint1(ctx context.Context, authHeader bearertoken. func (c *myServiceClient) Endpoint2(ctx context.Context, authHeader bearertoken.Token, arg1Arg foo1.Type1) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("Endpoint2")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithHeader("Authorization", fmt.Sprint("Bearer ", authHeader))) requestParams = append(requestParams, httpclient.WithPathf("/endpoint2")) requestParams = append(requestParams, httpclient.WithJSONRequest(arg1Arg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "Endpoint2 failed") } return nil diff --git a/conjure/cycles/testdata/pkg-cycle/conjure/com/palantir/services/services.conjure.go b/conjure/cycles/testdata/pkg-cycle/conjure/com/palantir/services/services.conjure.go index 695e63614..e18101351 100644 --- a/conjure/cycles/testdata/pkg-cycle/conjure/com/palantir/services/services.conjure.go +++ b/conjure/cycles/testdata/pkg-cycle/conjure/com/palantir/services/services.conjure.go @@ -33,11 +33,10 @@ func (c *myServiceClient) Endpoint1(ctx context.Context, authHeader bearertoken. var returnVal *foo.Type4 var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("Endpoint1")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithHeader("Authorization", fmt.Sprint("Bearer ", authHeader))) requestParams = append(requestParams, httpclient.WithPathf("/endpoint1", url.PathEscape(fmt.Sprint(arg1Arg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "Endpoint1 failed") } if returnVal == nil { @@ -49,11 +48,10 @@ func (c *myServiceClient) Endpoint1(ctx context.Context, authHeader bearertoken. func (c *myServiceClient) Endpoint2(ctx context.Context, authHeader bearertoken.Token, arg1Arg foo1.Type1) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("Endpoint2")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithHeader("Authorization", fmt.Sprint("Bearer ", authHeader))) requestParams = append(requestParams, httpclient.WithPathf("/endpoint2")) requestParams = append(requestParams, httpclient.WithJSONRequest(arg1Arg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "Endpoint2 failed") } return nil diff --git a/conjure/cycles/testdata/type-cycle/conjure/com/palantir/services/services.conjure.go b/conjure/cycles/testdata/type-cycle/conjure/com/palantir/services/services.conjure.go index f37ae793f..fe1831171 100644 --- a/conjure/cycles/testdata/type-cycle/conjure/com/palantir/services/services.conjure.go +++ b/conjure/cycles/testdata/type-cycle/conjure/com/palantir/services/services.conjure.go @@ -33,11 +33,10 @@ func (c *myServiceClient) Endpoint1(ctx context.Context, authHeader bearertoken. var returnVal *barfoo.Type4 var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("Endpoint1")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithHeader("Authorization", fmt.Sprint("Bearer ", authHeader))) requestParams = append(requestParams, httpclient.WithPathf("/endpoint1", url.PathEscape(fmt.Sprint(arg1Arg)))) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "Endpoint1 failed") } if returnVal == nil { @@ -49,11 +48,10 @@ func (c *myServiceClient) Endpoint1(ctx context.Context, authHeader bearertoken. func (c *myServiceClient) Endpoint2(ctx context.Context, authHeader bearertoken.Token, arg1Arg foo.Type1) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("Endpoint2")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithHeader("Authorization", fmt.Sprint("Bearer ", authHeader))) requestParams = append(requestParams, httpclient.WithPathf("/endpoint2")) requestParams = append(requestParams, httpclient.WithJSONRequest(arg1Arg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "Endpoint2 failed") } return nil diff --git a/conjure/servicewriter.go b/conjure/servicewriter.go index 7eab57af1..e498824be 100644 --- a/conjure/servicewriter.go +++ b/conjure/servicewriter.go @@ -17,6 +17,7 @@ package conjure import ( "fmt" "regexp" + "strings" "github.com/dave/jennifer/jen" "github.com/palantir/conjure-go/v6/conjure/snip" @@ -269,7 +270,7 @@ func astForEndpointMethodBodyFunc(methodBody *jen.Group, endpointDef *types.Endp astForEndpointMethodBodyRequestParams(methodBody, endpointDef) // execute request - callStmt := jen.Id(clientReceiverName).Dot(clientStructFieldName).Dot("Do").Call( + callStmt := jen.Id(clientReceiverName).Dot(clientStructFieldName).Dot(httpMethodTitleCase(endpointDef)).Call( jen.Id("ctx"), jen.Id(requestParamsVar).Op("...")) returnErr := jen.ReturnFunc(func(returnVals *jen.Group) { @@ -332,7 +333,10 @@ func astForEndpointMethodBodyRequestParams(methodBody *jen.Group, endpointDef *t } appendRequestParams(methodBody, snip.CGRClientWithRPCMethodName().Call(jen.Lit(transforms.Export(endpointDef.EndpointName)))) - appendRequestParams(methodBody, snip.CGRClientWithRequestMethod().Call(jen.Lit(endpointDef.HTTPMethod.String()))) + // If the endpoint has an unimplemented HTTP method, add the param. + if endpointDef.HTTPMethod.IsUnknown() { + appendRequestParams(methodBody, snip.CGRClientWithRequestMethod().Call(jen.Lit(endpointDef.HTTPMethod.String()))) + } // auth params if endpointDef.HeaderAuth { appendRequestParams(methodBody, snip.CGRClientWithHeader().Call(jen.Lit("Authorization"), @@ -544,3 +548,11 @@ func withAuthName(name string) string { func withTokenProviderName(name string) string { return name + "WithTokenProvider" } + +func httpMethodTitleCase(endpointDef *types.EndpointDefinition) string { + if endpointDef.HTTPMethod.IsUnknown() { + return "Do" + } + methodUpper := endpointDef.HTTPMethod.String() + return methodUpper[0:1] + strings.ToLower(methodUpper)[1:] +} diff --git a/integration_test/testgenerated/auth/api/services.conjure.go b/integration_test/testgenerated/auth/api/services.conjure.go index ca1ebf7be..406191969 100644 --- a/integration_test/testgenerated/auth/api/services.conjure.go +++ b/integration_test/testgenerated/auth/api/services.conjure.go @@ -33,11 +33,10 @@ func (c *bothAuthServiceClient) Default(ctx context.Context, authHeader bearerto var returnVal *string var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("Default")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithHeader("Authorization", fmt.Sprint("Bearer ", authHeader))) requestParams = append(requestParams, httpclient.WithPathf("/default")) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "default failed") } if returnVal == nil { @@ -49,10 +48,9 @@ func (c *bothAuthServiceClient) Default(ctx context.Context, authHeader bearerto func (c *bothAuthServiceClient) Cookie(ctx context.Context, cookieToken bearertoken.Token) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("Cookie")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithHeader("Cookie", fmt.Sprint("P_TOKEN=", cookieToken))) requestParams = append(requestParams, httpclient.WithPathf("/cookie")) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "cookie failed") } return nil @@ -61,9 +59,8 @@ func (c *bothAuthServiceClient) Cookie(ctx context.Context, cookieToken bearerto func (c *bothAuthServiceClient) None(ctx context.Context) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("None")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/none")) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "none failed") } return nil @@ -72,11 +69,10 @@ func (c *bothAuthServiceClient) None(ctx context.Context) error { func (c *bothAuthServiceClient) WithArg(ctx context.Context, authHeader bearertoken.Token, argArg string) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("WithArg")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithHeader("Authorization", fmt.Sprint("Bearer ", authHeader))) requestParams = append(requestParams, httpclient.WithPathf("/withArg")) requestParams = append(requestParams, httpclient.WithJSONRequest(argArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "withArg failed") } return nil @@ -130,10 +126,9 @@ func NewCookieAuthServiceClient(client httpclient.Client) CookieAuthServiceClien func (c *cookieAuthServiceClient) Cookie(ctx context.Context, cookieToken bearertoken.Token) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("Cookie")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithHeader("Cookie", fmt.Sprint("P_TOKEN=", cookieToken))) requestParams = append(requestParams, httpclient.WithPathf("/cookie")) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "cookie failed") } return nil @@ -192,11 +187,10 @@ func (c *headerAuthServiceClient) Default(ctx context.Context, authHeader bearer var returnVal *string var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("Default")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithHeader("Authorization", fmt.Sprint("Bearer ", authHeader))) requestParams = append(requestParams, httpclient.WithPathf("/default")) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "default failed") } if returnVal == nil { @@ -208,11 +202,10 @@ func (c *headerAuthServiceClient) Default(ctx context.Context, authHeader bearer func (c *headerAuthServiceClient) Binary(ctx context.Context, authHeader bearertoken.Token) (io.ReadCloser, error) { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("Binary")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithHeader("Authorization", fmt.Sprint("Bearer ", authHeader))) requestParams = append(requestParams, httpclient.WithPathf("/binary")) requestParams = append(requestParams, httpclient.WithRawResponseBody()) - resp, err := c.client.Do(ctx, requestParams...) + resp, err := c.client.Get(ctx, requestParams...) if err != nil { return nil, werror.WrapWithContextParams(ctx, err, "binary failed") } @@ -222,11 +215,10 @@ func (c *headerAuthServiceClient) Binary(ctx context.Context, authHeader bearert func (c *headerAuthServiceClient) BinaryOptional(ctx context.Context, authHeader bearertoken.Token) (*io.ReadCloser, error) { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("BinaryOptional")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithHeader("Authorization", fmt.Sprint("Bearer ", authHeader))) requestParams = append(requestParams, httpclient.WithPathf("/binaryOptional")) requestParams = append(requestParams, httpclient.WithRawResponseBody()) - resp, err := c.client.Do(ctx, requestParams...) + resp, err := c.client.Get(ctx, requestParams...) if err != nil { return nil, werror.WrapWithContextParams(ctx, err, "binaryOptional failed") } @@ -317,11 +309,10 @@ func (c *someHeaderAuthServiceClient) Default(ctx context.Context, authHeader be var returnVal *string var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("Default")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithHeader("Authorization", fmt.Sprint("Bearer ", authHeader))) requestParams = append(requestParams, httpclient.WithPathf("/default")) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "default failed") } if returnVal == nil { @@ -333,9 +324,8 @@ func (c *someHeaderAuthServiceClient) Default(ctx context.Context, authHeader be func (c *someHeaderAuthServiceClient) None(ctx context.Context) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("None")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/none")) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "none failed") } return nil diff --git a/integration_test/testgenerated/binary/api/services.conjure.go b/integration_test/testgenerated/binary/api/services.conjure.go index 7376113b5..acae40541 100644 --- a/integration_test/testgenerated/binary/api/services.conjure.go +++ b/integration_test/testgenerated/binary/api/services.conjure.go @@ -33,11 +33,10 @@ func NewTestServiceClient(client httpclient.Client) TestServiceClient { func (c *testServiceClient) BinaryAlias(ctx context.Context, bodyArg func() io.ReadCloser) (io.ReadCloser, error) { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("BinaryAlias")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/binaryAlias")) requestParams = append(requestParams, httpclient.WithRawRequestBodyProvider(bodyArg)) requestParams = append(requestParams, httpclient.WithRawResponseBody()) - resp, err := c.client.Do(ctx, requestParams...) + resp, err := c.client.Post(ctx, requestParams...) if err != nil { return nil, werror.WrapWithContextParams(ctx, err, "binaryAlias failed") } @@ -47,10 +46,9 @@ func (c *testServiceClient) BinaryAlias(ctx context.Context, bodyArg func() io.R func (c *testServiceClient) BinaryAliasOptional(ctx context.Context) (*io.ReadCloser, error) { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("BinaryAliasOptional")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/binaryAliasOptional")) requestParams = append(requestParams, httpclient.WithRawResponseBody()) - resp, err := c.client.Do(ctx, requestParams...) + resp, err := c.client.Post(ctx, requestParams...) if err != nil { return nil, werror.WrapWithContextParams(ctx, err, "binaryAliasOptional failed") } @@ -63,13 +61,12 @@ func (c *testServiceClient) BinaryAliasOptional(ctx context.Context) (*io.ReadCl func (c *testServiceClient) BinaryAliasAlias(ctx context.Context, bodyArg func() io.ReadCloser) (*io.ReadCloser, error) { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("BinaryAliasAlias")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/binaryAliasAlias")) if bodyArg != nil { requestParams = append(requestParams, httpclient.WithRawRequestBodyProvider(bodyArg)) } requestParams = append(requestParams, httpclient.WithRawResponseBody()) - resp, err := c.client.Do(ctx, requestParams...) + resp, err := c.client.Post(ctx, requestParams...) if err != nil { return nil, werror.WrapWithContextParams(ctx, err, "binaryAliasAlias failed") } @@ -82,11 +79,10 @@ func (c *testServiceClient) BinaryAliasAlias(ctx context.Context, bodyArg func() func (c *testServiceClient) Binary(ctx context.Context, bodyArg func() io.ReadCloser) (io.ReadCloser, error) { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("Binary")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/binary")) requestParams = append(requestParams, httpclient.WithRawRequestBodyProvider(bodyArg)) requestParams = append(requestParams, httpclient.WithRawResponseBody()) - resp, err := c.client.Do(ctx, requestParams...) + resp, err := c.client.Post(ctx, requestParams...) if err != nil { return nil, werror.WrapWithContextParams(ctx, err, "binary failed") } @@ -96,10 +92,9 @@ func (c *testServiceClient) Binary(ctx context.Context, bodyArg func() io.ReadCl func (c *testServiceClient) BinaryOptional(ctx context.Context) (*io.ReadCloser, error) { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("BinaryOptional")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/binaryOptional")) requestParams = append(requestParams, httpclient.WithRawResponseBody()) - resp, err := c.client.Do(ctx, requestParams...) + resp, err := c.client.Post(ctx, requestParams...) if err != nil { return nil, werror.WrapWithContextParams(ctx, err, "binaryOptional failed") } @@ -112,13 +107,12 @@ func (c *testServiceClient) BinaryOptional(ctx context.Context) (*io.ReadCloser, func (c *testServiceClient) BinaryOptionalAlias(ctx context.Context, bodyArg func() io.ReadCloser) (*io.ReadCloser, error) { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("BinaryOptionalAlias")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/binaryOptionalAlias")) if bodyArg != nil { requestParams = append(requestParams, httpclient.WithRawRequestBodyProvider(bodyArg)) } requestParams = append(requestParams, httpclient.WithRawResponseBody()) - resp, err := c.client.Do(ctx, requestParams...) + resp, err := c.client.Post(ctx, requestParams...) if err != nil { return nil, werror.WrapWithContextParams(ctx, err, "binaryOptionalAlias failed") } @@ -132,11 +126,10 @@ func (c *testServiceClient) BinaryList(ctx context.Context, bodyArg [][]byte) ([ var returnVal [][]byte var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("BinaryList")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/binaryList")) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "binaryList failed") } if returnVal == nil { @@ -150,11 +143,10 @@ func (c *testServiceClient) Bytes(ctx context.Context, bodyArg CustomObject) (Cu var returnVal *CustomObject var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("Bytes")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/bytes")) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "bytes failed") } if returnVal == nil { diff --git a/integration_test/testgenerated/cli/api/services.conjure.go b/integration_test/testgenerated/cli/api/services.conjure.go index 222e129b8..b9614f877 100644 --- a/integration_test/testgenerated/cli/api/services.conjure.go +++ b/integration_test/testgenerated/cli/api/services.conjure.go @@ -55,10 +55,9 @@ func NewTestServiceClient(client httpclient.Client) TestServiceClient { func (c *testServiceClient) Echo(ctx context.Context, cookieToken bearertoken.Token) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("Echo")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithHeader("Cookie", fmt.Sprint("PALANTIR_TOKEN=", cookieToken))) requestParams = append(requestParams, httpclient.WithPathf("/echo")) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "echo failed") } return nil @@ -68,11 +67,10 @@ func (c *testServiceClient) EchoStrings(ctx context.Context, bodyArg []string) ( var returnVal []string var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("EchoStrings")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/echo")) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "echoStrings failed") } if returnVal == nil { @@ -85,13 +83,12 @@ func (c *testServiceClient) EchoCustomObject(ctx context.Context, bodyArg *Custo var returnVal *CustomObject var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("EchoCustomObject")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/echoCustomObject")) if bodyArg != nil { requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) } requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "echoCustomObject failed") } return returnVal, nil @@ -102,13 +99,12 @@ func (c *testServiceClient) EchoOptionalAlias(ctx context.Context, bodyArg Optio var returnVal OptionalIntegerAlias var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("EchoOptionalAlias")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/optional/alias")) if bodyArg.Value != nil { requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) } requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "echoOptionalAlias failed") } return returnVal, nil @@ -119,13 +115,12 @@ func (c *testServiceClient) EchoOptionalListAlias(ctx context.Context, bodyArg O var returnVal OptionalListAlias var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("EchoOptionalListAlias")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/optional/list-alias")) if bodyArg.Value != nil { requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) } requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "echoOptionalListAlias failed") } return returnVal, nil @@ -134,10 +129,9 @@ func (c *testServiceClient) EchoOptionalListAlias(ctx context.Context, bodyArg O func (c *testServiceClient) GetPathParam(ctx context.Context, authHeader bearertoken.Token, myPathParamArg string) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("GetPathParam")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithHeader("Authorization", fmt.Sprint("Bearer ", authHeader))) requestParams = append(requestParams, httpclient.WithPathf("/path/string/%s", url.PathEscape(fmt.Sprint(myPathParamArg)))) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "getPathParam failed") } return nil @@ -147,7 +141,6 @@ func (c *testServiceClient) GetListBoolean(ctx context.Context, myQueryParam1Arg var returnVal []bool var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("GetListBoolean")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/booleanListQueryVar")) queryParams := make(url.Values) for _, v := range myQueryParam1Arg { @@ -155,7 +148,7 @@ func (c *testServiceClient) GetListBoolean(ctx context.Context, myQueryParam1Arg } requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "getListBoolean failed") } if returnVal == nil { @@ -168,11 +161,10 @@ func (c *testServiceClient) PutMapStringString(ctx context.Context, myParamArg m var returnVal map[string]string var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("PutMapStringString")) - requestParams = append(requestParams, httpclient.WithRequestMethod("PUT")) requestParams = append(requestParams, httpclient.WithPathf("/mapStringString")) requestParams = append(requestParams, httpclient.WithJSONRequest(myParamArg)) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Put(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "putMapStringString failed") } if returnVal == nil { @@ -185,11 +177,10 @@ func (c *testServiceClient) PutMapStringAny(ctx context.Context, myParamArg map[ var returnVal map[string]interface{} var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("PutMapStringAny")) - requestParams = append(requestParams, httpclient.WithRequestMethod("PUT")) requestParams = append(requestParams, httpclient.WithPathf("/mapStringAny")) requestParams = append(requestParams, httpclient.WithJSONRequest(myParamArg)) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Put(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "putMapStringAny failed") } if returnVal == nil { @@ -203,13 +194,12 @@ func (c *testServiceClient) GetDateTime(ctx context.Context, myParamArg datetime var returnVal *datetime.DateTime var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("GetDateTime")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/getDateTime")) queryParams := make(url.Values) queryParams.Set("myParam", fmt.Sprint(myParamArg)) requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "getDateTime failed") } if returnVal == nil { @@ -223,13 +213,12 @@ func (c *testServiceClient) GetDouble(ctx context.Context, myParamArg float64) ( var returnVal *float64 var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("GetDouble")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/getDouble")) queryParams := make(url.Values) queryParams.Set("myParam", fmt.Sprint(myParamArg)) requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "getDouble failed") } if returnVal == nil { @@ -243,13 +232,12 @@ func (c *testServiceClient) GetRid(ctx context.Context, myParamArg rid.ResourceI var returnVal *rid.ResourceIdentifier var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("GetRid")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/getRid")) queryParams := make(url.Values) queryParams.Set("myParam", fmt.Sprint(myParamArg)) requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "getRid failed") } if returnVal == nil { @@ -263,13 +251,12 @@ func (c *testServiceClient) GetSafeLong(ctx context.Context, myParamArg safelong var returnVal *safelong.SafeLong var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("GetSafeLong")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/getSafeLong")) queryParams := make(url.Values) queryParams.Set("myParam", fmt.Sprint(myParamArg)) requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "getSafeLong failed") } if returnVal == nil { @@ -283,13 +270,12 @@ func (c *testServiceClient) GetUuid(ctx context.Context, myParamArg uuid.UUID) ( var returnVal *uuid.UUID var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("GetUuid")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/getUuid")) queryParams := make(url.Values) queryParams.Set("myParam", fmt.Sprint(myParamArg)) requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "getUuid failed") } if returnVal == nil { @@ -303,13 +289,12 @@ func (c *testServiceClient) GetEnum(ctx context.Context, myParamArg CustomEnum) var returnVal *CustomEnum var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("GetEnum")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/getEnum")) queryParams := make(url.Values) queryParams.Set("myParam", fmt.Sprint(myParamArg)) requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "getEnum failed") } if returnVal == nil { @@ -321,11 +306,10 @@ func (c *testServiceClient) GetEnum(ctx context.Context, myParamArg CustomEnum) func (c *testServiceClient) PutBinary(ctx context.Context, myParamArg func() io.ReadCloser) (io.ReadCloser, error) { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("PutBinary")) - requestParams = append(requestParams, httpclient.WithRequestMethod("PUT")) requestParams = append(requestParams, httpclient.WithPathf("/binary")) requestParams = append(requestParams, httpclient.WithRawRequestBodyProvider(myParamArg)) requestParams = append(requestParams, httpclient.WithRawResponseBody()) - resp, err := c.client.Do(ctx, requestParams...) + resp, err := c.client.Put(ctx, requestParams...) if err != nil { return nil, werror.WrapWithContextParams(ctx, err, "putBinary failed") } @@ -335,10 +319,9 @@ func (c *testServiceClient) PutBinary(ctx context.Context, myParamArg func() io. func (c *testServiceClient) GetOptionalBinary(ctx context.Context) (*io.ReadCloser, error) { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("GetOptionalBinary")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/optional/binary")) requestParams = append(requestParams, httpclient.WithRawResponseBody()) - resp, err := c.client.Do(ctx, requestParams...) + resp, err := c.client.Get(ctx, requestParams...) if err != nil { return nil, werror.WrapWithContextParams(ctx, err, "getOptionalBinary failed") } @@ -353,11 +336,10 @@ func (c *testServiceClient) PutCustomUnion(ctx context.Context, myParamArg Custo var returnVal *CustomUnion var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("PutCustomUnion")) - requestParams = append(requestParams, httpclient.WithRequestMethod("PUT")) requestParams = append(requestParams, httpclient.WithPathf("/customUnion")) requestParams = append(requestParams, httpclient.WithJSONRequest(myParamArg)) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Put(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "putCustomUnion failed") } if returnVal == nil { @@ -369,13 +351,12 @@ func (c *testServiceClient) PutCustomUnion(ctx context.Context, myParamArg Custo func (c *testServiceClient) GetReserved(ctx context.Context, confArg string, bearertokenArg string) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("GetReserved")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/getReserved")) queryParams := make(url.Values) queryParams.Set("conf", fmt.Sprint(confArg)) queryParams.Set("bearertoken", fmt.Sprint(bearertokenArg)) requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "getReserved failed") } return nil @@ -384,7 +365,6 @@ func (c *testServiceClient) GetReserved(ctx context.Context, confArg string, bea func (c *testServiceClient) Chan(ctx context.Context, varArg string, importArg map[string]string, typeArg string, returnArg safelong.SafeLong, httpArg string, jsonArg string, reqArg string, rwArg string) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("Chan")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/chan/%s", url.PathEscape(fmt.Sprint(varArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(importArg)) requestParams = append(requestParams, httpclient.WithHeader("X-My-Header2", fmt.Sprint(returnArg))) @@ -395,7 +375,7 @@ func (c *testServiceClient) Chan(ctx context.Context, varArg string, importArg m queryParams.Set("req", fmt.Sprint(reqArg)) queryParams.Set("rw", fmt.Sprint(rwArg)) requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "chan failed") } return nil diff --git a/integration_test/testgenerated/client/api/services.conjure.go b/integration_test/testgenerated/client/api/services.conjure.go index cc1cff89b..7bf430fa8 100644 --- a/integration_test/testgenerated/client/api/services.conjure.go +++ b/integration_test/testgenerated/client/api/services.conjure.go @@ -37,9 +37,8 @@ func NewTestServiceClient(client httpclient.Client) TestServiceClient { func (c *testServiceClient) Echo(ctx context.Context) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("Echo")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/echo")) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "echo failed") } return nil @@ -48,9 +47,8 @@ func (c *testServiceClient) Echo(ctx context.Context) error { func (c *testServiceClient) PathParam(ctx context.Context, paramArg string) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("PathParam")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/path/%s", url.PathEscape(fmt.Sprint(paramArg)))) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "pathParam failed") } return nil @@ -59,9 +57,8 @@ func (c *testServiceClient) PathParam(ctx context.Context, paramArg string) erro func (c *testServiceClient) PathParamAlias(ctx context.Context, paramArg StringAlias) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("PathParamAlias")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/path/alias/%s", url.PathEscape(fmt.Sprint(paramArg)))) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "pathParamAlias failed") } return nil @@ -70,9 +67,8 @@ func (c *testServiceClient) PathParamAlias(ctx context.Context, paramArg StringA func (c *testServiceClient) PathParamRid(ctx context.Context, paramArg rid.ResourceIdentifier) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("PathParamRid")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/path/rid/%s", url.PathEscape(fmt.Sprint(paramArg)))) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "pathParamRid failed") } return nil @@ -81,9 +77,8 @@ func (c *testServiceClient) PathParamRid(ctx context.Context, paramArg rid.Resou func (c *testServiceClient) PathParamRidAlias(ctx context.Context, paramArg RidAlias) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("PathParamRidAlias")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/path/rid/alias/%s", url.PathEscape(fmt.Sprint(paramArg)))) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "pathParamRidAlias failed") } return nil @@ -94,10 +89,9 @@ func (c *testServiceClient) Bytes(ctx context.Context) (CustomObject, error) { var returnVal *CustomObject var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("Bytes")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/bytes")) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "bytes failed") } if returnVal == nil { @@ -109,10 +103,9 @@ func (c *testServiceClient) Bytes(ctx context.Context) (CustomObject, error) { func (c *testServiceClient) Binary(ctx context.Context) (io.ReadCloser, error) { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("Binary")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/binary")) requestParams = append(requestParams, httpclient.WithRawResponseBody()) - resp, err := c.client.Do(ctx, requestParams...) + resp, err := c.client.Get(ctx, requestParams...) if err != nil { return nil, werror.WrapWithContextParams(ctx, err, "binary failed") } @@ -122,10 +115,9 @@ func (c *testServiceClient) Binary(ctx context.Context) (io.ReadCloser, error) { func (c *testServiceClient) MaybeBinary(ctx context.Context) (*io.ReadCloser, error) { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("MaybeBinary")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/optional/binary")) requestParams = append(requestParams, httpclient.WithRawResponseBody()) - resp, err := c.client.Do(ctx, requestParams...) + resp, err := c.client.Get(ctx, requestParams...) if err != nil { return nil, werror.WrapWithContextParams(ctx, err, "maybeBinary failed") } @@ -138,14 +130,13 @@ func (c *testServiceClient) MaybeBinary(ctx context.Context) (*io.ReadCloser, er func (c *testServiceClient) Query(ctx context.Context, queryArg *StringAlias) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("Query")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/query")) queryParams := make(url.Values) if queryArg != nil { queryParams.Set("query", fmt.Sprint(*queryArg)) } requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "query failed") } return nil diff --git a/integration_test/testgenerated/post/api/services.conjure.go b/integration_test/testgenerated/post/api/services.conjure.go index 830f621e4..bd72c32fd 100644 --- a/integration_test/testgenerated/post/api/services.conjure.go +++ b/integration_test/testgenerated/post/api/services.conjure.go @@ -35,11 +35,10 @@ func (c *testServiceClient) Echo(ctx context.Context, inputArg string) (string, var returnVal *string var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("Echo")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/echo")) requestParams = append(requestParams, httpclient.WithJSONRequest(inputArg)) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "echo failed") } if returnVal == nil { diff --git a/integration_test/testgenerated/queryparam/api/services.conjure.go b/integration_test/testgenerated/queryparam/api/services.conjure.go index cef5f77e5..293488630 100644 --- a/integration_test/testgenerated/queryparam/api/services.conjure.go +++ b/integration_test/testgenerated/queryparam/api/services.conjure.go @@ -28,7 +28,6 @@ func (c *testServiceClient) Echo(ctx context.Context, inputArg string, repsArg i var returnVal *string var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("Echo")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/echo")) queryParams := make(url.Values) queryParams.Set("input", fmt.Sprint(inputArg)) @@ -44,7 +43,7 @@ func (c *testServiceClient) Echo(ctx context.Context, inputArg string, repsArg i } requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "echo failed") } if returnVal == nil { diff --git a/integration_test/testgenerated/server/api/services.conjure.go b/integration_test/testgenerated/server/api/services.conjure.go index 86dc76ee3..5253fd11d 100644 --- a/integration_test/testgenerated/server/api/services.conjure.go +++ b/integration_test/testgenerated/server/api/services.conjure.go @@ -62,10 +62,9 @@ func NewTestServiceClient(client httpclient.Client) TestServiceClient { func (c *testServiceClient) Echo(ctx context.Context, cookieToken bearertoken.Token) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("Echo")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithHeader("Cookie", fmt.Sprint("PALANTIR_TOKEN=", cookieToken))) requestParams = append(requestParams, httpclient.WithPathf("/echo")) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "echo failed") } return nil @@ -75,11 +74,10 @@ func (c *testServiceClient) EchoStrings(ctx context.Context, bodyArg []string) ( var returnVal []string var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("EchoStrings")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/echo")) requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "echoStrings failed") } if returnVal == nil { @@ -92,13 +90,12 @@ func (c *testServiceClient) EchoCustomObject(ctx context.Context, bodyArg *Custo var returnVal *CustomObject var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("EchoCustomObject")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/echoCustomObject")) if bodyArg != nil { requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) } requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "echoCustomObject failed") } return returnVal, nil @@ -109,13 +106,12 @@ func (c *testServiceClient) EchoOptionalAlias(ctx context.Context, bodyArg Optio var returnVal OptionalIntegerAlias var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("EchoOptionalAlias")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/optional/alias")) if bodyArg.Value != nil { requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) } requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "echoOptionalAlias failed") } return returnVal, nil @@ -126,13 +122,12 @@ func (c *testServiceClient) EchoOptionalListAlias(ctx context.Context, bodyArg O var returnVal OptionalListAlias var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("EchoOptionalListAlias")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/optional/list-alias")) if bodyArg.Value != nil { requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg)) } requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "echoOptionalListAlias failed") } return returnVal, nil @@ -141,10 +136,9 @@ func (c *testServiceClient) EchoOptionalListAlias(ctx context.Context, bodyArg O func (c *testServiceClient) GetPathParam(ctx context.Context, authHeader bearertoken.Token, myPathParamArg string) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("GetPathParam")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithHeader("Authorization", fmt.Sprint("Bearer ", authHeader))) requestParams = append(requestParams, httpclient.WithPathf("/path/string/%s", url.PathEscape(fmt.Sprint(myPathParamArg)))) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "getPathParam failed") } return nil @@ -153,10 +147,9 @@ func (c *testServiceClient) GetPathParam(ctx context.Context, authHeader bearert func (c *testServiceClient) GetPathParamAlias(ctx context.Context, authHeader bearertoken.Token, myPathParamArg StringAlias) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("GetPathParamAlias")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithHeader("Authorization", fmt.Sprint("Bearer ", authHeader))) requestParams = append(requestParams, httpclient.WithPathf("/path/alias/%s", url.PathEscape(fmt.Sprint(myPathParamArg)))) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "getPathParamAlias failed") } return nil @@ -165,7 +158,6 @@ func (c *testServiceClient) GetPathParamAlias(ctx context.Context, authHeader be func (c *testServiceClient) QueryParamList(ctx context.Context, authHeader bearertoken.Token, myQueryParam1Arg []string) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("QueryParamList")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithHeader("Authorization", fmt.Sprint("Bearer ", authHeader))) requestParams = append(requestParams, httpclient.WithPathf("/pathNew")) queryParams := make(url.Values) @@ -173,7 +165,7 @@ func (c *testServiceClient) QueryParamList(ctx context.Context, authHeader beare queryParams.Add("myQueryParam1", fmt.Sprint(v)) } requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "queryParamList failed") } return nil @@ -182,7 +174,6 @@ func (c *testServiceClient) QueryParamList(ctx context.Context, authHeader beare func (c *testServiceClient) QueryParamListBoolean(ctx context.Context, authHeader bearertoken.Token, myQueryParam1Arg []bool) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("QueryParamListBoolean")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithHeader("Authorization", fmt.Sprint("Bearer ", authHeader))) requestParams = append(requestParams, httpclient.WithPathf("/booleanListQueryVar")) queryParams := make(url.Values) @@ -190,7 +181,7 @@ func (c *testServiceClient) QueryParamListBoolean(ctx context.Context, authHeade queryParams.Add("myQueryParam1", fmt.Sprint(v)) } requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "queryParamListBoolean failed") } return nil @@ -199,7 +190,6 @@ func (c *testServiceClient) QueryParamListBoolean(ctx context.Context, authHeade func (c *testServiceClient) QueryParamListDateTime(ctx context.Context, authHeader bearertoken.Token, myQueryParam1Arg []datetime.DateTime) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("QueryParamListDateTime")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithHeader("Authorization", fmt.Sprint("Bearer ", authHeader))) requestParams = append(requestParams, httpclient.WithPathf("/dateTimeListQueryVar")) queryParams := make(url.Values) @@ -207,7 +197,7 @@ func (c *testServiceClient) QueryParamListDateTime(ctx context.Context, authHead queryParams.Add("myQueryParam1", fmt.Sprint(v)) } requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "queryParamListDateTime failed") } return nil @@ -217,7 +207,6 @@ func (c *testServiceClient) QueryParamSetDateTime(ctx context.Context, authHeade var returnVal []datetime.DateTime var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("QueryParamSetDateTime")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithHeader("Authorization", fmt.Sprint("Bearer ", authHeader))) requestParams = append(requestParams, httpclient.WithPathf("/dateTimeSetQueryVar")) queryParams := make(url.Values) @@ -226,7 +215,7 @@ func (c *testServiceClient) QueryParamSetDateTime(ctx context.Context, authHeade } requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return nil, werror.WrapWithContextParams(ctx, err, "queryParamSetDateTime failed") } if returnVal == nil { @@ -238,7 +227,6 @@ func (c *testServiceClient) QueryParamSetDateTime(ctx context.Context, authHeade func (c *testServiceClient) QueryParamListDouble(ctx context.Context, authHeader bearertoken.Token, myQueryParam1Arg []float64) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("QueryParamListDouble")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithHeader("Authorization", fmt.Sprint("Bearer ", authHeader))) requestParams = append(requestParams, httpclient.WithPathf("/doubleListQueryVar")) queryParams := make(url.Values) @@ -246,7 +234,7 @@ func (c *testServiceClient) QueryParamListDouble(ctx context.Context, authHeader queryParams.Add("myQueryParam1", fmt.Sprint(v)) } requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "queryParamListDouble failed") } return nil @@ -255,7 +243,6 @@ func (c *testServiceClient) QueryParamListDouble(ctx context.Context, authHeader func (c *testServiceClient) QueryParamListInteger(ctx context.Context, authHeader bearertoken.Token, myQueryParam1Arg []int) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("QueryParamListInteger")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithHeader("Authorization", fmt.Sprint("Bearer ", authHeader))) requestParams = append(requestParams, httpclient.WithPathf("/intListQueryVar")) queryParams := make(url.Values) @@ -263,7 +250,7 @@ func (c *testServiceClient) QueryParamListInteger(ctx context.Context, authHeade queryParams.Add("myQueryParam1", fmt.Sprint(v)) } requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "queryParamListInteger failed") } return nil @@ -272,7 +259,6 @@ func (c *testServiceClient) QueryParamListInteger(ctx context.Context, authHeade func (c *testServiceClient) QueryParamListRid(ctx context.Context, authHeader bearertoken.Token, myQueryParam1Arg []rid.ResourceIdentifier) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("QueryParamListRid")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithHeader("Authorization", fmt.Sprint("Bearer ", authHeader))) requestParams = append(requestParams, httpclient.WithPathf("/ridListQueryVar")) queryParams := make(url.Values) @@ -280,7 +266,7 @@ func (c *testServiceClient) QueryParamListRid(ctx context.Context, authHeader be queryParams.Add("myQueryParam1", fmt.Sprint(v)) } requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "queryParamListRid failed") } return nil @@ -289,7 +275,6 @@ func (c *testServiceClient) QueryParamListRid(ctx context.Context, authHeader be func (c *testServiceClient) QueryParamListSafeLong(ctx context.Context, authHeader bearertoken.Token, myQueryParam1Arg []safelong.SafeLong) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("QueryParamListSafeLong")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithHeader("Authorization", fmt.Sprint("Bearer ", authHeader))) requestParams = append(requestParams, httpclient.WithPathf("/safeLongListQueryVar")) queryParams := make(url.Values) @@ -297,7 +282,7 @@ func (c *testServiceClient) QueryParamListSafeLong(ctx context.Context, authHead queryParams.Add("myQueryParam1", fmt.Sprint(v)) } requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "queryParamListSafeLong failed") } return nil @@ -306,7 +291,6 @@ func (c *testServiceClient) QueryParamListSafeLong(ctx context.Context, authHead func (c *testServiceClient) QueryParamListString(ctx context.Context, authHeader bearertoken.Token, myQueryParam1Arg []string) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("QueryParamListString")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithHeader("Authorization", fmt.Sprint("Bearer ", authHeader))) requestParams = append(requestParams, httpclient.WithPathf("/stringListQueryVar")) queryParams := make(url.Values) @@ -314,7 +298,7 @@ func (c *testServiceClient) QueryParamListString(ctx context.Context, authHeader queryParams.Add("myQueryParam1", fmt.Sprint(v)) } requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "queryParamListString failed") } return nil @@ -323,7 +307,6 @@ func (c *testServiceClient) QueryParamListString(ctx context.Context, authHeader func (c *testServiceClient) QueryParamListUuid(ctx context.Context, authHeader bearertoken.Token, myQueryParam1Arg []uuid.UUID) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("QueryParamListUuid")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithHeader("Authorization", fmt.Sprint("Bearer ", authHeader))) requestParams = append(requestParams, httpclient.WithPathf("/uuidListQueryVar")) queryParams := make(url.Values) @@ -331,7 +314,7 @@ func (c *testServiceClient) QueryParamListUuid(ctx context.Context, authHeader b queryParams.Add("myQueryParam1", fmt.Sprint(v)) } requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "queryParamListUuid failed") } return nil @@ -340,13 +323,12 @@ func (c *testServiceClient) QueryParamListUuid(ctx context.Context, authHeader b func (c *testServiceClient) QueryParamExternalString(ctx context.Context, authHeader bearertoken.Token, myQueryParam1Arg string) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("QueryParamExternalString")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithHeader("Authorization", fmt.Sprint("Bearer ", authHeader))) requestParams = append(requestParams, httpclient.WithPathf("/externalStringQueryVar")) queryParams := make(url.Values) queryParams.Set("myQueryParam1", fmt.Sprint(myQueryParam1Arg)) requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "queryParamExternalString failed") } return nil @@ -355,13 +337,12 @@ func (c *testServiceClient) QueryParamExternalString(ctx context.Context, authHe func (c *testServiceClient) QueryParamExternalInteger(ctx context.Context, authHeader bearertoken.Token, myQueryParam1Arg int) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("QueryParamExternalInteger")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithHeader("Authorization", fmt.Sprint("Bearer ", authHeader))) requestParams = append(requestParams, httpclient.WithPathf("/externalIntegerQueryVar")) queryParams := make(url.Values) queryParams.Set("myQueryParam1", fmt.Sprint(myQueryParam1Arg)) requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "queryParamExternalInteger failed") } return nil @@ -370,10 +351,9 @@ func (c *testServiceClient) QueryParamExternalInteger(ctx context.Context, authH func (c *testServiceClient) PathParamExternalString(ctx context.Context, authHeader bearertoken.Token, myPathParam1Arg string) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("PathParamExternalString")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithHeader("Authorization", fmt.Sprint("Bearer ", authHeader))) requestParams = append(requestParams, httpclient.WithPathf("/externalStringPath/%s", url.PathEscape(fmt.Sprint(myPathParam1Arg)))) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "pathParamExternalString failed") } return nil @@ -382,10 +362,9 @@ func (c *testServiceClient) PathParamExternalString(ctx context.Context, authHea func (c *testServiceClient) PathParamExternalInteger(ctx context.Context, authHeader bearertoken.Token, myPathParam1Arg int) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("PathParamExternalInteger")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithHeader("Authorization", fmt.Sprint("Bearer ", authHeader))) requestParams = append(requestParams, httpclient.WithPathf("/externalIntegerPath/%s", url.PathEscape(fmt.Sprint(myPathParam1Arg)))) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "pathParamExternalInteger failed") } return nil @@ -396,7 +375,6 @@ func (c *testServiceClient) PostPathParam(ctx context.Context, authHeader bearer var returnVal *CustomObject var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("PostPathParam")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithHeader("Authorization", fmt.Sprint("Bearer ", authHeader))) requestParams = append(requestParams, httpclient.WithPathf("/path/%s/%s", url.PathEscape(fmt.Sprint(myPathParam1Arg)), url.PathEscape(fmt.Sprint(myPathParam2Arg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(myBodyParamArg)) @@ -419,7 +397,7 @@ func (c *testServiceClient) PostPathParam(ctx context.Context, authHeader bearer } requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "postPathParam failed") } if returnVal == nil { @@ -431,7 +409,6 @@ func (c *testServiceClient) PostPathParam(ctx context.Context, authHeader bearer func (c *testServiceClient) PostSafeParams(ctx context.Context, authHeader bearertoken.Token, myPathParam1Arg string, myPathParam2Arg bool, myBodyParamArg CustomObject, myQueryParam1Arg string, myQueryParam2Arg string, myQueryParam3Arg float64, myQueryParam4Arg *safelong.SafeLong, myQueryParam5Arg *string, myHeaderParam1Arg safelong.SafeLong, myHeaderParam2Arg *SafeUuid) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("PostSafeParams")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithHeader("Authorization", fmt.Sprint("Bearer ", authHeader))) requestParams = append(requestParams, httpclient.WithPathf("/safe/%s/%s", url.PathEscape(fmt.Sprint(myPathParam1Arg)), url.PathEscape(fmt.Sprint(myPathParam2Arg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(myBodyParamArg)) @@ -450,7 +427,7 @@ func (c *testServiceClient) PostSafeParams(ctx context.Context, authHeader beare queryParams.Set("myQueryParam5", fmt.Sprint(*myQueryParam5Arg)) } requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "postSafeParams failed") } return nil @@ -461,10 +438,9 @@ func (c *testServiceClient) Bytes(ctx context.Context) (CustomObject, error) { var returnVal *CustomObject var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("Bytes")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/bytes")) requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Get(ctx, requestParams...); err != nil { return defaultReturnVal, werror.WrapWithContextParams(ctx, err, "bytes failed") } if returnVal == nil { @@ -476,10 +452,9 @@ func (c *testServiceClient) Bytes(ctx context.Context) (CustomObject, error) { func (c *testServiceClient) GetBinary(ctx context.Context) (io.ReadCloser, error) { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("GetBinary")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/binary")) requestParams = append(requestParams, httpclient.WithRawResponseBody()) - resp, err := c.client.Do(ctx, requestParams...) + resp, err := c.client.Get(ctx, requestParams...) if err != nil { return nil, werror.WrapWithContextParams(ctx, err, "getBinary failed") } @@ -489,11 +464,10 @@ func (c *testServiceClient) GetBinary(ctx context.Context) (io.ReadCloser, error func (c *testServiceClient) PostBinary(ctx context.Context, myBytesArg func() io.ReadCloser) (io.ReadCloser, error) { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("PostBinary")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/binary")) requestParams = append(requestParams, httpclient.WithRawRequestBodyProvider(myBytesArg)) requestParams = append(requestParams, httpclient.WithRawResponseBody()) - resp, err := c.client.Do(ctx, requestParams...) + resp, err := c.client.Post(ctx, requestParams...) if err != nil { return nil, werror.WrapWithContextParams(ctx, err, "postBinary failed") } @@ -503,10 +477,9 @@ func (c *testServiceClient) PostBinary(ctx context.Context, myBytesArg func() io func (c *testServiceClient) PutBinary(ctx context.Context, myBytesArg func() io.ReadCloser) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("PutBinary")) - requestParams = append(requestParams, httpclient.WithRequestMethod("PUT")) requestParams = append(requestParams, httpclient.WithPathf("/binary")) requestParams = append(requestParams, httpclient.WithRawRequestBodyProvider(myBytesArg)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Put(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "putBinary failed") } return nil @@ -515,10 +488,9 @@ func (c *testServiceClient) PutBinary(ctx context.Context, myBytesArg func() io. func (c *testServiceClient) GetOptionalBinary(ctx context.Context) (*io.ReadCloser, error) { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("GetOptionalBinary")) - requestParams = append(requestParams, httpclient.WithRequestMethod("GET")) requestParams = append(requestParams, httpclient.WithPathf("/optional/binary")) requestParams = append(requestParams, httpclient.WithRawResponseBody()) - resp, err := c.client.Do(ctx, requestParams...) + resp, err := c.client.Get(ctx, requestParams...) if err != nil { return nil, werror.WrapWithContextParams(ctx, err, "getOptionalBinary failed") } @@ -531,7 +503,6 @@ func (c *testServiceClient) GetOptionalBinary(ctx context.Context) (*io.ReadClos func (c *testServiceClient) Chan(ctx context.Context, varArg string, importArg map[string]string, typeArg string, returnArg safelong.SafeLong, httpArg string, jsonArg string, reqArg string, rwArg string) error { var requestParams []httpclient.RequestParam requestParams = append(requestParams, httpclient.WithRPCMethodName("Chan")) - requestParams = append(requestParams, httpclient.WithRequestMethod("POST")) requestParams = append(requestParams, httpclient.WithPathf("/chan/%s", url.PathEscape(fmt.Sprint(varArg)))) requestParams = append(requestParams, httpclient.WithJSONRequest(importArg)) requestParams = append(requestParams, httpclient.WithHeader("X-My-Header2", fmt.Sprint(returnArg))) @@ -542,7 +513,7 @@ func (c *testServiceClient) Chan(ctx context.Context, varArg string, importArg m queryParams.Set("req", fmt.Sprint(reqArg)) queryParams.Set("rw", fmt.Sprint(rwArg)) requestParams = append(requestParams, httpclient.WithQueryValues(queryParams)) - if _, err := c.client.Do(ctx, requestParams...); err != nil { + if _, err := c.client.Post(ctx, requestParams...); err != nil { return werror.WrapWithContextParams(ctx, err, "chan failed") } return nil From e767ecc9e3ebd82de5a0554ea8ce6faf4ec8d11d Mon Sep 17 00:00:00 2001 From: svc-changelog Date: Thu, 30 Nov 2023 17:12:49 +0000 Subject: [PATCH 2/2] Add generated changelog entries --- changelog/@unreleased/pr-541.v2.yml | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 changelog/@unreleased/pr-541.v2.yml diff --git a/changelog/@unreleased/pr-541.v2.yml b/changelog/@unreleased/pr-541.v2.yml new file mode 100644 index 000000000..fce9eee83 --- /dev/null +++ b/changelog/@unreleased/pr-541.v2.yml @@ -0,0 +1,5 @@ +type: improvement +improvement: + description: Use HTTP-method-specific functions on client requests + links: + - https://github.com/palantir/conjure-go/pull/541