maps-service/pkg/api/oas_parameters_gen.go

// Code generated by ogen, DO NOT EDIT.

package api

import (
	"net/http"
	"net/url"

	"github.com/go-faster/errors"
	"github.com/ogen-go/ogen/conv"
	"github.com/ogen-go/ogen/middleware"
	"github.com/ogen-go/ogen/ogenerrors"
	"github.com/ogen-go/ogen/uri"
	"github.com/ogen-go/ogen/validate"
)

// ActionMapfixAcceptedParams is parameters of actionMapfixAccepted operation.
type ActionMapfixAcceptedParams struct {
	// The unique identifier for a mapfix.
	MapfixID int64
}

func unpackActionMapfixAcceptedParams(packed middleware.Parameters) (params ActionMapfixAcceptedParams) {
	{
		key := middleware.ParameterKey{
			Name: "MapfixID",
			In:   "path",
		}
		params.MapfixID = packed[key].(int64)
	}
	return params
}

func decodeActionMapfixAcceptedParams(args [1]string, argsEscaped bool, r *http.Request) (params ActionMapfixAcceptedParams, _ error) {
	// Decode path: MapfixID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "MapfixID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.MapfixID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.MapfixID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "MapfixID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// ActionMapfixRejectParams is parameters of actionMapfixReject operation.
type ActionMapfixRejectParams struct {
	// The unique identifier for a mapfix.
	MapfixID int64
}

func unpackActionMapfixRejectParams(packed middleware.Parameters) (params ActionMapfixRejectParams) {
	{
		key := middleware.ParameterKey{
			Name: "MapfixID",
			In:   "path",
		}
		params.MapfixID = packed[key].(int64)
	}
	return params
}

func decodeActionMapfixRejectParams(args [1]string, argsEscaped bool, r *http.Request) (params ActionMapfixRejectParams, _ error) {
	// Decode path: MapfixID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "MapfixID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.MapfixID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.MapfixID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "MapfixID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// ActionMapfixRequestChangesParams is parameters of actionMapfixRequestChanges operation.
type ActionMapfixRequestChangesParams struct {
	// The unique identifier for a mapfix.
	MapfixID int64
}

func unpackActionMapfixRequestChangesParams(packed middleware.Parameters) (params ActionMapfixRequestChangesParams) {
	{
		key := middleware.ParameterKey{
			Name: "MapfixID",
			In:   "path",
		}
		params.MapfixID = packed[key].(int64)
	}
	return params
}

func decodeActionMapfixRequestChangesParams(args [1]string, argsEscaped bool, r *http.Request) (params ActionMapfixRequestChangesParams, _ error) {
	// Decode path: MapfixID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "MapfixID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.MapfixID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.MapfixID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "MapfixID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// ActionMapfixResetSubmittingParams is parameters of actionMapfixResetSubmitting operation.
type ActionMapfixResetSubmittingParams struct {
	// The unique identifier for a mapfix.
	MapfixID int64
}

func unpackActionMapfixResetSubmittingParams(packed middleware.Parameters) (params ActionMapfixResetSubmittingParams) {
	{
		key := middleware.ParameterKey{
			Name: "MapfixID",
			In:   "path",
		}
		params.MapfixID = packed[key].(int64)
	}
	return params
}

func decodeActionMapfixResetSubmittingParams(args [1]string, argsEscaped bool, r *http.Request) (params ActionMapfixResetSubmittingParams, _ error) {
	// Decode path: MapfixID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "MapfixID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.MapfixID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.MapfixID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "MapfixID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// ActionMapfixRetryValidateParams is parameters of actionMapfixRetryValidate operation.
type ActionMapfixRetryValidateParams struct {
	// The unique identifier for a mapfix.
	MapfixID int64
}

func unpackActionMapfixRetryValidateParams(packed middleware.Parameters) (params ActionMapfixRetryValidateParams) {
	{
		key := middleware.ParameterKey{
			Name: "MapfixID",
			In:   "path",
		}
		params.MapfixID = packed[key].(int64)
	}
	return params
}

func decodeActionMapfixRetryValidateParams(args [1]string, argsEscaped bool, r *http.Request) (params ActionMapfixRetryValidateParams, _ error) {
	// Decode path: MapfixID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "MapfixID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.MapfixID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.MapfixID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "MapfixID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// ActionMapfixRevokeParams is parameters of actionMapfixRevoke operation.
type ActionMapfixRevokeParams struct {
	// The unique identifier for a mapfix.
	MapfixID int64
}

func unpackActionMapfixRevokeParams(packed middleware.Parameters) (params ActionMapfixRevokeParams) {
	{
		key := middleware.ParameterKey{
			Name: "MapfixID",
			In:   "path",
		}
		params.MapfixID = packed[key].(int64)
	}
	return params
}

func decodeActionMapfixRevokeParams(args [1]string, argsEscaped bool, r *http.Request) (params ActionMapfixRevokeParams, _ error) {
	// Decode path: MapfixID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "MapfixID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.MapfixID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.MapfixID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "MapfixID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// ActionMapfixTriggerReleaseParams is parameters of actionMapfixTriggerRelease operation.
type ActionMapfixTriggerReleaseParams struct {
	// The unique identifier for a mapfix.
	MapfixID int64
}

func unpackActionMapfixTriggerReleaseParams(packed middleware.Parameters) (params ActionMapfixTriggerReleaseParams) {
	{
		key := middleware.ParameterKey{
			Name: "MapfixID",
			In:   "path",
		}
		params.MapfixID = packed[key].(int64)
	}
	return params
}

func decodeActionMapfixTriggerReleaseParams(args [1]string, argsEscaped bool, r *http.Request) (params ActionMapfixTriggerReleaseParams, _ error) {
	// Decode path: MapfixID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "MapfixID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.MapfixID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.MapfixID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "MapfixID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// ActionMapfixTriggerSubmitParams is parameters of actionMapfixTriggerSubmit operation.
type ActionMapfixTriggerSubmitParams struct {
	// The unique identifier for a mapfix.
	MapfixID int64
}

func unpackActionMapfixTriggerSubmitParams(packed middleware.Parameters) (params ActionMapfixTriggerSubmitParams) {
	{
		key := middleware.ParameterKey{
			Name: "MapfixID",
			In:   "path",
		}
		params.MapfixID = packed[key].(int64)
	}
	return params
}

func decodeActionMapfixTriggerSubmitParams(args [1]string, argsEscaped bool, r *http.Request) (params ActionMapfixTriggerSubmitParams, _ error) {
	// Decode path: MapfixID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "MapfixID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.MapfixID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.MapfixID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "MapfixID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// ActionMapfixTriggerSubmitUncheckedParams is parameters of actionMapfixTriggerSubmitUnchecked operation.
type ActionMapfixTriggerSubmitUncheckedParams struct {
	// The unique identifier for a mapfix.
	MapfixID int64
}

func unpackActionMapfixTriggerSubmitUncheckedParams(packed middleware.Parameters) (params ActionMapfixTriggerSubmitUncheckedParams) {
	{
		key := middleware.ParameterKey{
			Name: "MapfixID",
			In:   "path",
		}
		params.MapfixID = packed[key].(int64)
	}
	return params
}

func decodeActionMapfixTriggerSubmitUncheckedParams(args [1]string, argsEscaped bool, r *http.Request) (params ActionMapfixTriggerSubmitUncheckedParams, _ error) {
	// Decode path: MapfixID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "MapfixID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.MapfixID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.MapfixID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "MapfixID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// ActionMapfixTriggerUploadParams is parameters of actionMapfixTriggerUpload operation.
type ActionMapfixTriggerUploadParams struct {
	// The unique identifier for a mapfix.
	MapfixID int64
}

func unpackActionMapfixTriggerUploadParams(packed middleware.Parameters) (params ActionMapfixTriggerUploadParams) {
	{
		key := middleware.ParameterKey{
			Name: "MapfixID",
			In:   "path",
		}
		params.MapfixID = packed[key].(int64)
	}
	return params
}

func decodeActionMapfixTriggerUploadParams(args [1]string, argsEscaped bool, r *http.Request) (params ActionMapfixTriggerUploadParams, _ error) {
	// Decode path: MapfixID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "MapfixID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.MapfixID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.MapfixID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "MapfixID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// ActionMapfixTriggerValidateParams is parameters of actionMapfixTriggerValidate operation.
type ActionMapfixTriggerValidateParams struct {
	// The unique identifier for a mapfix.
	MapfixID int64
}

func unpackActionMapfixTriggerValidateParams(packed middleware.Parameters) (params ActionMapfixTriggerValidateParams) {
	{
		key := middleware.ParameterKey{
			Name: "MapfixID",
			In:   "path",
		}
		params.MapfixID = packed[key].(int64)
	}
	return params
}

func decodeActionMapfixTriggerValidateParams(args [1]string, argsEscaped bool, r *http.Request) (params ActionMapfixTriggerValidateParams, _ error) {
	// Decode path: MapfixID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "MapfixID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.MapfixID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.MapfixID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "MapfixID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// ActionMapfixUploadedParams is parameters of actionMapfixUploaded operation.
type ActionMapfixUploadedParams struct {
	// The unique identifier for a mapfix.
	MapfixID int64
}

func unpackActionMapfixUploadedParams(packed middleware.Parameters) (params ActionMapfixUploadedParams) {
	{
		key := middleware.ParameterKey{
			Name: "MapfixID",
			In:   "path",
		}
		params.MapfixID = packed[key].(int64)
	}
	return params
}

func decodeActionMapfixUploadedParams(args [1]string, argsEscaped bool, r *http.Request) (params ActionMapfixUploadedParams, _ error) {
	// Decode path: MapfixID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "MapfixID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.MapfixID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.MapfixID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "MapfixID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// ActionMapfixValidatedParams is parameters of actionMapfixValidated operation.
type ActionMapfixValidatedParams struct {
	// The unique identifier for a mapfix.
	MapfixID int64
}

func unpackActionMapfixValidatedParams(packed middleware.Parameters) (params ActionMapfixValidatedParams) {
	{
		key := middleware.ParameterKey{
			Name: "MapfixID",
			In:   "path",
		}
		params.MapfixID = packed[key].(int64)
	}
	return params
}

func decodeActionMapfixValidatedParams(args [1]string, argsEscaped bool, r *http.Request) (params ActionMapfixValidatedParams, _ error) {
	// Decode path: MapfixID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "MapfixID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.MapfixID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.MapfixID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "MapfixID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// ActionSubmissionAcceptedParams is parameters of actionSubmissionAccepted operation.
type ActionSubmissionAcceptedParams struct {
	// The unique identifier for a submission.
	SubmissionID int64
}

func unpackActionSubmissionAcceptedParams(packed middleware.Parameters) (params ActionSubmissionAcceptedParams) {
	{
		key := middleware.ParameterKey{
			Name: "SubmissionID",
			In:   "path",
		}
		params.SubmissionID = packed[key].(int64)
	}
	return params
}

func decodeActionSubmissionAcceptedParams(args [1]string, argsEscaped bool, r *http.Request) (params ActionSubmissionAcceptedParams, _ error) {
	// Decode path: SubmissionID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "SubmissionID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.SubmissionID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.SubmissionID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "SubmissionID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// ActionSubmissionRejectParams is parameters of actionSubmissionReject operation.
type ActionSubmissionRejectParams struct {
	// The unique identifier for a submission.
	SubmissionID int64
}

func unpackActionSubmissionRejectParams(packed middleware.Parameters) (params ActionSubmissionRejectParams) {
	{
		key := middleware.ParameterKey{
			Name: "SubmissionID",
			In:   "path",
		}
		params.SubmissionID = packed[key].(int64)
	}
	return params
}

func decodeActionSubmissionRejectParams(args [1]string, argsEscaped bool, r *http.Request) (params ActionSubmissionRejectParams, _ error) {
	// Decode path: SubmissionID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "SubmissionID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.SubmissionID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.SubmissionID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "SubmissionID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// ActionSubmissionRequestChangesParams is parameters of actionSubmissionRequestChanges operation.
type ActionSubmissionRequestChangesParams struct {
	// The unique identifier for a submission.
	SubmissionID int64
}

func unpackActionSubmissionRequestChangesParams(packed middleware.Parameters) (params ActionSubmissionRequestChangesParams) {
	{
		key := middleware.ParameterKey{
			Name: "SubmissionID",
			In:   "path",
		}
		params.SubmissionID = packed[key].(int64)
	}
	return params
}

func decodeActionSubmissionRequestChangesParams(args [1]string, argsEscaped bool, r *http.Request) (params ActionSubmissionRequestChangesParams, _ error) {
	// Decode path: SubmissionID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "SubmissionID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.SubmissionID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.SubmissionID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "SubmissionID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// ActionSubmissionResetSubmittingParams is parameters of actionSubmissionResetSubmitting operation.
type ActionSubmissionResetSubmittingParams struct {
	// The unique identifier for a submission.
	SubmissionID int64
}

func unpackActionSubmissionResetSubmittingParams(packed middleware.Parameters) (params ActionSubmissionResetSubmittingParams) {
	{
		key := middleware.ParameterKey{
			Name: "SubmissionID",
			In:   "path",
		}
		params.SubmissionID = packed[key].(int64)
	}
	return params
}

func decodeActionSubmissionResetSubmittingParams(args [1]string, argsEscaped bool, r *http.Request) (params ActionSubmissionResetSubmittingParams, _ error) {
	// Decode path: SubmissionID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "SubmissionID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.SubmissionID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.SubmissionID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "SubmissionID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// ActionSubmissionRetryValidateParams is parameters of actionSubmissionRetryValidate operation.
type ActionSubmissionRetryValidateParams struct {
	// The unique identifier for a submission.
	SubmissionID int64
}

func unpackActionSubmissionRetryValidateParams(packed middleware.Parameters) (params ActionSubmissionRetryValidateParams) {
	{
		key := middleware.ParameterKey{
			Name: "SubmissionID",
			In:   "path",
		}
		params.SubmissionID = packed[key].(int64)
	}
	return params
}

func decodeActionSubmissionRetryValidateParams(args [1]string, argsEscaped bool, r *http.Request) (params ActionSubmissionRetryValidateParams, _ error) {
	// Decode path: SubmissionID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "SubmissionID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.SubmissionID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.SubmissionID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "SubmissionID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// ActionSubmissionRevokeParams is parameters of actionSubmissionRevoke operation.
type ActionSubmissionRevokeParams struct {
	// The unique identifier for a submission.
	SubmissionID int64
}

func unpackActionSubmissionRevokeParams(packed middleware.Parameters) (params ActionSubmissionRevokeParams) {
	{
		key := middleware.ParameterKey{
			Name: "SubmissionID",
			In:   "path",
		}
		params.SubmissionID = packed[key].(int64)
	}
	return params
}

func decodeActionSubmissionRevokeParams(args [1]string, argsEscaped bool, r *http.Request) (params ActionSubmissionRevokeParams, _ error) {
	// Decode path: SubmissionID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "SubmissionID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.SubmissionID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.SubmissionID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "SubmissionID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// ActionSubmissionTriggerSubmitParams is parameters of actionSubmissionTriggerSubmit operation.
type ActionSubmissionTriggerSubmitParams struct {
	// The unique identifier for a submission.
	SubmissionID int64
}

func unpackActionSubmissionTriggerSubmitParams(packed middleware.Parameters) (params ActionSubmissionTriggerSubmitParams) {
	{
		key := middleware.ParameterKey{
			Name: "SubmissionID",
			In:   "path",
		}
		params.SubmissionID = packed[key].(int64)
	}
	return params
}

func decodeActionSubmissionTriggerSubmitParams(args [1]string, argsEscaped bool, r *http.Request) (params ActionSubmissionTriggerSubmitParams, _ error) {
	// Decode path: SubmissionID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "SubmissionID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.SubmissionID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.SubmissionID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "SubmissionID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// ActionSubmissionTriggerSubmitUncheckedParams is parameters of actionSubmissionTriggerSubmitUnchecked operation.
type ActionSubmissionTriggerSubmitUncheckedParams struct {
	// The unique identifier for a submission.
	SubmissionID int64
}

func unpackActionSubmissionTriggerSubmitUncheckedParams(packed middleware.Parameters) (params ActionSubmissionTriggerSubmitUncheckedParams) {
	{
		key := middleware.ParameterKey{
			Name: "SubmissionID",
			In:   "path",
		}
		params.SubmissionID = packed[key].(int64)
	}
	return params
}

func decodeActionSubmissionTriggerSubmitUncheckedParams(args [1]string, argsEscaped bool, r *http.Request) (params ActionSubmissionTriggerSubmitUncheckedParams, _ error) {
	// Decode path: SubmissionID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "SubmissionID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.SubmissionID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.SubmissionID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "SubmissionID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// ActionSubmissionTriggerUploadParams is parameters of actionSubmissionTriggerUpload operation.
type ActionSubmissionTriggerUploadParams struct {
	// The unique identifier for a submission.
	SubmissionID int64
}

func unpackActionSubmissionTriggerUploadParams(packed middleware.Parameters) (params ActionSubmissionTriggerUploadParams) {
	{
		key := middleware.ParameterKey{
			Name: "SubmissionID",
			In:   "path",
		}
		params.SubmissionID = packed[key].(int64)
	}
	return params
}

func decodeActionSubmissionTriggerUploadParams(args [1]string, argsEscaped bool, r *http.Request) (params ActionSubmissionTriggerUploadParams, _ error) {
	// Decode path: SubmissionID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "SubmissionID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.SubmissionID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.SubmissionID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "SubmissionID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// ActionSubmissionTriggerValidateParams is parameters of actionSubmissionTriggerValidate operation.
type ActionSubmissionTriggerValidateParams struct {
	// The unique identifier for a submission.
	SubmissionID int64
}

func unpackActionSubmissionTriggerValidateParams(packed middleware.Parameters) (params ActionSubmissionTriggerValidateParams) {
	{
		key := middleware.ParameterKey{
			Name: "SubmissionID",
			In:   "path",
		}
		params.SubmissionID = packed[key].(int64)
	}
	return params
}

func decodeActionSubmissionTriggerValidateParams(args [1]string, argsEscaped bool, r *http.Request) (params ActionSubmissionTriggerValidateParams, _ error) {
	// Decode path: SubmissionID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "SubmissionID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.SubmissionID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.SubmissionID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "SubmissionID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// ActionSubmissionValidatedParams is parameters of actionSubmissionValidated operation.
type ActionSubmissionValidatedParams struct {
	// The unique identifier for a submission.
	SubmissionID int64
}

func unpackActionSubmissionValidatedParams(packed middleware.Parameters) (params ActionSubmissionValidatedParams) {
	{
		key := middleware.ParameterKey{
			Name: "SubmissionID",
			In:   "path",
		}
		params.SubmissionID = packed[key].(int64)
	}
	return params
}

func decodeActionSubmissionValidatedParams(args [1]string, argsEscaped bool, r *http.Request) (params ActionSubmissionValidatedParams, _ error) {
	// Decode path: SubmissionID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "SubmissionID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.SubmissionID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.SubmissionID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "SubmissionID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// CombobulateParams is parameters of combobulate operation.
type CombobulateParams struct {
	MapID int64
}

func unpackCombobulateParams(packed middleware.Parameters) (params CombobulateParams) {
	{
		key := middleware.ParameterKey{
			Name: "MapID",
			In:   "path",
		}
		params.MapID = packed[key].(int64)
	}
	return params
}

func decodeCombobulateParams(args [1]string, argsEscaped bool, r *http.Request) (params CombobulateParams, _ error) {
	// Decode path: MapID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "MapID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.MapID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.MapID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "MapID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// CreateMapfixAuditCommentParams is parameters of createMapfixAuditComment operation.
type CreateMapfixAuditCommentParams struct {
	// The unique identifier for a mapfix.
	MapfixID int64
}

func unpackCreateMapfixAuditCommentParams(packed middleware.Parameters) (params CreateMapfixAuditCommentParams) {
	{
		key := middleware.ParameterKey{
			Name: "MapfixID",
			In:   "path",
		}
		params.MapfixID = packed[key].(int64)
	}
	return params
}

func decodeCreateMapfixAuditCommentParams(args [1]string, argsEscaped bool, r *http.Request) (params CreateMapfixAuditCommentParams, _ error) {
	// Decode path: MapfixID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "MapfixID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.MapfixID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.MapfixID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "MapfixID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// CreateSubmissionAuditCommentParams is parameters of createSubmissionAuditComment operation.
type CreateSubmissionAuditCommentParams struct {
	// The unique identifier for a submission.
	SubmissionID int64
}

func unpackCreateSubmissionAuditCommentParams(packed middleware.Parameters) (params CreateSubmissionAuditCommentParams) {
	{
		key := middleware.ParameterKey{
			Name: "SubmissionID",
			In:   "path",
		}
		params.SubmissionID = packed[key].(int64)
	}
	return params
}

func decodeCreateSubmissionAuditCommentParams(args [1]string, argsEscaped bool, r *http.Request) (params CreateSubmissionAuditCommentParams, _ error) {
	// Decode path: SubmissionID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "SubmissionID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.SubmissionID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.SubmissionID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "SubmissionID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// DeleteScriptParams is parameters of deleteScript operation.
type DeleteScriptParams struct {
	// The unique identifier for a script.
	ScriptID int64
}

func unpackDeleteScriptParams(packed middleware.Parameters) (params DeleteScriptParams) {
	{
		key := middleware.ParameterKey{
			Name: "ScriptID",
			In:   "path",
		}
		params.ScriptID = packed[key].(int64)
	}
	return params
}

func decodeDeleteScriptParams(args [1]string, argsEscaped bool, r *http.Request) (params DeleteScriptParams, _ error) {
	// Decode path: ScriptID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "ScriptID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.ScriptID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.ScriptID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "ScriptID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// DeleteScriptPolicyParams is parameters of deleteScriptPolicy operation.
type DeleteScriptPolicyParams struct {
	// The unique identifier for a script policy.
	ScriptPolicyID int64
}

func unpackDeleteScriptPolicyParams(packed middleware.Parameters) (params DeleteScriptPolicyParams) {
	{
		key := middleware.ParameterKey{
			Name: "ScriptPolicyID",
			In:   "path",
		}
		params.ScriptPolicyID = packed[key].(int64)
	}
	return params
}

func decodeDeleteScriptPolicyParams(args [1]string, argsEscaped bool, r *http.Request) (params DeleteScriptPolicyParams, _ error) {
	// Decode path: ScriptPolicyID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "ScriptPolicyID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.ScriptPolicyID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.ScriptPolicyID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "ScriptPolicyID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// DownloadMapAssetParams is parameters of downloadMapAsset operation.
type DownloadMapAssetParams struct {
	MapID int64
}

func unpackDownloadMapAssetParams(packed middleware.Parameters) (params DownloadMapAssetParams) {
	{
		key := middleware.ParameterKey{
			Name: "MapID",
			In:   "path",
		}
		params.MapID = packed[key].(int64)
	}
	return params
}

func decodeDownloadMapAssetParams(args [1]string, argsEscaped bool, r *http.Request) (params DownloadMapAssetParams, _ error) {
	// Decode path: MapID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "MapID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.MapID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.MapID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "MapID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// GetAssetThumbnailParams is parameters of getAssetThumbnail operation.
type GetAssetThumbnailParams struct {
	AssetID uint64
	Size    OptGetAssetThumbnailSize `json:",omitempty,omitzero"`
}

func unpackGetAssetThumbnailParams(packed middleware.Parameters) (params GetAssetThumbnailParams) {
	{
		key := middleware.ParameterKey{
			Name: "AssetID",
			In:   "path",
		}
		params.AssetID = packed[key].(uint64)
	}
	{
		key := middleware.ParameterKey{
			Name: "size",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Size = v.(OptGetAssetThumbnailSize)
		}
	}
	return params
}

func decodeGetAssetThumbnailParams(args [1]string, argsEscaped bool, r *http.Request) (params GetAssetThumbnailParams, _ error) {
	q := uri.NewQueryDecoder(r.URL.Query())
	// Decode path: AssetID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "AssetID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToUint64(val)
				if err != nil {
					return err
				}

				params.AssetID = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "AssetID",
			In:   "path",
			Err:  err,
		}
	}
	// Set default value for query: size.
	{
		val := GetAssetThumbnailSize("420x420")
		params.Size.SetTo(val)
	}
	// Decode query: size.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "size",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotSizeVal GetAssetThumbnailSize
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					paramsDotSizeVal = GetAssetThumbnailSize(c)
					return nil
				}(); err != nil {
					return err
				}
				params.Size.SetTo(paramsDotSizeVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.Size.Get(); ok {
					if err := func() error {
						if err := value.Validate(); err != nil {
							return err
						}
						return nil
					}(); err != nil {
						return err
					}
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "size",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// GetMapParams is parameters of getMap operation.
type GetMapParams struct {
	// The unique identifier for a map.
	MapID int64
}

func unpackGetMapParams(packed middleware.Parameters) (params GetMapParams) {
	{
		key := middleware.ParameterKey{
			Name: "MapID",
			In:   "path",
		}
		params.MapID = packed[key].(int64)
	}
	return params
}

func decodeGetMapParams(args [1]string, argsEscaped bool, r *http.Request) (params GetMapParams, _ error) {
	// Decode path: MapID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "MapID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.MapID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.MapID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "MapID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// GetMapfixParams is parameters of getMapfix operation.
type GetMapfixParams struct {
	// The unique identifier for a mapfix.
	MapfixID int64
}

func unpackGetMapfixParams(packed middleware.Parameters) (params GetMapfixParams) {
	{
		key := middleware.ParameterKey{
			Name: "MapfixID",
			In:   "path",
		}
		params.MapfixID = packed[key].(int64)
	}
	return params
}

func decodeGetMapfixParams(args [1]string, argsEscaped bool, r *http.Request) (params GetMapfixParams, _ error) {
	// Decode path: MapfixID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "MapfixID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.MapfixID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.MapfixID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "MapfixID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// GetOperationParams is parameters of getOperation operation.
type GetOperationParams struct {
	// The unique identifier for a long-running operation.
	OperationID int32
}

func unpackGetOperationParams(packed middleware.Parameters) (params GetOperationParams) {
	{
		key := middleware.ParameterKey{
			Name: "OperationID",
			In:   "path",
		}
		params.OperationID = packed[key].(int32)
	}
	return params
}

func decodeGetOperationParams(args [1]string, argsEscaped bool, r *http.Request) (params GetOperationParams, _ error) {
	// Decode path: OperationID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "OperationID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt32(val)
				if err != nil {
					return err
				}

				params.OperationID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.OperationID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "OperationID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// GetScriptParams is parameters of getScript operation.
type GetScriptParams struct {
	// The unique identifier for a script.
	ScriptID int64
}

func unpackGetScriptParams(packed middleware.Parameters) (params GetScriptParams) {
	{
		key := middleware.ParameterKey{
			Name: "ScriptID",
			In:   "path",
		}
		params.ScriptID = packed[key].(int64)
	}
	return params
}

func decodeGetScriptParams(args [1]string, argsEscaped bool, r *http.Request) (params GetScriptParams, _ error) {
	// Decode path: ScriptID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "ScriptID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.ScriptID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.ScriptID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "ScriptID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// GetScriptPolicyParams is parameters of getScriptPolicy operation.
type GetScriptPolicyParams struct {
	// The unique identifier for a script policy.
	ScriptPolicyID int64
}

func unpackGetScriptPolicyParams(packed middleware.Parameters) (params GetScriptPolicyParams) {
	{
		key := middleware.ParameterKey{
			Name: "ScriptPolicyID",
			In:   "path",
		}
		params.ScriptPolicyID = packed[key].(int64)
	}
	return params
}

func decodeGetScriptPolicyParams(args [1]string, argsEscaped bool, r *http.Request) (params GetScriptPolicyParams, _ error) {
	// Decode path: ScriptPolicyID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "ScriptPolicyID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.ScriptPolicyID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.ScriptPolicyID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "ScriptPolicyID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// GetSubmissionParams is parameters of getSubmission operation.
type GetSubmissionParams struct {
	// The unique identifier for a submission.
	SubmissionID int64
}

func unpackGetSubmissionParams(packed middleware.Parameters) (params GetSubmissionParams) {
	{
		key := middleware.ParameterKey{
			Name: "SubmissionID",
			In:   "path",
		}
		params.SubmissionID = packed[key].(int64)
	}
	return params
}

func decodeGetSubmissionParams(args [1]string, argsEscaped bool, r *http.Request) (params GetSubmissionParams, _ error) {
	// Decode path: SubmissionID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "SubmissionID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.SubmissionID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.SubmissionID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "SubmissionID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// GetUserThumbnailParams is parameters of getUserThumbnail operation.
type GetUserThumbnailParams struct {
	UserID uint64
	Size   OptGetUserThumbnailSize `json:",omitempty,omitzero"`
}

func unpackGetUserThumbnailParams(packed middleware.Parameters) (params GetUserThumbnailParams) {
	{
		key := middleware.ParameterKey{
			Name: "UserID",
			In:   "path",
		}
		params.UserID = packed[key].(uint64)
	}
	{
		key := middleware.ParameterKey{
			Name: "size",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Size = v.(OptGetUserThumbnailSize)
		}
	}
	return params
}

func decodeGetUserThumbnailParams(args [1]string, argsEscaped bool, r *http.Request) (params GetUserThumbnailParams, _ error) {
	q := uri.NewQueryDecoder(r.URL.Query())
	// Decode path: UserID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "UserID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToUint64(val)
				if err != nil {
					return err
				}

				params.UserID = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "UserID",
			In:   "path",
			Err:  err,
		}
	}
	// Set default value for query: size.
	{
		val := GetUserThumbnailSize("150x150")
		params.Size.SetTo(val)
	}
	// Decode query: size.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "size",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotSizeVal GetUserThumbnailSize
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					paramsDotSizeVal = GetUserThumbnailSize(c)
					return nil
				}(); err != nil {
					return err
				}
				params.Size.SetTo(paramsDotSizeVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.Size.Get(); ok {
					if err := func() error {
						if err := value.Validate(); err != nil {
							return err
						}
						return nil
					}(); err != nil {
						return err
					}
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "size",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// ListMapfixAuditEventsParams is parameters of listMapfixAuditEvents operation.
type ListMapfixAuditEventsParams struct {
	// The unique identifier for a mapfix.
	MapfixID int64
	Page     int32
	Limit    int32
}

func unpackListMapfixAuditEventsParams(packed middleware.Parameters) (params ListMapfixAuditEventsParams) {
	{
		key := middleware.ParameterKey{
			Name: "MapfixID",
			In:   "path",
		}
		params.MapfixID = packed[key].(int64)
	}
	{
		key := middleware.ParameterKey{
			Name: "Page",
			In:   "query",
		}
		params.Page = packed[key].(int32)
	}
	{
		key := middleware.ParameterKey{
			Name: "Limit",
			In:   "query",
		}
		params.Limit = packed[key].(int32)
	}
	return params
}

func decodeListMapfixAuditEventsParams(args [1]string, argsEscaped bool, r *http.Request) (params ListMapfixAuditEventsParams, _ error) {
	q := uri.NewQueryDecoder(r.URL.Query())
	// Decode path: MapfixID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "MapfixID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.MapfixID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.MapfixID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "MapfixID",
			In:   "path",
			Err:  err,
		}
	}
	// Decode query: Page.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "Page",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt32(val)
				if err != nil {
					return err
				}

				params.Page = c
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           1,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.Page)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return err
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "Page",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: Limit.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "Limit",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt32(val)
				if err != nil {
					return err
				}

				params.Limit = c
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        true,
					Max:           100,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.Limit)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return err
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "Limit",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// ListMapfixesParams is parameters of listMapfixes operation.
type ListMapfixesParams struct {
	Page        int32
	Limit       int32
	DisplayName OptString `json:",omitempty,omitzero"`
	Creator     OptString `json:",omitempty,omitzero"`
	// Game ID: * `1` - Bhop * `2` - Surf * `5` - FlyTrials.
	GameID OptInt32 `json:",omitempty,omitzero"`
	// Sort order: * `0` - Disabled * `1` - DisplayNameAscending * `2` - DisplayNameDescending * `3` -
	// DateAscending * `4` - DateDescending.
	Sort          OptInt32 `json:",omitempty,omitzero"`
	Submitter     OptInt64 `json:",omitempty,omitzero"`
	AssetID       OptInt64 `json:",omitempty,omitzero"`
	AssetVersion  OptInt64 `json:",omitempty,omitzero"`
	TargetAssetID OptInt64 `json:",omitempty,omitzero"`
	// // Phase: Creation * `0` - UnderConstruction * `1` - ChangesRequested
	// // Phase: Review * `2` - Submitting * `3` - Submitted
	// // Phase: Testing * `4` - AcceptedUnvalidated // pending script review, can re-trigger validation
	// * `5` - Validating * `6` - Validated * `7` - Uploading
	// // Phase: Final MapfixStatus * `8` - Uploaded // uploaded to the group, but pending release * `9`
	// - Rejected.
	StatusID OptInt32 `json:",omitempty,omitzero"`
}

func unpackListMapfixesParams(packed middleware.Parameters) (params ListMapfixesParams) {
	{
		key := middleware.ParameterKey{
			Name: "Page",
			In:   "query",
		}
		params.Page = packed[key].(int32)
	}
	{
		key := middleware.ParameterKey{
			Name: "Limit",
			In:   "query",
		}
		params.Limit = packed[key].(int32)
	}
	{
		key := middleware.ParameterKey{
			Name: "DisplayName",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.DisplayName = v.(OptString)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "Creator",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Creator = v.(OptString)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "GameID",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.GameID = v.(OptInt32)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "Sort",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Sort = v.(OptInt32)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "Submitter",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Submitter = v.(OptInt64)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "AssetID",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.AssetID = v.(OptInt64)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "AssetVersion",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.AssetVersion = v.(OptInt64)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "TargetAssetID",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.TargetAssetID = v.(OptInt64)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "StatusID",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.StatusID = v.(OptInt32)
		}
	}
	return params
}

func decodeListMapfixesParams(args [0]string, argsEscaped bool, r *http.Request) (params ListMapfixesParams, _ error) {
	q := uri.NewQueryDecoder(r.URL.Query())
	// Decode query: Page.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "Page",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt32(val)
				if err != nil {
					return err
				}

				params.Page = c
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           1,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.Page)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return err
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "Page",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: Limit.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "Limit",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt32(val)
				if err != nil {
					return err
				}

				params.Limit = c
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        true,
					Max:           100,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.Limit)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return err
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "Limit",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: DisplayName.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "DisplayName",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotDisplayNameVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					paramsDotDisplayNameVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.DisplayName.SetTo(paramsDotDisplayNameVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.DisplayName.Get(); ok {
					if err := func() error {
						if err := (validate.String{
							MinLength:     0,
							MinLengthSet:  false,
							MaxLength:     128,
							MaxLengthSet:  true,
							Email:         false,
							Hostname:      false,
							Regex:         nil,
							MinNumeric:    0,
							MinNumericSet: false,
							MaxNumeric:    0,
							MaxNumericSet: false,
						}).Validate(string(value)); err != nil {
							return errors.Wrap(err, "string")
						}
						return nil
					}(); err != nil {
						return err
					}
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "DisplayName",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: Creator.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "Creator",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotCreatorVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					paramsDotCreatorVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.Creator.SetTo(paramsDotCreatorVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.Creator.Get(); ok {
					if err := func() error {
						if err := (validate.String{
							MinLength:     0,
							MinLengthSet:  false,
							MaxLength:     128,
							MaxLengthSet:  true,
							Email:         false,
							Hostname:      false,
							Regex:         nil,
							MinNumeric:    0,
							MinNumericSet: false,
							MaxNumeric:    0,
							MaxNumericSet: false,
						}).Validate(string(value)); err != nil {
							return errors.Wrap(err, "string")
						}
						return nil
					}(); err != nil {
						return err
					}
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "Creator",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: GameID.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "GameID",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotGameIDVal int32
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToInt32(val)
					if err != nil {
						return err
					}

					paramsDotGameIDVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.GameID.SetTo(paramsDotGameIDVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.GameID.Get(); ok {
					if err := func() error {
						if err := (validate.Int{
							MinSet:        true,
							Min:           1,
							MaxSet:        true,
							Max:           5,
							MinExclusive:  false,
							MaxExclusive:  false,
							MultipleOfSet: false,
							MultipleOf:    0,
							Pattern:       nil,
						}).Validate(int64(value)); err != nil {
							return errors.Wrap(err, "int")
						}
						return nil
					}(); err != nil {
						return err
					}
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "GameID",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: Sort.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "Sort",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotSortVal int32
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToInt32(val)
					if err != nil {
						return err
					}

					paramsDotSortVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.Sort.SetTo(paramsDotSortVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.Sort.Get(); ok {
					if err := func() error {
						if err := (validate.Int{
							MinSet:        true,
							Min:           0,
							MaxSet:        true,
							Max:           4,
							MinExclusive:  false,
							MaxExclusive:  false,
							MultipleOfSet: false,
							MultipleOf:    0,
							Pattern:       nil,
						}).Validate(int64(value)); err != nil {
							return errors.Wrap(err, "int")
						}
						return nil
					}(); err != nil {
						return err
					}
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "Sort",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: Submitter.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "Submitter",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotSubmitterVal int64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToInt64(val)
					if err != nil {
						return err
					}

					paramsDotSubmitterVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.Submitter.SetTo(paramsDotSubmitterVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.Submitter.Get(); ok {
					if err := func() error {
						if err := (validate.Int{
							MinSet:        true,
							Min:           0,
							MaxSet:        false,
							Max:           0,
							MinExclusive:  false,
							MaxExclusive:  false,
							MultipleOfSet: false,
							MultipleOf:    0,
							Pattern:       nil,
						}).Validate(int64(value)); err != nil {
							return errors.Wrap(err, "int")
						}
						return nil
					}(); err != nil {
						return err
					}
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "Submitter",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: AssetID.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "AssetID",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotAssetIDVal int64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToInt64(val)
					if err != nil {
						return err
					}

					paramsDotAssetIDVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.AssetID.SetTo(paramsDotAssetIDVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.AssetID.Get(); ok {
					if err := func() error {
						if err := (validate.Int{
							MinSet:        true,
							Min:           0,
							MaxSet:        false,
							Max:           0,
							MinExclusive:  false,
							MaxExclusive:  false,
							MultipleOfSet: false,
							MultipleOf:    0,
							Pattern:       nil,
						}).Validate(int64(value)); err != nil {
							return errors.Wrap(err, "int")
						}
						return nil
					}(); err != nil {
						return err
					}
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "AssetID",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: AssetVersion.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "AssetVersion",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotAssetVersionVal int64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToInt64(val)
					if err != nil {
						return err
					}

					paramsDotAssetVersionVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.AssetVersion.SetTo(paramsDotAssetVersionVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.AssetVersion.Get(); ok {
					if err := func() error {
						if err := (validate.Int{
							MinSet:        true,
							Min:           0,
							MaxSet:        false,
							Max:           0,
							MinExclusive:  false,
							MaxExclusive:  false,
							MultipleOfSet: false,
							MultipleOf:    0,
							Pattern:       nil,
						}).Validate(int64(value)); err != nil {
							return errors.Wrap(err, "int")
						}
						return nil
					}(); err != nil {
						return err
					}
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "AssetVersion",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: TargetAssetID.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "TargetAssetID",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotTargetAssetIDVal int64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToInt64(val)
					if err != nil {
						return err
					}

					paramsDotTargetAssetIDVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.TargetAssetID.SetTo(paramsDotTargetAssetIDVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.TargetAssetID.Get(); ok {
					if err := func() error {
						if err := (validate.Int{
							MinSet:        true,
							Min:           0,
							MaxSet:        false,
							Max:           0,
							MinExclusive:  false,
							MaxExclusive:  false,
							MultipleOfSet: false,
							MultipleOf:    0,
							Pattern:       nil,
						}).Validate(int64(value)); err != nil {
							return errors.Wrap(err, "int")
						}
						return nil
					}(); err != nil {
						return err
					}
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "TargetAssetID",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: StatusID.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "StatusID",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotStatusIDVal int32
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToInt32(val)
					if err != nil {
						return err
					}

					paramsDotStatusIDVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.StatusID.SetTo(paramsDotStatusIDVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.StatusID.Get(); ok {
					if err := func() error {
						if err := (validate.Int{
							MinSet:        true,
							Min:           0,
							MaxSet:        true,
							Max:           9,
							MinExclusive:  false,
							MaxExclusive:  false,
							MultipleOfSet: false,
							MultipleOf:    0,
							Pattern:       nil,
						}).Validate(int64(value)); err != nil {
							return errors.Wrap(err, "int")
						}
						return nil
					}(); err != nil {
						return err
					}
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "StatusID",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// ListMapsParams is parameters of listMaps operation.
type ListMapsParams struct {
	Page        int32
	Limit       int32
	DisplayName OptString `json:",omitempty,omitzero"`
	Creator     OptString `json:",omitempty,omitzero"`
	GameID      OptInt32  `json:",omitempty,omitzero"`
	// Sort order: * `0` - Disabled * `1` - DisplayNameAscending * `2` - DisplayNameDescending * `3` -
	// DateAscending * `4` - DateDescending.
	Sort OptInt32 `json:",omitempty,omitzero"`
}

func unpackListMapsParams(packed middleware.Parameters) (params ListMapsParams) {
	{
		key := middleware.ParameterKey{
			Name: "Page",
			In:   "query",
		}
		params.Page = packed[key].(int32)
	}
	{
		key := middleware.ParameterKey{
			Name: "Limit",
			In:   "query",
		}
		params.Limit = packed[key].(int32)
	}
	{
		key := middleware.ParameterKey{
			Name: "DisplayName",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.DisplayName = v.(OptString)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "Creator",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Creator = v.(OptString)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "GameID",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.GameID = v.(OptInt32)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "Sort",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Sort = v.(OptInt32)
		}
	}
	return params
}

func decodeListMapsParams(args [0]string, argsEscaped bool, r *http.Request) (params ListMapsParams, _ error) {
	q := uri.NewQueryDecoder(r.URL.Query())
	// Decode query: Page.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "Page",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt32(val)
				if err != nil {
					return err
				}

				params.Page = c
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           1,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.Page)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return err
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "Page",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: Limit.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "Limit",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt32(val)
				if err != nil {
					return err
				}

				params.Limit = c
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        true,
					Max:           100,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.Limit)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return err
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "Limit",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: DisplayName.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "DisplayName",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotDisplayNameVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					paramsDotDisplayNameVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.DisplayName.SetTo(paramsDotDisplayNameVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.DisplayName.Get(); ok {
					if err := func() error {
						if err := (validate.String{
							MinLength:     0,
							MinLengthSet:  false,
							MaxLength:     128,
							MaxLengthSet:  true,
							Email:         false,
							Hostname:      false,
							Regex:         nil,
							MinNumeric:    0,
							MinNumericSet: false,
							MaxNumeric:    0,
							MaxNumericSet: false,
						}).Validate(string(value)); err != nil {
							return errors.Wrap(err, "string")
						}
						return nil
					}(); err != nil {
						return err
					}
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "DisplayName",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: Creator.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "Creator",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotCreatorVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					paramsDotCreatorVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.Creator.SetTo(paramsDotCreatorVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.Creator.Get(); ok {
					if err := func() error {
						if err := (validate.String{
							MinLength:     0,
							MinLengthSet:  false,
							MaxLength:     128,
							MaxLengthSet:  true,
							Email:         false,
							Hostname:      false,
							Regex:         nil,
							MinNumeric:    0,
							MinNumericSet: false,
							MaxNumeric:    0,
							MaxNumericSet: false,
						}).Validate(string(value)); err != nil {
							return errors.Wrap(err, "string")
						}
						return nil
					}(); err != nil {
						return err
					}
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "Creator",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: GameID.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "GameID",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotGameIDVal int32
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToInt32(val)
					if err != nil {
						return err
					}

					paramsDotGameIDVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.GameID.SetTo(paramsDotGameIDVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.GameID.Get(); ok {
					if err := func() error {
						if err := (validate.Int{
							MinSet:        true,
							Min:           1,
							MaxSet:        true,
							Max:           5,
							MinExclusive:  false,
							MaxExclusive:  false,
							MultipleOfSet: false,
							MultipleOf:    0,
							Pattern:       nil,
						}).Validate(int64(value)); err != nil {
							return errors.Wrap(err, "int")
						}
						return nil
					}(); err != nil {
						return err
					}
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "GameID",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: Sort.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "Sort",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotSortVal int32
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToInt32(val)
					if err != nil {
						return err
					}

					paramsDotSortVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.Sort.SetTo(paramsDotSortVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.Sort.Get(); ok {
					if err := func() error {
						if err := (validate.Int{
							MinSet:        true,
							Min:           0,
							MaxSet:        true,
							Max:           4,
							MinExclusive:  false,
							MaxExclusive:  false,
							MultipleOfSet: false,
							MultipleOf:    0,
							Pattern:       nil,
						}).Validate(int64(value)); err != nil {
							return errors.Wrap(err, "int")
						}
						return nil
					}(); err != nil {
						return err
					}
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "Sort",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// ListScriptPolicyParams is parameters of listScriptPolicy operation.
type ListScriptPolicyParams struct {
	Page           int32
	Limit          int32
	FromScriptHash OptString `json:",omitempty,omitzero"`
	ToScriptID     OptInt64  `json:",omitempty,omitzero"`
	Policy         OptInt32  `json:",omitempty,omitzero"`
}

func unpackListScriptPolicyParams(packed middleware.Parameters) (params ListScriptPolicyParams) {
	{
		key := middleware.ParameterKey{
			Name: "Page",
			In:   "query",
		}
		params.Page = packed[key].(int32)
	}
	{
		key := middleware.ParameterKey{
			Name: "Limit",
			In:   "query",
		}
		params.Limit = packed[key].(int32)
	}
	{
		key := middleware.ParameterKey{
			Name: "FromScriptHash",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.FromScriptHash = v.(OptString)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "ToScriptID",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.ToScriptID = v.(OptInt64)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "Policy",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Policy = v.(OptInt32)
		}
	}
	return params
}

func decodeListScriptPolicyParams(args [0]string, argsEscaped bool, r *http.Request) (params ListScriptPolicyParams, _ error) {
	q := uri.NewQueryDecoder(r.URL.Query())
	// Decode query: Page.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "Page",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt32(val)
				if err != nil {
					return err
				}

				params.Page = c
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           1,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.Page)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return err
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "Page",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: Limit.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "Limit",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt32(val)
				if err != nil {
					return err
				}

				params.Limit = c
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        true,
					Max:           100,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.Limit)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return err
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "Limit",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: FromScriptHash.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "FromScriptHash",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotFromScriptHashVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					paramsDotFromScriptHashVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.FromScriptHash.SetTo(paramsDotFromScriptHashVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.FromScriptHash.Get(); ok {
					if err := func() error {
						if err := (validate.String{
							MinLength:     16,
							MinLengthSet:  true,
							MaxLength:     16,
							MaxLengthSet:  true,
							Email:         false,
							Hostname:      false,
							Regex:         nil,
							MinNumeric:    0,
							MinNumericSet: false,
							MaxNumeric:    0,
							MaxNumericSet: false,
						}).Validate(string(value)); err != nil {
							return errors.Wrap(err, "string")
						}
						return nil
					}(); err != nil {
						return err
					}
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "FromScriptHash",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: ToScriptID.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "ToScriptID",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotToScriptIDVal int64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToInt64(val)
					if err != nil {
						return err
					}

					paramsDotToScriptIDVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.ToScriptID.SetTo(paramsDotToScriptIDVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.ToScriptID.Get(); ok {
					if err := func() error {
						if err := (validate.Int{
							MinSet:        true,
							Min:           0,
							MaxSet:        false,
							Max:           0,
							MinExclusive:  false,
							MaxExclusive:  false,
							MultipleOfSet: false,
							MultipleOf:    0,
							Pattern:       nil,
						}).Validate(int64(value)); err != nil {
							return errors.Wrap(err, "int")
						}
						return nil
					}(); err != nil {
						return err
					}
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "ToScriptID",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: Policy.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "Policy",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotPolicyVal int32
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToInt32(val)
					if err != nil {
						return err
					}

					paramsDotPolicyVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.Policy.SetTo(paramsDotPolicyVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.Policy.Get(); ok {
					if err := func() error {
						if err := (validate.Int{
							MinSet:        true,
							Min:           0,
							MaxSet:        false,
							Max:           0,
							MinExclusive:  false,
							MaxExclusive:  false,
							MultipleOfSet: false,
							MultipleOf:    0,
							Pattern:       nil,
						}).Validate(int64(value)); err != nil {
							return errors.Wrap(err, "int")
						}
						return nil
					}(); err != nil {
						return err
					}
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "Policy",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// ListScriptsParams is parameters of listScripts operation.
type ListScriptsParams struct {
	Page         int32
	Limit        int32
	Hash         OptString `json:",omitempty,omitzero"`
	Name         OptString `json:",omitempty,omitzero"`
	Source       OptString `json:",omitempty,omitzero"`
	ResourceType OptInt32  `json:",omitempty,omitzero"`
	ResourceID   OptInt64  `json:",omitempty,omitzero"`
}

func unpackListScriptsParams(packed middleware.Parameters) (params ListScriptsParams) {
	{
		key := middleware.ParameterKey{
			Name: "Page",
			In:   "query",
		}
		params.Page = packed[key].(int32)
	}
	{
		key := middleware.ParameterKey{
			Name: "Limit",
			In:   "query",
		}
		params.Limit = packed[key].(int32)
	}
	{
		key := middleware.ParameterKey{
			Name: "Hash",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Hash = v.(OptString)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "Name",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Name = v.(OptString)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "Source",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Source = v.(OptString)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "ResourceType",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.ResourceType = v.(OptInt32)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "ResourceID",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.ResourceID = v.(OptInt64)
		}
	}
	return params
}

func decodeListScriptsParams(args [0]string, argsEscaped bool, r *http.Request) (params ListScriptsParams, _ error) {
	q := uri.NewQueryDecoder(r.URL.Query())
	// Decode query: Page.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "Page",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt32(val)
				if err != nil {
					return err
				}

				params.Page = c
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           1,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.Page)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return err
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "Page",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: Limit.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "Limit",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt32(val)
				if err != nil {
					return err
				}

				params.Limit = c
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        true,
					Max:           100,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.Limit)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return err
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "Limit",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: Hash.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "Hash",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotHashVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					paramsDotHashVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.Hash.SetTo(paramsDotHashVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.Hash.Get(); ok {
					if err := func() error {
						if err := (validate.String{
							MinLength:     16,
							MinLengthSet:  true,
							MaxLength:     16,
							MaxLengthSet:  true,
							Email:         false,
							Hostname:      false,
							Regex:         nil,
							MinNumeric:    0,
							MinNumericSet: false,
							MaxNumeric:    0,
							MaxNumericSet: false,
						}).Validate(string(value)); err != nil {
							return errors.Wrap(err, "string")
						}
						return nil
					}(); err != nil {
						return err
					}
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "Hash",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: Name.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "Name",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotNameVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					paramsDotNameVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.Name.SetTo(paramsDotNameVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.Name.Get(); ok {
					if err := func() error {
						if err := (validate.String{
							MinLength:     0,
							MinLengthSet:  false,
							MaxLength:     128,
							MaxLengthSet:  true,
							Email:         false,
							Hostname:      false,
							Regex:         nil,
							MinNumeric:    0,
							MinNumericSet: false,
							MaxNumeric:    0,
							MaxNumericSet: false,
						}).Validate(string(value)); err != nil {
							return errors.Wrap(err, "string")
						}
						return nil
					}(); err != nil {
						return err
					}
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "Name",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: Source.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "Source",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotSourceVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					paramsDotSourceVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.Source.SetTo(paramsDotSourceVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.Source.Get(); ok {
					if err := func() error {
						if err := (validate.String{
							MinLength:     0,
							MinLengthSet:  false,
							MaxLength:     1048576,
							MaxLengthSet:  true,
							Email:         false,
							Hostname:      false,
							Regex:         nil,
							MinNumeric:    0,
							MinNumericSet: false,
							MaxNumeric:    0,
							MaxNumericSet: false,
						}).Validate(string(value)); err != nil {
							return errors.Wrap(err, "string")
						}
						return nil
					}(); err != nil {
						return err
					}
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "Source",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: ResourceType.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "ResourceType",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotResourceTypeVal int32
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToInt32(val)
					if err != nil {
						return err
					}

					paramsDotResourceTypeVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.ResourceType.SetTo(paramsDotResourceTypeVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.ResourceType.Get(); ok {
					if err := func() error {
						if err := (validate.Int{
							MinSet:        true,
							Min:           0,
							MaxSet:        false,
							Max:           0,
							MinExclusive:  false,
							MaxExclusive:  false,
							MultipleOfSet: false,
							MultipleOf:    0,
							Pattern:       nil,
						}).Validate(int64(value)); err != nil {
							return errors.Wrap(err, "int")
						}
						return nil
					}(); err != nil {
						return err
					}
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "ResourceType",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: ResourceID.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "ResourceID",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotResourceIDVal int64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToInt64(val)
					if err != nil {
						return err
					}

					paramsDotResourceIDVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.ResourceID.SetTo(paramsDotResourceIDVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.ResourceID.Get(); ok {
					if err := func() error {
						if err := (validate.Int{
							MinSet:        true,
							Min:           0,
							MaxSet:        false,
							Max:           0,
							MinExclusive:  false,
							MaxExclusive:  false,
							MultipleOfSet: false,
							MultipleOf:    0,
							Pattern:       nil,
						}).Validate(int64(value)); err != nil {
							return errors.Wrap(err, "int")
						}
						return nil
					}(); err != nil {
						return err
					}
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "ResourceID",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// ListSubmissionAuditEventsParams is parameters of listSubmissionAuditEvents operation.
type ListSubmissionAuditEventsParams struct {
	// The unique identifier for a submission.
	SubmissionID int64
	Page         int32
	Limit        int32
}

func unpackListSubmissionAuditEventsParams(packed middleware.Parameters) (params ListSubmissionAuditEventsParams) {
	{
		key := middleware.ParameterKey{
			Name: "SubmissionID",
			In:   "path",
		}
		params.SubmissionID = packed[key].(int64)
	}
	{
		key := middleware.ParameterKey{
			Name: "Page",
			In:   "query",
		}
		params.Page = packed[key].(int32)
	}
	{
		key := middleware.ParameterKey{
			Name: "Limit",
			In:   "query",
		}
		params.Limit = packed[key].(int32)
	}
	return params
}

func decodeListSubmissionAuditEventsParams(args [1]string, argsEscaped bool, r *http.Request) (params ListSubmissionAuditEventsParams, _ error) {
	q := uri.NewQueryDecoder(r.URL.Query())
	// Decode path: SubmissionID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "SubmissionID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.SubmissionID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.SubmissionID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "SubmissionID",
			In:   "path",
			Err:  err,
		}
	}
	// Decode query: Page.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "Page",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt32(val)
				if err != nil {
					return err
				}

				params.Page = c
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           1,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.Page)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return err
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "Page",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: Limit.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "Limit",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt32(val)
				if err != nil {
					return err
				}

				params.Limit = c
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        true,
					Max:           100,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.Limit)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return err
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "Limit",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// ListSubmissionsParams is parameters of listSubmissions operation.
type ListSubmissionsParams struct {
	Page        int32
	Limit       int32
	DisplayName OptString `json:",omitempty,omitzero"`
	Creator     OptString `json:",omitempty,omitzero"`
	// Game ID: * `1` - Bhop * `2` - Surf * `5` - FlyTrials.
	GameID OptInt32 `json:",omitempty,omitzero"`
	// Sort order: * `0` - Disabled * `1` - DisplayNameAscending * `2` - DisplayNameDescending * `3` -
	// DateAscending * `4` - DateDescending.
	Sort            OptInt32 `json:",omitempty,omitzero"`
	Submitter       OptInt64 `json:",omitempty,omitzero"`
	AssetID         OptInt64 `json:",omitempty,omitzero"`
	AssetVersion    OptInt64 `json:",omitempty,omitzero"`
	UploadedAssetID OptInt64 `json:",omitempty,omitzero"`
	// // Phase: Creation * `0` - UnderConstruction * `1` - ChangesRequested
	// // Phase: Review * `2` - Submitting * `3` - Submitted
	// // Phase: Testing * `4` - AcceptedUnvalidated // pending script review, can re-trigger validation
	// * `5` - Validating * `6` - Validated * `7` - Uploading * `8` - Uploaded // uploaded to the group,
	// but pending release
	// // Phase: Final SubmissionStatus * `9` - Rejected * `10` - Released.
	StatusID OptInt32 `json:",omitempty,omitzero"`
}

func unpackListSubmissionsParams(packed middleware.Parameters) (params ListSubmissionsParams) {
	{
		key := middleware.ParameterKey{
			Name: "Page",
			In:   "query",
		}
		params.Page = packed[key].(int32)
	}
	{
		key := middleware.ParameterKey{
			Name: "Limit",
			In:   "query",
		}
		params.Limit = packed[key].(int32)
	}
	{
		key := middleware.ParameterKey{
			Name: "DisplayName",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.DisplayName = v.(OptString)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "Creator",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Creator = v.(OptString)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "GameID",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.GameID = v.(OptInt32)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "Sort",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Sort = v.(OptInt32)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "Submitter",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Submitter = v.(OptInt64)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "AssetID",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.AssetID = v.(OptInt64)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "AssetVersion",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.AssetVersion = v.(OptInt64)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "UploadedAssetID",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.UploadedAssetID = v.(OptInt64)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "StatusID",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.StatusID = v.(OptInt32)
		}
	}
	return params
}

func decodeListSubmissionsParams(args [0]string, argsEscaped bool, r *http.Request) (params ListSubmissionsParams, _ error) {
	q := uri.NewQueryDecoder(r.URL.Query())
	// Decode query: Page.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "Page",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt32(val)
				if err != nil {
					return err
				}

				params.Page = c
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           1,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.Page)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return err
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "Page",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: Limit.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "Limit",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt32(val)
				if err != nil {
					return err
				}

				params.Limit = c
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        true,
					Max:           100,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.Limit)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return err
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "Limit",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: DisplayName.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "DisplayName",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotDisplayNameVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					paramsDotDisplayNameVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.DisplayName.SetTo(paramsDotDisplayNameVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.DisplayName.Get(); ok {
					if err := func() error {
						if err := (validate.String{
							MinLength:     0,
							MinLengthSet:  false,
							MaxLength:     128,
							MaxLengthSet:  true,
							Email:         false,
							Hostname:      false,
							Regex:         nil,
							MinNumeric:    0,
							MinNumericSet: false,
							MaxNumeric:    0,
							MaxNumericSet: false,
						}).Validate(string(value)); err != nil {
							return errors.Wrap(err, "string")
						}
						return nil
					}(); err != nil {
						return err
					}
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "DisplayName",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: Creator.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "Creator",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotCreatorVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToString(val)
					if err != nil {
						return err
					}

					paramsDotCreatorVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.Creator.SetTo(paramsDotCreatorVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.Creator.Get(); ok {
					if err := func() error {
						if err := (validate.String{
							MinLength:     0,
							MinLengthSet:  false,
							MaxLength:     128,
							MaxLengthSet:  true,
							Email:         false,
							Hostname:      false,
							Regex:         nil,
							MinNumeric:    0,
							MinNumericSet: false,
							MaxNumeric:    0,
							MaxNumericSet: false,
						}).Validate(string(value)); err != nil {
							return errors.Wrap(err, "string")
						}
						return nil
					}(); err != nil {
						return err
					}
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "Creator",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: GameID.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "GameID",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotGameIDVal int32
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToInt32(val)
					if err != nil {
						return err
					}

					paramsDotGameIDVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.GameID.SetTo(paramsDotGameIDVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.GameID.Get(); ok {
					if err := func() error {
						if err := (validate.Int{
							MinSet:        true,
							Min:           1,
							MaxSet:        true,
							Max:           5,
							MinExclusive:  false,
							MaxExclusive:  false,
							MultipleOfSet: false,
							MultipleOf:    0,
							Pattern:       nil,
						}).Validate(int64(value)); err != nil {
							return errors.Wrap(err, "int")
						}
						return nil
					}(); err != nil {
						return err
					}
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "GameID",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: Sort.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "Sort",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotSortVal int32
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToInt32(val)
					if err != nil {
						return err
					}

					paramsDotSortVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.Sort.SetTo(paramsDotSortVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.Sort.Get(); ok {
					if err := func() error {
						if err := (validate.Int{
							MinSet:        true,
							Min:           0,
							MaxSet:        true,
							Max:           4,
							MinExclusive:  false,
							MaxExclusive:  false,
							MultipleOfSet: false,
							MultipleOf:    0,
							Pattern:       nil,
						}).Validate(int64(value)); err != nil {
							return errors.Wrap(err, "int")
						}
						return nil
					}(); err != nil {
						return err
					}
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "Sort",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: Submitter.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "Submitter",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotSubmitterVal int64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToInt64(val)
					if err != nil {
						return err
					}

					paramsDotSubmitterVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.Submitter.SetTo(paramsDotSubmitterVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.Submitter.Get(); ok {
					if err := func() error {
						if err := (validate.Int{
							MinSet:        true,
							Min:           0,
							MaxSet:        false,
							Max:           0,
							MinExclusive:  false,
							MaxExclusive:  false,
							MultipleOfSet: false,
							MultipleOf:    0,
							Pattern:       nil,
						}).Validate(int64(value)); err != nil {
							return errors.Wrap(err, "int")
						}
						return nil
					}(); err != nil {
						return err
					}
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "Submitter",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: AssetID.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "AssetID",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotAssetIDVal int64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToInt64(val)
					if err != nil {
						return err
					}

					paramsDotAssetIDVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.AssetID.SetTo(paramsDotAssetIDVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.AssetID.Get(); ok {
					if err := func() error {
						if err := (validate.Int{
							MinSet:        true,
							Min:           0,
							MaxSet:        false,
							Max:           0,
							MinExclusive:  false,
							MaxExclusive:  false,
							MultipleOfSet: false,
							MultipleOf:    0,
							Pattern:       nil,
						}).Validate(int64(value)); err != nil {
							return errors.Wrap(err, "int")
						}
						return nil
					}(); err != nil {
						return err
					}
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "AssetID",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: AssetVersion.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "AssetVersion",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotAssetVersionVal int64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToInt64(val)
					if err != nil {
						return err
					}

					paramsDotAssetVersionVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.AssetVersion.SetTo(paramsDotAssetVersionVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.AssetVersion.Get(); ok {
					if err := func() error {
						if err := (validate.Int{
							MinSet:        true,
							Min:           0,
							MaxSet:        false,
							Max:           0,
							MinExclusive:  false,
							MaxExclusive:  false,
							MultipleOfSet: false,
							MultipleOf:    0,
							Pattern:       nil,
						}).Validate(int64(value)); err != nil {
							return errors.Wrap(err, "int")
						}
						return nil
					}(); err != nil {
						return err
					}
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "AssetVersion",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: UploadedAssetID.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "UploadedAssetID",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotUploadedAssetIDVal int64
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToInt64(val)
					if err != nil {
						return err
					}

					paramsDotUploadedAssetIDVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.UploadedAssetID.SetTo(paramsDotUploadedAssetIDVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.UploadedAssetID.Get(); ok {
					if err := func() error {
						if err := (validate.Int{
							MinSet:        true,
							Min:           0,
							MaxSet:        false,
							Max:           0,
							MinExclusive:  false,
							MaxExclusive:  false,
							MultipleOfSet: false,
							MultipleOf:    0,
							Pattern:       nil,
						}).Validate(int64(value)); err != nil {
							return errors.Wrap(err, "int")
						}
						return nil
					}(); err != nil {
						return err
					}
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "UploadedAssetID",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: StatusID.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "StatusID",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotStatusIDVal int32
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

					c, err := conv.ToInt32(val)
					if err != nil {
						return err
					}

					paramsDotStatusIDVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.StatusID.SetTo(paramsDotStatusIDVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.StatusID.Get(); ok {
					if err := func() error {
						if err := (validate.Int{
							MinSet:        true,
							Min:           0,
							MaxSet:        true,
							Max:           10,
							MinExclusive:  false,
							MaxExclusive:  false,
							MultipleOfSet: false,
							MultipleOf:    0,
							Pattern:       nil,
						}).Validate(int64(value)); err != nil {
							return errors.Wrap(err, "int")
						}
						return nil
					}(); err != nil {
						return err
					}
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "StatusID",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// SetMapfixCompletedParams is parameters of setMapfixCompleted operation.
type SetMapfixCompletedParams struct {
	// The unique identifier for a mapfix.
	MapfixID int64
}

func unpackSetMapfixCompletedParams(packed middleware.Parameters) (params SetMapfixCompletedParams) {
	{
		key := middleware.ParameterKey{
			Name: "MapfixID",
			In:   "path",
		}
		params.MapfixID = packed[key].(int64)
	}
	return params
}

func decodeSetMapfixCompletedParams(args [1]string, argsEscaped bool, r *http.Request) (params SetMapfixCompletedParams, _ error) {
	// Decode path: MapfixID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "MapfixID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.MapfixID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.MapfixID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "MapfixID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// SetSubmissionCompletedParams is parameters of setSubmissionCompleted operation.
type SetSubmissionCompletedParams struct {
	// The unique identifier for a submission.
	SubmissionID int64
}

func unpackSetSubmissionCompletedParams(packed middleware.Parameters) (params SetSubmissionCompletedParams) {
	{
		key := middleware.ParameterKey{
			Name: "SubmissionID",
			In:   "path",
		}
		params.SubmissionID = packed[key].(int64)
	}
	return params
}

func decodeSetSubmissionCompletedParams(args [1]string, argsEscaped bool, r *http.Request) (params SetSubmissionCompletedParams, _ error) {
	// Decode path: SubmissionID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "SubmissionID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.SubmissionID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.SubmissionID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "SubmissionID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// UpdateMapfixDescriptionParams is parameters of updateMapfixDescription operation.
type UpdateMapfixDescriptionParams struct {
	// The unique identifier for a mapfix.
	MapfixID int64
}

func unpackUpdateMapfixDescriptionParams(packed middleware.Parameters) (params UpdateMapfixDescriptionParams) {
	{
		key := middleware.ParameterKey{
			Name: "MapfixID",
			In:   "path",
		}
		params.MapfixID = packed[key].(int64)
	}
	return params
}

func decodeUpdateMapfixDescriptionParams(args [1]string, argsEscaped bool, r *http.Request) (params UpdateMapfixDescriptionParams, _ error) {
	// Decode path: MapfixID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "MapfixID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.MapfixID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.MapfixID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "MapfixID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// UpdateMapfixModelParams is parameters of updateMapfixModel operation.
type UpdateMapfixModelParams struct {
	// The unique identifier for a mapfix.
	MapfixID     int64
	ModelID      int64
	ModelVersion int64
}

func unpackUpdateMapfixModelParams(packed middleware.Parameters) (params UpdateMapfixModelParams) {
	{
		key := middleware.ParameterKey{
			Name: "MapfixID",
			In:   "path",
		}
		params.MapfixID = packed[key].(int64)
	}
	{
		key := middleware.ParameterKey{
			Name: "ModelID",
			In:   "query",
		}
		params.ModelID = packed[key].(int64)
	}
	{
		key := middleware.ParameterKey{
			Name: "ModelVersion",
			In:   "query",
		}
		params.ModelVersion = packed[key].(int64)
	}
	return params
}

func decodeUpdateMapfixModelParams(args [1]string, argsEscaped bool, r *http.Request) (params UpdateMapfixModelParams, _ error) {
	q := uri.NewQueryDecoder(r.URL.Query())
	// Decode path: MapfixID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "MapfixID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.MapfixID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.MapfixID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "MapfixID",
			In:   "path",
			Err:  err,
		}
	}
	// Decode query: ModelID.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "ModelID",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.ModelID = c
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.ModelID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return err
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "ModelID",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: ModelVersion.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "ModelVersion",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.ModelVersion = c
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.ModelVersion)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return err
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "ModelVersion",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// UpdateScriptParams is parameters of updateScript operation.
type UpdateScriptParams struct {
	// The unique identifier for a script.
	ScriptID int64
}

func unpackUpdateScriptParams(packed middleware.Parameters) (params UpdateScriptParams) {
	{
		key := middleware.ParameterKey{
			Name: "ScriptID",
			In:   "path",
		}
		params.ScriptID = packed[key].(int64)
	}
	return params
}

func decodeUpdateScriptParams(args [1]string, argsEscaped bool, r *http.Request) (params UpdateScriptParams, _ error) {
	// Decode path: ScriptID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "ScriptID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.ScriptID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.ScriptID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "ScriptID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// UpdateScriptPolicyParams is parameters of updateScriptPolicy operation.
type UpdateScriptPolicyParams struct {
	// The unique identifier for a script policy.
	ScriptPolicyID int64
}

func unpackUpdateScriptPolicyParams(packed middleware.Parameters) (params UpdateScriptPolicyParams) {
	{
		key := middleware.ParameterKey{
			Name: "ScriptPolicyID",
			In:   "path",
		}
		params.ScriptPolicyID = packed[key].(int64)
	}
	return params
}

func decodeUpdateScriptPolicyParams(args [1]string, argsEscaped bool, r *http.Request) (params UpdateScriptPolicyParams, _ error) {
	// Decode path: ScriptPolicyID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "ScriptPolicyID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.ScriptPolicyID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.ScriptPolicyID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "ScriptPolicyID",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// UpdateSubmissionModelParams is parameters of updateSubmissionModel operation.
type UpdateSubmissionModelParams struct {
	// The unique identifier for a submission.
	SubmissionID int64
	ModelID      int64
	ModelVersion int64
}

func unpackUpdateSubmissionModelParams(packed middleware.Parameters) (params UpdateSubmissionModelParams) {
	{
		key := middleware.ParameterKey{
			Name: "SubmissionID",
			In:   "path",
		}
		params.SubmissionID = packed[key].(int64)
	}
	{
		key := middleware.ParameterKey{
			Name: "ModelID",
			In:   "query",
		}
		params.ModelID = packed[key].(int64)
	}
	{
		key := middleware.ParameterKey{
			Name: "ModelVersion",
			In:   "query",
		}
		params.ModelVersion = packed[key].(int64)
	}
	return params
}

func decodeUpdateSubmissionModelParams(args [1]string, argsEscaped bool, r *http.Request) (params UpdateSubmissionModelParams, _ error) {
	q := uri.NewQueryDecoder(r.URL.Query())
	// Decode path: SubmissionID.
	if err := func() error {
		param := args[0]
		if argsEscaped {
			unescaped, err := url.PathUnescape(args[0])
			if err != nil {
				return errors.Wrap(err, "unescape path")
			}
			param = unescaped
		}
		if len(param) > 0 {
			d := uri.NewPathDecoder(uri.PathDecoderConfig{
				Param:   "SubmissionID",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

			if err := func() error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.SubmissionID = c
				return nil
			}(); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.SubmissionID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "SubmissionID",
			In:   "path",
			Err:  err,
		}
	}
	// Decode query: ModelID.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "ModelID",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.ModelID = c
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.ModelID)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return err
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "ModelID",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: ModelVersion.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "ModelVersion",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				val, err := d.DecodeValue()
				if err != nil {
					return err
				}

				c, err := conv.ToInt64(val)
				if err != nil {
					return err
				}

				params.ModelVersion = c
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           0,
					MaxSet:        false,
					Max:           0,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(params.ModelVersion)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return err
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "ModelVersion",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}