From 5ccc98154da82dfae9762239bda6b71f5789e83c Mon Sep 17 00:00:00 2001 From: Maikel Veen Date: Fri, 8 Nov 2024 21:44:03 +0100 Subject: [PATCH] chore: Generate client package --- generate.go | 3 +- oapi-client.yaml | 5 + oapi-codegen-config.yaml => oapi-server.yaml | 0 pkg/client/client.gen.go | 779 +++++++++++++++++++ 4 files changed, 786 insertions(+), 1 deletion(-) create mode 100644 oapi-client.yaml rename oapi-codegen-config.yaml => oapi-server.yaml (100%) create mode 100644 pkg/client/client.gen.go diff --git a/generate.go b/generate.go index 0ed89ea..a98cff8 100644 --- a/generate.go +++ b/generate.go @@ -1,3 +1,4 @@ package main -//go:generate go run github.com/oapi-codegen/oapi-codegen/v2/cmd/oapi-codegen --config=oapi-codegen-config.yaml openapi.yaml +//go:generate go run github.com/oapi-codegen/oapi-codegen/v2/cmd/oapi-codegen --config=oapi-server.yaml openapi.yaml +//go:generate go run github.com/oapi-codegen/oapi-codegen/v2/cmd/oapi-codegen --config=oapi-client.yaml openapi.yaml diff --git a/oapi-client.yaml b/oapi-client.yaml new file mode 100644 index 0000000..bb9b013 --- /dev/null +++ b/oapi-client.yaml @@ -0,0 +1,5 @@ +package: client +output: pkg/client/client.gen.go +generate: + models: true + client: true \ No newline at end of file diff --git a/oapi-codegen-config.yaml b/oapi-server.yaml similarity index 100% rename from oapi-codegen-config.yaml rename to oapi-server.yaml diff --git a/pkg/client/client.gen.go b/pkg/client/client.gen.go new file mode 100644 index 0000000..aa8f47e --- /dev/null +++ b/pkg/client/client.gen.go @@ -0,0 +1,779 @@ +// Package client provides primitives to interact with the openapi HTTP API. +// +// Code generated by github.com/oapi-codegen/oapi-codegen/v2 version v2.3.0 DO NOT EDIT. +package client + +import ( + "bytes" + "context" + "encoding/json" + "fmt" + "io" + "net/http" + "net/url" + "strings" + "time" + + "github.com/oapi-codegen/runtime" +) + +// Defines values for ErrorCode. +const ( + ParameterInvalid ErrorCode = "parameter_invalid" + ParameterMissing ErrorCode = "parameter_missing" + ProcessingError ErrorCode = "processing_error" + ResourceAlreadyExists ErrorCode = "resource_already_exists" + ResourceMissing ErrorCode = "resource_missing" +) + +// Defines values for ErrorType. +const ( + ApiError ErrorType = "api_error" + InvalidRequestError ErrorType = "invalid_request_error" +) + +// Error Error is the response model when an API call is unsuccessful. +type Error struct { + Code ErrorCode `json:"code"` + Details map[string]interface{} `json:"details"` + Message string `json:"message"` + Type ErrorType `json:"type"` +} + +// ErrorCode defines model for ErrorCode. +type ErrorCode string + +// ErrorType defines model for ErrorType. +type ErrorType string + +// Item Item represents an individual content item. +type Item struct { + Content string `json:"content"` + CreateTime time.Time `json:"create_time"` + DeleteTime *time.Time `json:"delete_time,omitempty"` + DisplayName string `json:"display_name"` + + // Hash represents a hash value calculated from the item's content. + Hash string `json:"hash"` + Metadata map[string]interface{} `json:"metadata"` + Name string `json:"name"` + Properties map[string]interface{} `json:"properties"` + UpdateTime time.Time `json:"update_time"` +} + +// ItemCreate Resource create operation model. +type ItemCreate struct { + Content string `json:"content"` + CreateTime time.Time `json:"create_time"` + DisplayName string `json:"display_name"` + + // Hash represents a hash value calculated from the item's content. + Hash string `json:"hash"` + Metadata map[string]interface{} `json:"metadata"` + Name string `json:"name"` + Properties map[string]interface{} `json:"properties"` + UpdateTime time.Time `json:"update_time"` +} + +// ItemUpdate Resource create or update operation model. +type ItemUpdate struct { + Content *string `json:"content,omitempty"` + CreateTime *time.Time `json:"create_time,omitempty"` + DisplayName *string `json:"display_name,omitempty"` + + // Hash represents a hash value calculated from the item's content. + Hash *string `json:"hash,omitempty"` + Metadata *map[string]interface{} `json:"metadata,omitempty"` + Properties *map[string]interface{} `json:"properties,omitempty"` + UpdateTime *time.Time `json:"update_time,omitempty"` +} + +// ItemKey defines model for ItemKey. +type ItemKey = string + +// ItemsListParams defines parameters for ItemsList. +type ItemsListParams struct { + Fields *string `form:"fields,omitempty" json:"fields,omitempty"` +} + +// ItemsCreateJSONRequestBody defines body for ItemsCreate for application/json ContentType. +type ItemsCreateJSONRequestBody = ItemCreate + +// ItemsUpdateJSONRequestBody defines body for ItemsUpdate for application/json ContentType. +type ItemsUpdateJSONRequestBody = ItemUpdate + +// RequestEditorFn is the function signature for the RequestEditor callback function +type RequestEditorFn func(ctx context.Context, req *http.Request) error + +// Doer performs HTTP requests. +// +// The standard http.Client implements this interface. +type HttpRequestDoer interface { + Do(req *http.Request) (*http.Response, error) +} + +// Client which conforms to the OpenAPI3 specification for this service. +type Client struct { + // The endpoint of the server conforming to this interface, with scheme, + // https://api.deepmap.com for example. This can contain a path relative + // to the server, such as https://api.deepmap.com/dev-test, and all the + // paths in the swagger spec will be appended to the server. + Server string + + // Doer for performing requests, typically a *http.Client with any + // customized settings, such as certificate chains. + Client HttpRequestDoer + + // A list of callbacks for modifying requests which are generated before sending over + // the network. + RequestEditors []RequestEditorFn +} + +// ClientOption allows setting custom parameters during construction +type ClientOption func(*Client) error + +// Creates a new Client, with reasonable defaults +func NewClient(server string, opts ...ClientOption) (*Client, error) { + // create a client with sane default values + client := Client{ + Server: server, + } + // mutate client and add all optional params + for _, o := range opts { + if err := o(&client); err != nil { + return nil, err + } + } + // ensure the server URL always has a trailing slash + if !strings.HasSuffix(client.Server, "/") { + client.Server += "/" + } + // create httpClient, if not already present + if client.Client == nil { + client.Client = &http.Client{} + } + return &client, nil +} + +// WithHTTPClient allows overriding the default Doer, which is +// automatically created using http.Client. This is useful for tests. +func WithHTTPClient(doer HttpRequestDoer) ClientOption { + return func(c *Client) error { + c.Client = doer + return nil + } +} + +// WithRequestEditorFn allows setting up a callback function, which will be +// called right before sending the request. This can be used to mutate the request. +func WithRequestEditorFn(fn RequestEditorFn) ClientOption { + return func(c *Client) error { + c.RequestEditors = append(c.RequestEditors, fn) + return nil + } +} + +// The interface specification for the client above. +type ClientInterface interface { + // ItemsList request + ItemsList(ctx context.Context, params *ItemsListParams, reqEditors ...RequestEditorFn) (*http.Response, error) + + // ItemsCreateWithBody request with any body + ItemsCreateWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) + + ItemsCreate(ctx context.Context, body ItemsCreateJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) + + // ItemsGet request + ItemsGet(ctx context.Context, name ItemKey, reqEditors ...RequestEditorFn) (*http.Response, error) + + // ItemsUpdateWithBody request with any body + ItemsUpdateWithBody(ctx context.Context, name ItemKey, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) + + ItemsUpdate(ctx context.Context, name ItemKey, body ItemsUpdateJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) +} + +func (c *Client) ItemsList(ctx context.Context, params *ItemsListParams, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewItemsListRequest(c.Server, params) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) ItemsCreateWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewItemsCreateRequestWithBody(c.Server, contentType, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) ItemsCreate(ctx context.Context, body ItemsCreateJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewItemsCreateRequest(c.Server, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) ItemsGet(ctx context.Context, name ItemKey, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewItemsGetRequest(c.Server, name) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) ItemsUpdateWithBody(ctx context.Context, name ItemKey, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewItemsUpdateRequestWithBody(c.Server, name, contentType, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) ItemsUpdate(ctx context.Context, name ItemKey, body ItemsUpdateJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewItemsUpdateRequest(c.Server, name, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +// NewItemsListRequest generates requests for ItemsList +func NewItemsListRequest(server string, params *ItemsListParams) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/items") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + if params != nil { + queryValues := queryURL.Query() + + if params.Fields != nil { + + if queryFrag, err := runtime.StyleParamWithLocation("form", true, "fields", runtime.ParamLocationQuery, *params.Fields); err != nil { + return nil, err + } else if parsed, err := url.ParseQuery(queryFrag); err != nil { + return nil, err + } else { + for k, v := range parsed { + for _, v2 := range v { + queryValues.Add(k, v2) + } + } + } + + } + + queryURL.RawQuery = queryValues.Encode() + } + + req, err := http.NewRequest("GET", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewItemsCreateRequest calls the generic ItemsCreate builder with application/json body +func NewItemsCreateRequest(server string, body ItemsCreateJSONRequestBody) (*http.Request, error) { + var bodyReader io.Reader + buf, err := json.Marshal(body) + if err != nil { + return nil, err + } + bodyReader = bytes.NewReader(buf) + return NewItemsCreateRequestWithBody(server, "application/json", bodyReader) +} + +// NewItemsCreateRequestWithBody generates requests for ItemsCreate with any type of body +func NewItemsCreateRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/items") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("POST", queryURL.String(), body) + if err != nil { + return nil, err + } + + req.Header.Add("Content-Type", contentType) + + return req, nil +} + +// NewItemsGetRequest generates requests for ItemsGet +func NewItemsGetRequest(server string, name ItemKey) (*http.Request, error) { + var err error + + var pathParam0 string + + pathParam0, err = runtime.StyleParamWithLocation("simple", false, "name", runtime.ParamLocationPath, name) + if err != nil { + return nil, err + } + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/items/%s", pathParam0) + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("GET", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewItemsUpdateRequest calls the generic ItemsUpdate builder with application/json body +func NewItemsUpdateRequest(server string, name ItemKey, body ItemsUpdateJSONRequestBody) (*http.Request, error) { + var bodyReader io.Reader + buf, err := json.Marshal(body) + if err != nil { + return nil, err + } + bodyReader = bytes.NewReader(buf) + return NewItemsUpdateRequestWithBody(server, name, "application/json", bodyReader) +} + +// NewItemsUpdateRequestWithBody generates requests for ItemsUpdate with any type of body +func NewItemsUpdateRequestWithBody(server string, name ItemKey, contentType string, body io.Reader) (*http.Request, error) { + var err error + + var pathParam0 string + + pathParam0, err = runtime.StyleParamWithLocation("simple", false, "name", runtime.ParamLocationPath, name) + if err != nil { + return nil, err + } + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/items/%s", pathParam0) + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("PATCH", queryURL.String(), body) + if err != nil { + return nil, err + } + + req.Header.Add("Content-Type", contentType) + + return req, nil +} + +func (c *Client) applyEditors(ctx context.Context, req *http.Request, additionalEditors []RequestEditorFn) error { + for _, r := range c.RequestEditors { + if err := r(ctx, req); err != nil { + return err + } + } + for _, r := range additionalEditors { + if err := r(ctx, req); err != nil { + return err + } + } + return nil +} + +// ClientWithResponses builds on ClientInterface to offer response payloads +type ClientWithResponses struct { + ClientInterface +} + +// NewClientWithResponses creates a new ClientWithResponses, which wraps +// Client with return type handling +func NewClientWithResponses(server string, opts ...ClientOption) (*ClientWithResponses, error) { + client, err := NewClient(server, opts...) + if err != nil { + return nil, err + } + return &ClientWithResponses{client}, nil +} + +// WithBaseURL overrides the baseURL. +func WithBaseURL(baseURL string) ClientOption { + return func(c *Client) error { + newBaseURL, err := url.Parse(baseURL) + if err != nil { + return err + } + c.Server = newBaseURL.String() + return nil + } +} + +// ClientWithResponsesInterface is the interface specification for the client with responses above. +type ClientWithResponsesInterface interface { + // ItemsListWithResponse request + ItemsListWithResponse(ctx context.Context, params *ItemsListParams, reqEditors ...RequestEditorFn) (*ItemsListResponse, error) + + // ItemsCreateWithBodyWithResponse request with any body + ItemsCreateWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ItemsCreateResponse, error) + + ItemsCreateWithResponse(ctx context.Context, body ItemsCreateJSONRequestBody, reqEditors ...RequestEditorFn) (*ItemsCreateResponse, error) + + // ItemsGetWithResponse request + ItemsGetWithResponse(ctx context.Context, name ItemKey, reqEditors ...RequestEditorFn) (*ItemsGetResponse, error) + + // ItemsUpdateWithBodyWithResponse request with any body + ItemsUpdateWithBodyWithResponse(ctx context.Context, name ItemKey, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ItemsUpdateResponse, error) + + ItemsUpdateWithResponse(ctx context.Context, name ItemKey, body ItemsUpdateJSONRequestBody, reqEditors ...RequestEditorFn) (*ItemsUpdateResponse, error) +} + +type ItemsListResponse struct { + Body []byte + HTTPResponse *http.Response + JSON200 *[]Item + JSONDefault *Error +} + +// Status returns HTTPResponse.Status +func (r ItemsListResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r ItemsListResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type ItemsCreateResponse struct { + Body []byte + HTTPResponse *http.Response + JSON200 *Item + JSON201 *Item + JSONDefault *Error +} + +// Status returns HTTPResponse.Status +func (r ItemsCreateResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r ItemsCreateResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type ItemsGetResponse struct { + Body []byte + HTTPResponse *http.Response + JSON200 *Item + JSONDefault *Error +} + +// Status returns HTTPResponse.Status +func (r ItemsGetResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r ItemsGetResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type ItemsUpdateResponse struct { + Body []byte + HTTPResponse *http.Response + JSON200 *Item + JSONDefault *Error +} + +// Status returns HTTPResponse.Status +func (r ItemsUpdateResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r ItemsUpdateResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +// ItemsListWithResponse request returning *ItemsListResponse +func (c *ClientWithResponses) ItemsListWithResponse(ctx context.Context, params *ItemsListParams, reqEditors ...RequestEditorFn) (*ItemsListResponse, error) { + rsp, err := c.ItemsList(ctx, params, reqEditors...) + if err != nil { + return nil, err + } + return ParseItemsListResponse(rsp) +} + +// ItemsCreateWithBodyWithResponse request with arbitrary body returning *ItemsCreateResponse +func (c *ClientWithResponses) ItemsCreateWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ItemsCreateResponse, error) { + rsp, err := c.ItemsCreateWithBody(ctx, contentType, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseItemsCreateResponse(rsp) +} + +func (c *ClientWithResponses) ItemsCreateWithResponse(ctx context.Context, body ItemsCreateJSONRequestBody, reqEditors ...RequestEditorFn) (*ItemsCreateResponse, error) { + rsp, err := c.ItemsCreate(ctx, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseItemsCreateResponse(rsp) +} + +// ItemsGetWithResponse request returning *ItemsGetResponse +func (c *ClientWithResponses) ItemsGetWithResponse(ctx context.Context, name ItemKey, reqEditors ...RequestEditorFn) (*ItemsGetResponse, error) { + rsp, err := c.ItemsGet(ctx, name, reqEditors...) + if err != nil { + return nil, err + } + return ParseItemsGetResponse(rsp) +} + +// ItemsUpdateWithBodyWithResponse request with arbitrary body returning *ItemsUpdateResponse +func (c *ClientWithResponses) ItemsUpdateWithBodyWithResponse(ctx context.Context, name ItemKey, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ItemsUpdateResponse, error) { + rsp, err := c.ItemsUpdateWithBody(ctx, name, contentType, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseItemsUpdateResponse(rsp) +} + +func (c *ClientWithResponses) ItemsUpdateWithResponse(ctx context.Context, name ItemKey, body ItemsUpdateJSONRequestBody, reqEditors ...RequestEditorFn) (*ItemsUpdateResponse, error) { + rsp, err := c.ItemsUpdate(ctx, name, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseItemsUpdateResponse(rsp) +} + +// ParseItemsListResponse parses an HTTP response from a ItemsListWithResponse call +func ParseItemsListResponse(rsp *http.Response) (*ItemsListResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &ItemsListResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200: + var dest []Item + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON200 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && true: + var dest Error + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSONDefault = &dest + + } + + return response, nil +} + +// ParseItemsCreateResponse parses an HTTP response from a ItemsCreateWithResponse call +func ParseItemsCreateResponse(rsp *http.Response) (*ItemsCreateResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &ItemsCreateResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200: + var dest Item + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON200 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 201: + var dest Item + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON201 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && true: + var dest Error + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSONDefault = &dest + + } + + return response, nil +} + +// ParseItemsGetResponse parses an HTTP response from a ItemsGetWithResponse call +func ParseItemsGetResponse(rsp *http.Response) (*ItemsGetResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &ItemsGetResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200: + var dest Item + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON200 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && true: + var dest Error + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSONDefault = &dest + + } + + return response, nil +} + +// ParseItemsUpdateResponse parses an HTTP response from a ItemsUpdateWithResponse call +func ParseItemsUpdateResponse(rsp *http.Response) (*ItemsUpdateResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &ItemsUpdateResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200: + var dest Item + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON200 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && true: + var dest Error + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSONDefault = &dest + + } + + return response, nil +}