Rhys Lloyd
4e3048e272
Adds the ability to seed a single map for combobulation. Reviewed-on: #338 Co-authored-by: Rhys Lloyd <krakow20@gmail.com> Co-committed-by: Rhys Lloyd <krakow20@gmail.com>
5230 lines
125 KiB
Go
5230 lines
125 KiB
Go
// Code generated by ogen, DO NOT EDIT.
|
|
|
|
package api
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"io"
|
|
"mime"
|
|
"net/http"
|
|
|
|
"github.com/go-faster/errors"
|
|
"github.com/go-faster/jx"
|
|
"github.com/ogen-go/ogen/conv"
|
|
"github.com/ogen-go/ogen/ogenerrors"
|
|
"github.com/ogen-go/ogen/uri"
|
|
"github.com/ogen-go/ogen/validate"
|
|
)
|
|
|
|
func decodeActionMapfixAcceptedResponse(resp *http.Response) (res *ActionMapfixAcceptedNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &ActionMapfixAcceptedNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeActionMapfixRejectResponse(resp *http.Response) (res *ActionMapfixRejectNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &ActionMapfixRejectNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeActionMapfixRequestChangesResponse(resp *http.Response) (res *ActionMapfixRequestChangesNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &ActionMapfixRequestChangesNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeActionMapfixResetSubmittingResponse(resp *http.Response) (res *ActionMapfixResetSubmittingNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &ActionMapfixResetSubmittingNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeActionMapfixRetryValidateResponse(resp *http.Response) (res *ActionMapfixRetryValidateNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &ActionMapfixRetryValidateNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeActionMapfixRevokeResponse(resp *http.Response) (res *ActionMapfixRevokeNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &ActionMapfixRevokeNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeActionMapfixTriggerReleaseResponse(resp *http.Response) (res *ActionMapfixTriggerReleaseNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &ActionMapfixTriggerReleaseNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeActionMapfixTriggerSubmitResponse(resp *http.Response) (res *ActionMapfixTriggerSubmitNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &ActionMapfixTriggerSubmitNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeActionMapfixTriggerSubmitUncheckedResponse(resp *http.Response) (res *ActionMapfixTriggerSubmitUncheckedNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &ActionMapfixTriggerSubmitUncheckedNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeActionMapfixTriggerUploadResponse(resp *http.Response) (res *ActionMapfixTriggerUploadNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &ActionMapfixTriggerUploadNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeActionMapfixTriggerValidateResponse(resp *http.Response) (res *ActionMapfixTriggerValidateNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &ActionMapfixTriggerValidateNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeActionMapfixUploadedResponse(resp *http.Response) (res *ActionMapfixUploadedNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &ActionMapfixUploadedNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeActionMapfixValidatedResponse(resp *http.Response) (res *ActionMapfixValidatedNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &ActionMapfixValidatedNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeActionSubmissionAcceptedResponse(resp *http.Response) (res *ActionSubmissionAcceptedNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &ActionSubmissionAcceptedNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeActionSubmissionRejectResponse(resp *http.Response) (res *ActionSubmissionRejectNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &ActionSubmissionRejectNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeActionSubmissionRequestChangesResponse(resp *http.Response) (res *ActionSubmissionRequestChangesNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &ActionSubmissionRequestChangesNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeActionSubmissionResetSubmittingResponse(resp *http.Response) (res *ActionSubmissionResetSubmittingNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &ActionSubmissionResetSubmittingNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeActionSubmissionRetryValidateResponse(resp *http.Response) (res *ActionSubmissionRetryValidateNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &ActionSubmissionRetryValidateNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeActionSubmissionRevokeResponse(resp *http.Response) (res *ActionSubmissionRevokeNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &ActionSubmissionRevokeNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeActionSubmissionTriggerSubmitResponse(resp *http.Response) (res *ActionSubmissionTriggerSubmitNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &ActionSubmissionTriggerSubmitNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeActionSubmissionTriggerSubmitUncheckedResponse(resp *http.Response) (res *ActionSubmissionTriggerSubmitUncheckedNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &ActionSubmissionTriggerSubmitUncheckedNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeActionSubmissionTriggerUploadResponse(resp *http.Response) (res *ActionSubmissionTriggerUploadNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &ActionSubmissionTriggerUploadNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeActionSubmissionTriggerValidateResponse(resp *http.Response) (res *ActionSubmissionTriggerValidateNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &ActionSubmissionTriggerValidateNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeActionSubmissionValidatedResponse(resp *http.Response) (res *ActionSubmissionValidatedNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &ActionSubmissionValidatedNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeBatchAssetThumbnailsResponse(resp *http.Response) (res *BatchAssetThumbnailsOK, _ error) {
|
|
switch resp.StatusCode {
|
|
case 200:
|
|
// Code 200.
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response BatchAssetThumbnailsOK
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
return &response, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeBatchUserThumbnailsResponse(resp *http.Response) (res *BatchUserThumbnailsOK, _ error) {
|
|
switch resp.StatusCode {
|
|
case 200:
|
|
// Code 200.
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response BatchUserThumbnailsOK
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
return &response, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeBatchUsernamesResponse(resp *http.Response) (res *BatchUsernamesOK, _ error) {
|
|
switch resp.StatusCode {
|
|
case 200:
|
|
// Code 200.
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response BatchUsernamesOK
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
return &response, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeCombobulateMapResponse(resp *http.Response) (res *CombobulateMapNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &CombobulateMapNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeCreateMapfixResponse(resp *http.Response) (res *OperationID, _ error) {
|
|
switch resp.StatusCode {
|
|
case 201:
|
|
// Code 201.
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response OperationID
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &response, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeCreateMapfixAuditCommentResponse(resp *http.Response) (res *CreateMapfixAuditCommentNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &CreateMapfixAuditCommentNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeCreateScriptResponse(resp *http.Response) (res *ScriptID, _ error) {
|
|
switch resp.StatusCode {
|
|
case 201:
|
|
// Code 201.
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response ScriptID
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &response, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeCreateScriptPolicyResponse(resp *http.Response) (res *ScriptPolicyID, _ error) {
|
|
switch resp.StatusCode {
|
|
case 201:
|
|
// Code 201.
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response ScriptPolicyID
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &response, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeCreateSubmissionResponse(resp *http.Response) (res *OperationID, _ error) {
|
|
switch resp.StatusCode {
|
|
case 201:
|
|
// Code 201.
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response OperationID
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &response, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeCreateSubmissionAdminResponse(resp *http.Response) (res *OperationID, _ error) {
|
|
switch resp.StatusCode {
|
|
case 201:
|
|
// Code 201.
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response OperationID
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &response, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeCreateSubmissionAuditCommentResponse(resp *http.Response) (res *CreateSubmissionAuditCommentNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &CreateSubmissionAuditCommentNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeDeleteScriptResponse(resp *http.Response) (res *DeleteScriptNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &DeleteScriptNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeDeleteScriptPolicyResponse(resp *http.Response) (res *DeleteScriptPolicyNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &DeleteScriptPolicyNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeDownloadMapAssetResponse(resp *http.Response) (res DownloadMapAssetOK, _ error) {
|
|
switch resp.StatusCode {
|
|
case 200:
|
|
// Code 200.
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/octet-stream":
|
|
reader := resp.Body
|
|
b, err := io.ReadAll(reader)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
|
|
response := DownloadMapAssetOK{Data: bytes.NewReader(b)}
|
|
return response, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeGetAssetThumbnailResponse(resp *http.Response) (res *GetAssetThumbnailFound, _ error) {
|
|
switch resp.StatusCode {
|
|
case 302:
|
|
// Code 302.
|
|
var wrapper GetAssetThumbnailFound
|
|
h := uri.NewHeaderDecoder(resp.Header)
|
|
// Parse "Location" header.
|
|
{
|
|
cfg := uri.HeaderParameterDecodingConfig{
|
|
Name: "Location",
|
|
Explode: false,
|
|
}
|
|
if err := func() error {
|
|
if err := h.HasParam(cfg); err == nil {
|
|
if err := h.DecodeParam(cfg, func(d uri.Decoder) error {
|
|
var wrapperDotLocationVal string
|
|
if err := func() error {
|
|
val, err := d.DecodeValue()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
c, err := conv.ToString(val)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
wrapperDotLocationVal = c
|
|
return nil
|
|
}(); err != nil {
|
|
return err
|
|
}
|
|
wrapper.Location.SetTo(wrapperDotLocationVal)
|
|
return nil
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "parse Location header")
|
|
}
|
|
}
|
|
return &wrapper, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeGetMapResponse(resp *http.Response) (res *Map, _ error) {
|
|
switch resp.StatusCode {
|
|
case 200:
|
|
// Code 200.
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Map
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &response, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeGetMapfixResponse(resp *http.Response) (res *Mapfix, _ error) {
|
|
switch resp.StatusCode {
|
|
case 200:
|
|
// Code 200.
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Mapfix
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &response, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeGetOperationResponse(resp *http.Response) (res *Operation, _ error) {
|
|
switch resp.StatusCode {
|
|
case 200:
|
|
// Code 200.
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Operation
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &response, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeGetScriptResponse(resp *http.Response) (res *Script, _ error) {
|
|
switch resp.StatusCode {
|
|
case 200:
|
|
// Code 200.
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Script
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &response, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeGetScriptPolicyResponse(resp *http.Response) (res *ScriptPolicy, _ error) {
|
|
switch resp.StatusCode {
|
|
case 200:
|
|
// Code 200.
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response ScriptPolicy
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &response, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeGetStatsResponse(resp *http.Response) (res *Stats, _ error) {
|
|
switch resp.StatusCode {
|
|
case 200:
|
|
// Code 200.
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Stats
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &response, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeGetSubmissionResponse(resp *http.Response) (res *Submission, _ error) {
|
|
switch resp.StatusCode {
|
|
case 200:
|
|
// Code 200.
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Submission
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &response, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeGetUserThumbnailResponse(resp *http.Response) (res *GetUserThumbnailFound, _ error) {
|
|
switch resp.StatusCode {
|
|
case 302:
|
|
// Code 302.
|
|
var wrapper GetUserThumbnailFound
|
|
h := uri.NewHeaderDecoder(resp.Header)
|
|
// Parse "Location" header.
|
|
{
|
|
cfg := uri.HeaderParameterDecodingConfig{
|
|
Name: "Location",
|
|
Explode: false,
|
|
}
|
|
if err := func() error {
|
|
if err := h.HasParam(cfg); err == nil {
|
|
if err := h.DecodeParam(cfg, func(d uri.Decoder) error {
|
|
var wrapperDotLocationVal string
|
|
if err := func() error {
|
|
val, err := d.DecodeValue()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
c, err := conv.ToString(val)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
wrapperDotLocationVal = c
|
|
return nil
|
|
}(); err != nil {
|
|
return err
|
|
}
|
|
wrapper.Location.SetTo(wrapperDotLocationVal)
|
|
return nil
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "parse Location header")
|
|
}
|
|
}
|
|
return &wrapper, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeListMapfixAuditEventsResponse(resp *http.Response) (res []AuditEvent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 200:
|
|
// Code 200.
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response []AuditEvent
|
|
if err := func() error {
|
|
response = make([]AuditEvent, 0)
|
|
if err := d.Arr(func(d *jx.Decoder) error {
|
|
var elem AuditEvent
|
|
if err := elem.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
response = append(response, elem)
|
|
return nil
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if response == nil {
|
|
return errors.New("nil is invalid value")
|
|
}
|
|
var failures []validate.FieldError
|
|
for i, elem := range response {
|
|
if err := func() error {
|
|
if err := elem.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
failures = append(failures, validate.FieldError{
|
|
Name: fmt.Sprintf("[%d]", i),
|
|
Error: err,
|
|
})
|
|
}
|
|
}
|
|
if len(failures) > 0 {
|
|
return &validate.Error{Fields: failures}
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return response, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeListMapfixesResponse(resp *http.Response) (res *Mapfixes, _ error) {
|
|
switch resp.StatusCode {
|
|
case 200:
|
|
// Code 200.
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Mapfixes
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &response, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeListMapsResponse(resp *http.Response) (res []Map, _ error) {
|
|
switch resp.StatusCode {
|
|
case 200:
|
|
// Code 200.
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response []Map
|
|
if err := func() error {
|
|
response = make([]Map, 0)
|
|
if err := d.Arr(func(d *jx.Decoder) error {
|
|
var elem Map
|
|
if err := elem.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
response = append(response, elem)
|
|
return nil
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if response == nil {
|
|
return errors.New("nil is invalid value")
|
|
}
|
|
var failures []validate.FieldError
|
|
for i, elem := range response {
|
|
if err := func() error {
|
|
if err := elem.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
failures = append(failures, validate.FieldError{
|
|
Name: fmt.Sprintf("[%d]", i),
|
|
Error: err,
|
|
})
|
|
}
|
|
}
|
|
if len(failures) > 0 {
|
|
return &validate.Error{Fields: failures}
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return response, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeListScriptPolicyResponse(resp *http.Response) (res []ScriptPolicy, _ error) {
|
|
switch resp.StatusCode {
|
|
case 200:
|
|
// Code 200.
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response []ScriptPolicy
|
|
if err := func() error {
|
|
response = make([]ScriptPolicy, 0)
|
|
if err := d.Arr(func(d *jx.Decoder) error {
|
|
var elem ScriptPolicy
|
|
if err := elem.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
response = append(response, elem)
|
|
return nil
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if response == nil {
|
|
return errors.New("nil is invalid value")
|
|
}
|
|
var failures []validate.FieldError
|
|
for i, elem := range response {
|
|
if err := func() error {
|
|
if err := elem.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
failures = append(failures, validate.FieldError{
|
|
Name: fmt.Sprintf("[%d]", i),
|
|
Error: err,
|
|
})
|
|
}
|
|
}
|
|
if len(failures) > 0 {
|
|
return &validate.Error{Fields: failures}
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return response, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeListScriptsResponse(resp *http.Response) (res []Script, _ error) {
|
|
switch resp.StatusCode {
|
|
case 200:
|
|
// Code 200.
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response []Script
|
|
if err := func() error {
|
|
response = make([]Script, 0)
|
|
if err := d.Arr(func(d *jx.Decoder) error {
|
|
var elem Script
|
|
if err := elem.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
response = append(response, elem)
|
|
return nil
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if response == nil {
|
|
return errors.New("nil is invalid value")
|
|
}
|
|
var failures []validate.FieldError
|
|
for i, elem := range response {
|
|
if err := func() error {
|
|
if err := elem.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
failures = append(failures, validate.FieldError{
|
|
Name: fmt.Sprintf("[%d]", i),
|
|
Error: err,
|
|
})
|
|
}
|
|
}
|
|
if len(failures) > 0 {
|
|
return &validate.Error{Fields: failures}
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return response, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeListSubmissionAuditEventsResponse(resp *http.Response) (res []AuditEvent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 200:
|
|
// Code 200.
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response []AuditEvent
|
|
if err := func() error {
|
|
response = make([]AuditEvent, 0)
|
|
if err := d.Arr(func(d *jx.Decoder) error {
|
|
var elem AuditEvent
|
|
if err := elem.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
response = append(response, elem)
|
|
return nil
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if response == nil {
|
|
return errors.New("nil is invalid value")
|
|
}
|
|
var failures []validate.FieldError
|
|
for i, elem := range response {
|
|
if err := func() error {
|
|
if err := elem.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
failures = append(failures, validate.FieldError{
|
|
Name: fmt.Sprintf("[%d]", i),
|
|
Error: err,
|
|
})
|
|
}
|
|
}
|
|
if len(failures) > 0 {
|
|
return &validate.Error{Fields: failures}
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return response, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeListSubmissionsResponse(resp *http.Response) (res *Submissions, _ error) {
|
|
switch resp.StatusCode {
|
|
case 200:
|
|
// Code 200.
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Submissions
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &response, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeReleaseSubmissionsResponse(resp *http.Response) (res *OperationID, _ error) {
|
|
switch resp.StatusCode {
|
|
case 201:
|
|
// Code 201.
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response OperationID
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &response, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeSeedCombobulatorResponse(resp *http.Response) (res *SeedCombobulatorNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &SeedCombobulatorNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeSessionRolesResponse(resp *http.Response) (res *Roles, _ error) {
|
|
switch resp.StatusCode {
|
|
case 200:
|
|
// Code 200.
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Roles
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &response, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeSessionUserResponse(resp *http.Response) (res *User, _ error) {
|
|
switch resp.StatusCode {
|
|
case 200:
|
|
// Code 200.
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response User
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &response, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeSessionValidateResponse(resp *http.Response) (res bool, _ error) {
|
|
switch resp.StatusCode {
|
|
case 200:
|
|
// Code 200.
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response bool
|
|
if err := func() error {
|
|
v, err := d.Bool()
|
|
response = bool(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
return response, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeSetMapfixCompletedResponse(resp *http.Response) (res *SetMapfixCompletedNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &SetMapfixCompletedNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeSetSubmissionCompletedResponse(resp *http.Response) (res *SetSubmissionCompletedNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &SetSubmissionCompletedNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeUpdateMapfixDescriptionResponse(resp *http.Response) (res *UpdateMapfixDescriptionNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &UpdateMapfixDescriptionNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeUpdateMapfixModelResponse(resp *http.Response) (res *UpdateMapfixModelNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &UpdateMapfixModelNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeUpdateScriptResponse(resp *http.Response) (res *UpdateScriptNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &UpdateScriptNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeUpdateScriptPolicyResponse(resp *http.Response) (res *UpdateScriptPolicyNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &UpdateScriptPolicyNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|
|
|
|
func decodeUpdateSubmissionModelResponse(resp *http.Response) (res *UpdateSubmissionModelNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &UpdateSubmissionModelNoContent{}, nil
|
|
}
|
|
// Convenient error response.
|
|
defRes, err := func() (res *ErrorStatusCode, err error) {
|
|
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "parse media type")
|
|
}
|
|
switch {
|
|
case ct == "application/json":
|
|
buf, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
d := jx.DecodeBytes(buf)
|
|
|
|
var response Error
|
|
if err := func() error {
|
|
if err := response.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
if err := d.Skip(); err != io.EOF {
|
|
return errors.New("unexpected trailing data")
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
err = &ogenerrors.DecodeBodyError{
|
|
ContentType: ct,
|
|
Body: buf,
|
|
Err: err,
|
|
}
|
|
return res, err
|
|
}
|
|
// Validate response.
|
|
if err := func() error {
|
|
if err := response.Validate(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "validate")
|
|
}
|
|
return &ErrorStatusCode{
|
|
StatusCode: resp.StatusCode,
|
|
Response: response,
|
|
}, nil
|
|
default:
|
|
return res, validate.InvalidContentType(ct)
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
|
|
}
|
|
return res, errors.Wrap(defRes, "error")
|
|
}
|