1465 lines
35 KiB
Go
1465 lines
35 KiB
Go
// Code generated by ogen, DO NOT EDIT.
|
|
|
|
package api
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"mime"
|
|
"net/http"
|
|
|
|
"github.com/go-faster/errors"
|
|
"github.com/go-faster/jx"
|
|
|
|
"github.com/ogen-go/ogen/ogenerrors"
|
|
"github.com/ogen-go/ogen/validate"
|
|
)
|
|
|
|
func decodeActionSubmissionPublishResponse(resp *http.Response) (res *ActionSubmissionPublishNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &ActionSubmissionPublishNoContent{}, 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
|
|
}
|
|
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
|
|
}
|
|
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
|
|
}
|
|
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
|
|
}
|
|
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 decodeActionSubmissionSubmitResponse(resp *http.Response) (res *ActionSubmissionSubmitNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &ActionSubmissionSubmitNoContent{}, 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
|
|
}
|
|
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 decodeActionSubmissionTriggerPublishResponse(resp *http.Response) (res *ActionSubmissionTriggerPublishNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &ActionSubmissionTriggerPublishNoContent{}, 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
|
|
}
|
|
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
|
|
}
|
|
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 decodeActionSubmissionValidateResponse(resp *http.Response) (res *ActionSubmissionValidateNoContent, _ error) {
|
|
switch resp.StatusCode {
|
|
case 204:
|
|
// Code 204.
|
|
return &ActionSubmissionValidateNoContent{}, 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
|
|
}
|
|
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 *ID, _ 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 ID
|
|
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
|
|
}
|
|
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 *ID, _ 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 ID
|
|
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
|
|
}
|
|
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 *ID, _ 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 ID
|
|
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
|
|
}
|
|
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
|
|
}
|
|
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
|
|
}
|
|
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
|
|
}
|
|
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
|
|
}
|
|
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 decodeGetScriptPolicyFromHashResponse(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
|
|
}
|
|
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
|
|
}
|
|
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 []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 {
|
|
response = make([]Submission, 0)
|
|
if err := d.Arr(func(d *jx.Decoder) error {
|
|
var elem Submission
|
|
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
|
|
}
|
|
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
|
|
}
|
|
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
|
|
}
|
|
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
|
|
}
|
|
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
|
|
}
|
|
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")
|
|
}
|