oas_parameters_gen.go

// Code generated by ogen, DO NOT EDIT.

package api

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

	"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"
)

// APIAuctionAuctionUuidGetParams is parameters of GET /api/auction/{auctionUuid} operation.
type APIAuctionAuctionUuidGetParams struct {
	// The uuid of the auction you want the details for.
	AuctionUuid string
}

func unpackAPIAuctionAuctionUuidGetParams(packed middleware.Parameters) (params APIAuctionAuctionUuidGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "auctionUuid",
			In:   "path",
		}
		params.AuctionUuid = packed[key].(string)
	}
	return params
}

func decodeAPIAuctionAuctionUuidGetParams(args [1]string, argsEscaped bool, r *http.Request) (params APIAuctionAuctionUuidGetParams, _ error) {
	// Decode path: auctionUuid.
	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:   "auctionUuid",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.AuctionUuid = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "auctionUuid",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// APIAuctionAuctionUuidUIDGetParams is parameters of GET /api/auction/{auctionUuid}/uid operation.
type APIAuctionAuctionUuidUIDGetParams struct {
	// The uuid of the auction you want the details for.
	AuctionUuid string
}

func unpackAPIAuctionAuctionUuidUIDGetParams(packed middleware.Parameters) (params APIAuctionAuctionUuidUIDGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "auctionUuid",
			In:   "path",
		}
		params.AuctionUuid = packed[key].(string)
	}
	return params
}

func decodeAPIAuctionAuctionUuidUIDGetParams(args [1]string, argsEscaped bool, r *http.Request) (params APIAuctionAuctionUuidUIDGetParams, _ error) {
	// Decode path: auctionUuid.
	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:   "auctionUuid",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.AuctionUuid = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "auctionUuid",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// APIAuctionsBatchGetParams is parameters of GET /api/auctions/batch operation.
type APIAuctionsBatchGetParams struct {
	// Page of auctions to get.
	Page OptString
	// Secret token to access data.
	Token OptString
}

func unpackAPIAuctionsBatchGetParams(packed middleware.Parameters) (params APIAuctionsBatchGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "page",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Page = v.(OptString)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "token",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Token = v.(OptString)
		}
	}
	return params
}

func decodeAPIAuctionsBatchGetParams(args [0]string, argsEscaped bool, r *http.Request) (params APIAuctionsBatchGetParams, _ error) {
	q := uri.NewQueryDecoder(r.URL.Query())
	// Set default value for query: page.
	{
		val := string("last")
		params.Page.SetTo(val)
	}
	// 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 {
				var paramsDotPageVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

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

					paramsDotPageVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.Page.SetTo(paramsDotPageVal)
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "page",
			In:   "query",
			Err:  err,
		}
	}
	// Set default value for query: token.
	{
		val := string("")
		params.Token.SetTo(val)
	}
	// Decode query: token.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "token",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

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

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

					paramsDotTokenVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.Token.SetTo(paramsDotTokenVal)
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "token",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// APIAuctionsTagItemTagActiveBinGetParams is parameters of GET /api/auctions/tag/{itemTag}/active/bin operation.
type APIAuctionsTagItemTagActiveBinGetParams struct {
	// The itemTag to get bins for.
	ItemTag string
	// Filters for the auctions.
	Query *APIAuctionsTagItemTagActiveBinGetQuery
}

func unpackAPIAuctionsTagItemTagActiveBinGetParams(packed middleware.Parameters) (params APIAuctionsTagItemTagActiveBinGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "itemTag",
			In:   "path",
		}
		params.ItemTag = packed[key].(string)
	}
	{
		key := middleware.ParameterKey{
			Name: "query",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Query = v.(*APIAuctionsTagItemTagActiveBinGetQuery)
		}
	}
	return params
}

func decodeAPIAuctionsTagItemTagActiveBinGetParams(args [1]string, argsEscaped bool, r *http.Request) (params APIAuctionsTagItemTagActiveBinGetParams, _ error) {
	q := uri.NewQueryDecoder(r.URL.Query())
	// Decode path: itemTag.
	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:   "itemTag",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.ItemTag = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "itemTag",
			In:   "path",
			Err:  err,
		}
	}
	// Decode query: query.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "query",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotQueryVal APIAuctionsTagItemTagActiveBinGetQuery
				if err := func() error {
					return paramsDotQueryVal.DecodeURI(d)
				}(); err != nil {
					return err
				}
				params.Query = &paramsDotQueryVal
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "query",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// APIAuctionsTagItemTagActiveOverviewGetParams is parameters of GET /api/auctions/tag/{itemTag}/active/overview operation.
type APIAuctionsTagItemTagActiveOverviewGetParams struct {
	// The itemTag to get auctions for.
	ItemTag string
	Query   *APIAuctionsTagItemTagActiveOverviewGetQuery
}

func unpackAPIAuctionsTagItemTagActiveOverviewGetParams(packed middleware.Parameters) (params APIAuctionsTagItemTagActiveOverviewGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "itemTag",
			In:   "path",
		}
		params.ItemTag = packed[key].(string)
	}
	{
		key := middleware.ParameterKey{
			Name: "query",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Query = v.(*APIAuctionsTagItemTagActiveOverviewGetQuery)
		}
	}
	return params
}

func decodeAPIAuctionsTagItemTagActiveOverviewGetParams(args [1]string, argsEscaped bool, r *http.Request) (params APIAuctionsTagItemTagActiveOverviewGetParams, _ error) {
	q := uri.NewQueryDecoder(r.URL.Query())
	// Decode path: itemTag.
	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:   "itemTag",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.ItemTag = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "itemTag",
			In:   "path",
			Err:  err,
		}
	}
	// Decode query: query.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "query",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotQueryVal APIAuctionsTagItemTagActiveOverviewGetQuery
				if err := func() error {
					return paramsDotQueryVal.DecodeURI(d)
				}(); err != nil {
					return err
				}
				params.Query = &paramsDotQueryVal
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "query",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// APIAuctionsTagItemTagRecentOverviewGetParams is parameters of GET /api/auctions/tag/{itemTag}/recent/overview operation.
type APIAuctionsTagItemTagRecentOverviewGetParams struct {
	// The itemTag to get auctions for.
	ItemTag string
	Query   *APIAuctionsTagItemTagRecentOverviewGetQuery
}

func unpackAPIAuctionsTagItemTagRecentOverviewGetParams(packed middleware.Parameters) (params APIAuctionsTagItemTagRecentOverviewGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "itemTag",
			In:   "path",
		}
		params.ItemTag = packed[key].(string)
	}
	{
		key := middleware.ParameterKey{
			Name: "query",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Query = v.(*APIAuctionsTagItemTagRecentOverviewGetQuery)
		}
	}
	return params
}

func decodeAPIAuctionsTagItemTagRecentOverviewGetParams(args [1]string, argsEscaped bool, r *http.Request) (params APIAuctionsTagItemTagRecentOverviewGetParams, _ error) {
	q := uri.NewQueryDecoder(r.URL.Query())
	// Decode path: itemTag.
	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:   "itemTag",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.ItemTag = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "itemTag",
			In:   "path",
			Err:  err,
		}
	}
	// Decode query: query.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "query",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotQueryVal APIAuctionsTagItemTagRecentOverviewGetQuery
				if err := func() error {
					return paramsDotQueryVal.DecodeURI(d)
				}(); err != nil {
					return err
				}
				params.Query = &paramsDotQueryVal
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "query",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// APIAuctionsTagItemTagSoldGetParams is parameters of GET /api/auctions/tag/{itemTag}/sold operation.
type APIAuctionsTagItemTagSoldGetParams struct {
	// The itemTag to get auctions for.
	ItemTag string
	// Page of auctions to get.
	Page OptInt32
	// How many auctions to get per page 1-1000.
	PageSize OptInt32
}

func unpackAPIAuctionsTagItemTagSoldGetParams(packed middleware.Parameters) (params APIAuctionsTagItemTagSoldGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "itemTag",
			In:   "path",
		}
		params.ItemTag = packed[key].(string)
	}
	{
		key := middleware.ParameterKey{
			Name: "page",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Page = v.(OptInt32)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "pageSize",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.PageSize = v.(OptInt32)
		}
	}
	return params
}

func decodeAPIAuctionsTagItemTagSoldGetParams(args [1]string, argsEscaped bool, r *http.Request) (params APIAuctionsTagItemTagSoldGetParams, _ error) {
	q := uri.NewQueryDecoder(r.URL.Query())
	// Decode path: itemTag.
	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:   "itemTag",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.ItemTag = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "itemTag",
			In:   "path",
			Err:  err,
		}
	}
	// Set default value for query: page.
	{
		val := int32(0)
		params.Page.SetTo(val)
	}
	// 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 {
				var paramsDotPageVal int32
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

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

					paramsDotPageVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.Page.SetTo(paramsDotPageVal)
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "page",
			In:   "query",
			Err:  err,
		}
	}
	// Set default value for query: pageSize.
	{
		val := int32(1000)
		params.PageSize.SetTo(val)
	}
	// Decode query: pageSize.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "pageSize",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

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

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

					paramsDotPageSizeVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.PageSize.SetTo(paramsDotPageSizeVal)
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "pageSize",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// APIAuctionsUIDUIDSoldGetParams is parameters of GET /api/auctions/uid/{uid}/sold operation.
type APIAuctionsUIDUIDSoldGetParams struct {
	// The Item uuid or just uid.
	UID string
}

func unpackAPIAuctionsUIDUIDSoldGetParams(packed middleware.Parameters) (params APIAuctionsUIDUIDSoldGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "uid",
			In:   "path",
		}
		params.UID = packed[key].(string)
	}
	return params
}

func decodeAPIAuctionsUIDUIDSoldGetParams(args [1]string, argsEscaped bool, r *http.Request) (params APIAuctionsUIDUIDSoldGetParams, _ error) {
	// Decode path: uid.
	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:   "uid",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.UID = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "uid",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// APIBazaarItemHistoryItemTagStatusGetParams is parameters of GET /api/bazaar/item/history/{itemTag}/status operation.
type APIBazaarItemHistoryItemTagStatusGetParams struct {
	ItemTag string
}

func unpackAPIBazaarItemHistoryItemTagStatusGetParams(packed middleware.Parameters) (params APIBazaarItemHistoryItemTagStatusGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "itemTag",
			In:   "path",
		}
		params.ItemTag = packed[key].(string)
	}
	return params
}

func decodeAPIBazaarItemHistoryItemTagStatusGetParams(args [1]string, argsEscaped bool, r *http.Request) (params APIBazaarItemHistoryItemTagStatusGetParams, _ error) {
	// Decode path: itemTag.
	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:   "itemTag",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.ItemTag = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "itemTag",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// APIBazaarItemTagHistoryDayGetParams is parameters of GET /api/bazaar/{itemTag}/history/day operation.
type APIBazaarItemTagHistoryDayGetParams struct {
	// What item to get data for.
	ItemTag string
}

func unpackAPIBazaarItemTagHistoryDayGetParams(packed middleware.Parameters) (params APIBazaarItemTagHistoryDayGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "itemTag",
			In:   "path",
		}
		params.ItemTag = packed[key].(string)
	}
	return params
}

func decodeAPIBazaarItemTagHistoryDayGetParams(args [1]string, argsEscaped bool, r *http.Request) (params APIBazaarItemTagHistoryDayGetParams, _ error) {
	// Decode path: itemTag.
	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:   "itemTag",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.ItemTag = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "itemTag",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// APIBazaarItemTagHistoryGetParams is parameters of GET /api/bazaar/{itemTag}/history operation.
type APIBazaarItemTagHistoryGetParams struct {
	// What item to get data for.
	ItemTag string
	Start   OptDateTime
	End     OptDateTime
}

func unpackAPIBazaarItemTagHistoryGetParams(packed middleware.Parameters) (params APIBazaarItemTagHistoryGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "itemTag",
			In:   "path",
		}
		params.ItemTag = packed[key].(string)
	}
	{
		key := middleware.ParameterKey{
			Name: "start",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Start = v.(OptDateTime)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "end",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.End = v.(OptDateTime)
		}
	}
	return params
}

func decodeAPIBazaarItemTagHistoryGetParams(args [1]string, argsEscaped bool, r *http.Request) (params APIBazaarItemTagHistoryGetParams, _ error) {
	q := uri.NewQueryDecoder(r.URL.Query())
	// Decode path: itemTag.
	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:   "itemTag",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.ItemTag = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "itemTag",
			In:   "path",
			Err:  err,
		}
	}
	// Decode query: start.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "start",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

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

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

					paramsDotStartVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.Start.SetTo(paramsDotStartVal)
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "start",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: end.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "end",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

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

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

					paramsDotEndVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.End.SetTo(paramsDotEndVal)
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "end",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// APIBazaarItemTagHistoryHourGetParams is parameters of GET /api/bazaar/{itemTag}/history/hour operation.
type APIBazaarItemTagHistoryHourGetParams struct {
	// What item to get data for.
	ItemTag string
}

func unpackAPIBazaarItemTagHistoryHourGetParams(packed middleware.Parameters) (params APIBazaarItemTagHistoryHourGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "itemTag",
			In:   "path",
		}
		params.ItemTag = packed[key].(string)
	}
	return params
}

func decodeAPIBazaarItemTagHistoryHourGetParams(args [1]string, argsEscaped bool, r *http.Request) (params APIBazaarItemTagHistoryHourGetParams, _ error) {
	// Decode path: itemTag.
	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:   "itemTag",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.ItemTag = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "itemTag",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// APIBazaarItemTagHistoryWeekGetParams is parameters of GET /api/bazaar/{itemTag}/history/week operation.
type APIBazaarItemTagHistoryWeekGetParams struct {
	// What item to get data for.
	ItemTag string
}

func unpackAPIBazaarItemTagHistoryWeekGetParams(packed middleware.Parameters) (params APIBazaarItemTagHistoryWeekGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "itemTag",
			In:   "path",
		}
		params.ItemTag = packed[key].(string)
	}
	return params
}

func decodeAPIBazaarItemTagHistoryWeekGetParams(args [1]string, argsEscaped bool, r *http.Request) (params APIBazaarItemTagHistoryWeekGetParams, _ error) {
	// Decode path: itemTag.
	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:   "itemTag",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.ItemTag = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "itemTag",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// APIBazaarItemTagSnapshotGetParams is parameters of GET /api/bazaar/{itemTag}/snapshot operation.
type APIBazaarItemTagSnapshotGetParams struct {
	// The search term to search for.
	ItemTag string
	// Whattime to retrieve the information at (defaults to now).
	Timestamp OptDateTime
}

func unpackAPIBazaarItemTagSnapshotGetParams(packed middleware.Parameters) (params APIBazaarItemTagSnapshotGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "itemTag",
			In:   "path",
		}
		params.ItemTag = packed[key].(string)
	}
	{
		key := middleware.ParameterKey{
			Name: "timestamp",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Timestamp = v.(OptDateTime)
		}
	}
	return params
}

func decodeAPIBazaarItemTagSnapshotGetParams(args [1]string, argsEscaped bool, r *http.Request) (params APIBazaarItemTagSnapshotGetParams, _ error) {
	q := uri.NewQueryDecoder(r.URL.Query())
	// Decode path: itemTag.
	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:   "itemTag",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.ItemTag = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "itemTag",
			In:   "path",
			Err:  err,
		}
	}
	// Decode query: timestamp.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "timestamp",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

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

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

					paramsDotTimestampVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.Timestamp.SetTo(paramsDotTimestampVal)
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "timestamp",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// APICraftProfitGetParams is parameters of GET /api/craft/profit operation.
type APICraftProfitGetParams struct {
	Player  OptString
	Profile OptString
}

func unpackAPICraftProfitGetParams(packed middleware.Parameters) (params APICraftProfitGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "player",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Player = v.(OptString)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "profile",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Profile = v.(OptString)
		}
	}
	return params
}

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

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

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

					paramsDotPlayerVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.Player.SetTo(paramsDotPlayerVal)
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "player",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: profile.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "profile",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

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

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

					paramsDotProfileVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.Profile.SetTo(paramsDotProfileVal)
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "profile",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// APICraftRecipeItemTagGetParams is parameters of GET /api/craft/recipe/{itemTag} operation.
type APICraftRecipeItemTagGetParams struct {
	ItemTag string
}

func unpackAPICraftRecipeItemTagGetParams(packed middleware.Parameters) (params APICraftRecipeItemTagGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "itemTag",
			In:   "path",
		}
		params.ItemTag = packed[key].(string)
	}
	return params
}

func decodeAPICraftRecipeItemTagGetParams(args [1]string, argsEscaped bool, r *http.Request) (params APICraftRecipeItemTagGetParams, _ error) {
	// Decode path: itemTag.
	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:   "itemTag",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.ItemTag = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "itemTag",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// APIDataPlayerNamePostParams is parameters of POST /api/data/playerName operation.
type APIDataPlayerNamePostParams struct {
	Name OptString
}

func unpackAPIDataPlayerNamePostParams(packed middleware.Parameters) (params APIDataPlayerNamePostParams) {
	{
		key := middleware.ParameterKey{
			Name: "name",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Name = v.(OptString)
		}
	}
	return params
}

func decodeAPIDataPlayerNamePostParams(args [0]string, argsEscaped bool, r *http.Request) (params APIDataPlayerNamePostParams, _ error) {
	q := uri.NewQueryDecoder(r.URL.Query())
	// 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
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "name",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// APIFilterOptionsGetParams is parameters of GET /api/filter/options operation.
type APIFilterOptionsGetParams struct {
	ItemTag OptString
}

func unpackAPIFilterOptionsGetParams(packed middleware.Parameters) (params APIFilterOptionsGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "itemTag",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.ItemTag = v.(OptString)
		}
	}
	return params
}

func decodeAPIFilterOptionsGetParams(args [0]string, argsEscaped bool, r *http.Request) (params APIFilterOptionsGetParams, _ error) {
	q := uri.NewQueryDecoder(r.URL.Query())
	// Set default value for query: itemTag.
	{
		val := string("*")
		params.ItemTag.SetTo(val)
	}
	// Decode query: itemTag.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "itemTag",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

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

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

					paramsDotItemTagVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.ItemTag.SetTo(paramsDotItemTagVal)
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "itemTag",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// APIFlipStatsFinderFinderNameGetParams is parameters of GET /api/flip/stats/finder/{finderName} operation.
type APIFlipStatsFinderFinderNameGetParams struct {
	// Uuid of player to get stats for.
	FinderName string
	// The start time of flips to get (inclusive).
	Start OptDateTime
	// The end time of flips to get (exclusive).
	End OptDateTime
}

func unpackAPIFlipStatsFinderFinderNameGetParams(packed middleware.Parameters) (params APIFlipStatsFinderFinderNameGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "finderName",
			In:   "path",
		}
		params.FinderName = packed[key].(string)
	}
	{
		key := middleware.ParameterKey{
			Name: "start",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Start = v.(OptDateTime)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "end",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.End = v.(OptDateTime)
		}
	}
	return params
}

func decodeAPIFlipStatsFinderFinderNameGetParams(args [1]string, argsEscaped bool, r *http.Request) (params APIFlipStatsFinderFinderNameGetParams, _ error) {
	q := uri.NewQueryDecoder(r.URL.Query())
	// Decode path: finderName.
	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:   "finderName",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.FinderName = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "finderName",
			In:   "path",
			Err:  err,
		}
	}
	// Decode query: start.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "start",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

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

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

					paramsDotStartVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.Start.SetTo(paramsDotStartVal)
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "start",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: end.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "end",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

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

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

					paramsDotEndVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.End.SetTo(paramsDotEndVal)
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "end",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// APIFlipStatsPlayerPlayerUuidGetParams is parameters of GET /api/flip/stats/player/{playerUuid} operation.
type APIFlipStatsPlayerPlayerUuidGetParams struct {
	// Uuid of player to get stats for.
	PlayerUuid string
	Days       OptFloat32
}

func unpackAPIFlipStatsPlayerPlayerUuidGetParams(packed middleware.Parameters) (params APIFlipStatsPlayerPlayerUuidGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "playerUuid",
			In:   "path",
		}
		params.PlayerUuid = packed[key].(string)
	}
	{
		key := middleware.ParameterKey{
			Name: "days",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Days = v.(OptFloat32)
		}
	}
	return params
}

func decodeAPIFlipStatsPlayerPlayerUuidGetParams(args [1]string, argsEscaped bool, r *http.Request) (params APIFlipStatsPlayerPlayerUuidGetParams, _ error) {
	q := uri.NewQueryDecoder(r.URL.Query())
	// Decode path: playerUuid.
	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:   "playerUuid",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.PlayerUuid = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "playerUuid",
			In:   "path",
			Err:  err,
		}
	}
	// Set default value for query: days.
	{
		val := float32(7)
		params.Days.SetTo(val)
	}
	// Decode query: days.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "days",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

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

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

					paramsDotDaysVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.Days.SetTo(paramsDotDaysVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.Days.Get(); ok {
					if err := func() error {
						if err := (validate.Float{}).Validate(float64(value)); err != nil {
							return errors.Wrap(err, "float")
						}
						return nil
					}(); err != nil {
						return err
					}
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "days",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// APIFlipStatsPlayerPlayerUuidHourGetParams is parameters of GET /api/flip/stats/player/{playerUuid}/hour operation.
type APIFlipStatsPlayerPlayerUuidHourGetParams struct {
	// Uuid of player.
	PlayerUuid string
}

func unpackAPIFlipStatsPlayerPlayerUuidHourGetParams(packed middleware.Parameters) (params APIFlipStatsPlayerPlayerUuidHourGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "playerUuid",
			In:   "path",
		}
		params.PlayerUuid = packed[key].(string)
	}
	return params
}

func decodeAPIFlipStatsPlayerPlayerUuidHourGetParams(args [1]string, argsEscaped bool, r *http.Request) (params APIFlipStatsPlayerPlayerUuidHourGetParams, _ error) {
	// Decode path: playerUuid.
	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:   "playerUuid",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.PlayerUuid = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "playerUuid",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// APIFlipTrackFoundAuctionIdPostParams is parameters of POST /api/flip/track/found/{auctionId} operation.
type APIFlipTrackFoundAuctionIdPostParams struct {
	// The id of the found auction.
	AuctionId string
	// Identifier of finder.
	Finder OptString
	// Suggested target price.
	Price OptInt32
	// Unix millisecond timestamp when the flip was found.
	TimeStamp OptInt64
}

func unpackAPIFlipTrackFoundAuctionIdPostParams(packed middleware.Parameters) (params APIFlipTrackFoundAuctionIdPostParams) {
	{
		key := middleware.ParameterKey{
			Name: "auctionId",
			In:   "path",
		}
		params.AuctionId = packed[key].(string)
	}
	{
		key := middleware.ParameterKey{
			Name: "finder",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Finder = v.(OptString)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "price",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Price = v.(OptInt32)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "timeStamp",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.TimeStamp = v.(OptInt64)
		}
	}
	return params
}

func decodeAPIFlipTrackFoundAuctionIdPostParams(args [1]string, argsEscaped bool, r *http.Request) (params APIFlipTrackFoundAuctionIdPostParams, _ error) {
	q := uri.NewQueryDecoder(r.URL.Query())
	// Decode path: auctionId.
	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:   "auctionId",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.AuctionId = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "auctionId",
			In:   "path",
			Err:  err,
		}
	}
	// Decode query: finder.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "finder",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

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

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

					paramsDotFinderVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.Finder.SetTo(paramsDotFinderVal)
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "finder",
			In:   "query",
			Err:  err,
		}
	}
	// Set default value for query: price.
	{
		val := int32(-1)
		params.Price.SetTo(val)
	}
	// Decode query: price.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "price",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

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

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

					paramsDotPriceVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.Price.SetTo(paramsDotPriceVal)
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "price",
			In:   "query",
			Err:  err,
		}
	}
	// Set default value for query: timeStamp.
	{
		val := int64(0)
		params.TimeStamp.SetTo(val)
	}
	// Decode query: timeStamp.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "timeStamp",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

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

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

					paramsDotTimeStampVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.TimeStamp.SetTo(paramsDotTimeStampVal)
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "timeStamp",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// APIFlipTrackPurchaseAuctionIdPostParams is parameters of POST /api/flip/track/purchase/{auctionId} operation.
type APIFlipTrackPurchaseAuctionIdPostParams struct {
	// Id of found and purchased auction.
	AuctionId string
	// Identifier of finder.
	Finder OptString
	// The uuid of the player.
	PlayerId OptString
	// Sugested target price.
	Price OptInt32
	// Unix millisecond timestamp when the flip was found.
	TimeStamp OptInt64
}

func unpackAPIFlipTrackPurchaseAuctionIdPostParams(packed middleware.Parameters) (params APIFlipTrackPurchaseAuctionIdPostParams) {
	{
		key := middleware.ParameterKey{
			Name: "auctionId",
			In:   "path",
		}
		params.AuctionId = packed[key].(string)
	}
	{
		key := middleware.ParameterKey{
			Name: "finder",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Finder = v.(OptString)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "playerId",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.PlayerId = v.(OptString)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "price",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Price = v.(OptInt32)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "timeStamp",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.TimeStamp = v.(OptInt64)
		}
	}
	return params
}

func decodeAPIFlipTrackPurchaseAuctionIdPostParams(args [1]string, argsEscaped bool, r *http.Request) (params APIFlipTrackPurchaseAuctionIdPostParams, _ error) {
	q := uri.NewQueryDecoder(r.URL.Query())
	// Decode path: auctionId.
	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:   "auctionId",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.AuctionId = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "auctionId",
			In:   "path",
			Err:  err,
		}
	}
	// Decode query: finder.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "finder",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

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

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

					paramsDotFinderVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.Finder.SetTo(paramsDotFinderVal)
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "finder",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: playerId.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "playerId",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

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

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

					paramsDotPlayerIdVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.PlayerId.SetTo(paramsDotPlayerIdVal)
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "playerId",
			In:   "query",
			Err:  err,
		}
	}
	// Set default value for query: price.
	{
		val := int32(-1)
		params.Price.SetTo(val)
	}
	// Decode query: price.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "price",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

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

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

					paramsDotPriceVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.Price.SetTo(paramsDotPriceVal)
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "price",
			In:   "query",
			Err:  err,
		}
	}
	// Set default value for query: timeStamp.
	{
		val := int64(0)
		params.TimeStamp.SetTo(val)
	}
	// Decode query: timeStamp.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "timeStamp",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

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

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

					paramsDotTimeStampVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.TimeStamp.SetTo(paramsDotTimeStampVal)
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "timeStamp",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// APIItemItemTagDetailsGetParams is parameters of GET /api/item/{itemTag}/details operation.
type APIItemItemTagDetailsGetParams struct {
	ItemTag string
}

func unpackAPIItemItemTagDetailsGetParams(packed middleware.Parameters) (params APIItemItemTagDetailsGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "itemTag",
			In:   "path",
		}
		params.ItemTag = packed[key].(string)
	}
	return params
}

func decodeAPIItemItemTagDetailsGetParams(args [1]string, argsEscaped bool, r *http.Request) (params APIItemItemTagDetailsGetParams, _ error) {
	// Decode path: itemTag.
	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:   "itemTag",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.ItemTag = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "itemTag",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// APIItemItemTagSimilarGetParams is parameters of GET /api/item/{itemTag}/similar operation.
type APIItemItemTagSimilarGetParams struct {
	ItemTag string
}

func unpackAPIItemItemTagSimilarGetParams(packed middleware.Parameters) (params APIItemItemTagSimilarGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "itemTag",
			In:   "path",
		}
		params.ItemTag = packed[key].(string)
	}
	return params
}

func decodeAPIItemItemTagSimilarGetParams(args [1]string, argsEscaped bool, r *http.Request) (params APIItemItemTagSimilarGetParams, _ error) {
	// Decode path: itemTag.
	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:   "itemTag",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.ItemTag = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "itemTag",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// APIItemPriceItemTagBinGetParams is parameters of GET /api/item/price/{itemTag}/bin operation.
type APIItemPriceItemTagBinGetParams struct {
	// The tag of the item to search for bin.
	ItemTag string
	Query   *APIItemPriceItemTagBinGetQuery
}

func unpackAPIItemPriceItemTagBinGetParams(packed middleware.Parameters) (params APIItemPriceItemTagBinGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "itemTag",
			In:   "path",
		}
		params.ItemTag = packed[key].(string)
	}
	{
		key := middleware.ParameterKey{
			Name: "query",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Query = v.(*APIItemPriceItemTagBinGetQuery)
		}
	}
	return params
}

func decodeAPIItemPriceItemTagBinGetParams(args [1]string, argsEscaped bool, r *http.Request) (params APIItemPriceItemTagBinGetParams, _ error) {
	q := uri.NewQueryDecoder(r.URL.Query())
	// Decode path: itemTag.
	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:   "itemTag",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.ItemTag = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "itemTag",
			In:   "path",
			Err:  err,
		}
	}
	// Decode query: query.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "query",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotQueryVal APIItemPriceItemTagBinGetQuery
				if err := func() error {
					return paramsDotQueryVal.DecodeURI(d)
				}(); err != nil {
					return err
				}
				params.Query = &paramsDotQueryVal
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "query",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// APIItemPriceItemTagCurrentGetParams is parameters of GET /api/item/price/{itemTag}/current operation.
type APIItemPriceItemTagCurrentGetParams struct {
	// The tag of the item.
	ItemTag string
	// How many items to search for (and include in cost).
	Count OptInt32
}

func unpackAPIItemPriceItemTagCurrentGetParams(packed middleware.Parameters) (params APIItemPriceItemTagCurrentGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "itemTag",
			In:   "path",
		}
		params.ItemTag = packed[key].(string)
	}
	{
		key := middleware.ParameterKey{
			Name: "count",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Count = v.(OptInt32)
		}
	}
	return params
}

func decodeAPIItemPriceItemTagCurrentGetParams(args [1]string, argsEscaped bool, r *http.Request) (params APIItemPriceItemTagCurrentGetParams, _ error) {
	q := uri.NewQueryDecoder(r.URL.Query())
	// Decode path: itemTag.
	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:   "itemTag",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.ItemTag = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "itemTag",
			In:   "path",
			Err:  err,
		}
	}
	// Set default value for query: count.
	{
		val := int32(1)
		params.Count.SetTo(val)
	}
	// Decode query: count.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "count",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

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

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

					paramsDotCountVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.Count.SetTo(paramsDotCountVal)
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "count",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// APIItemPriceItemTagGetParams is parameters of GET /api/item/price/{itemTag} operation.
type APIItemPriceItemTagGetParams struct {
	// The item tag you want prices for.
	ItemTag string
	// Filter query.
	Query *APIItemPriceItemTagGetQuery
}

func unpackAPIItemPriceItemTagGetParams(packed middleware.Parameters) (params APIItemPriceItemTagGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "itemTag",
			In:   "path",
		}
		params.ItemTag = packed[key].(string)
	}
	{
		key := middleware.ParameterKey{
			Name: "query",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Query = v.(*APIItemPriceItemTagGetQuery)
		}
	}
	return params
}

func decodeAPIItemPriceItemTagGetParams(args [1]string, argsEscaped bool, r *http.Request) (params APIItemPriceItemTagGetParams, _ error) {
	q := uri.NewQueryDecoder(r.URL.Query())
	// Decode path: itemTag.
	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:   "itemTag",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.ItemTag = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "itemTag",
			In:   "path",
			Err:  err,
		}
	}
	// Decode query: query.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "query",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotQueryVal APIItemPriceItemTagGetQuery
				if err := func() error {
					return paramsDotQueryVal.DecodeURI(d)
				}(); err != nil {
					return err
				}
				params.Query = &paramsDotQueryVal
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "query",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// APIItemPriceItemTagHistoryDayGetParams is parameters of GET /api/item/price/{itemTag}/history/day operation.
type APIItemPriceItemTagHistoryDayGetParams struct {
	// The tag of the item.
	ItemTag string
	// Filter query.
	Query *APIItemPriceItemTagHistoryDayGetQuery
}

func unpackAPIItemPriceItemTagHistoryDayGetParams(packed middleware.Parameters) (params APIItemPriceItemTagHistoryDayGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "itemTag",
			In:   "path",
		}
		params.ItemTag = packed[key].(string)
	}
	{
		key := middleware.ParameterKey{
			Name: "query",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Query = v.(*APIItemPriceItemTagHistoryDayGetQuery)
		}
	}
	return params
}

func decodeAPIItemPriceItemTagHistoryDayGetParams(args [1]string, argsEscaped bool, r *http.Request) (params APIItemPriceItemTagHistoryDayGetParams, _ error) {
	q := uri.NewQueryDecoder(r.URL.Query())
	// Decode path: itemTag.
	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:   "itemTag",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.ItemTag = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "itemTag",
			In:   "path",
			Err:  err,
		}
	}
	// Decode query: query.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "query",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotQueryVal APIItemPriceItemTagHistoryDayGetQuery
				if err := func() error {
					return paramsDotQueryVal.DecodeURI(d)
				}(); err != nil {
					return err
				}
				params.Query = &paramsDotQueryVal
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "query",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// APIItemPriceItemTagHistoryFullGetParams is parameters of GET /api/item/price/{itemTag}/history/full operation.
type APIItemPriceItemTagHistoryFullGetParams struct {
	// The tag of the item.
	ItemTag string
}

func unpackAPIItemPriceItemTagHistoryFullGetParams(packed middleware.Parameters) (params APIItemPriceItemTagHistoryFullGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "itemTag",
			In:   "path",
		}
		params.ItemTag = packed[key].(string)
	}
	return params
}

func decodeAPIItemPriceItemTagHistoryFullGetParams(args [1]string, argsEscaped bool, r *http.Request) (params APIItemPriceItemTagHistoryFullGetParams, _ error) {
	// Decode path: itemTag.
	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:   "itemTag",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.ItemTag = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "itemTag",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// APIItemPriceItemTagHistoryMonthGetParams is parameters of GET /api/item/price/{itemTag}/history/month operation.
type APIItemPriceItemTagHistoryMonthGetParams struct {
	// The tag of the item.
	ItemTag string
	// Filter query.
	Query *APIItemPriceItemTagHistoryMonthGetQuery
}

func unpackAPIItemPriceItemTagHistoryMonthGetParams(packed middleware.Parameters) (params APIItemPriceItemTagHistoryMonthGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "itemTag",
			In:   "path",
		}
		params.ItemTag = packed[key].(string)
	}
	{
		key := middleware.ParameterKey{
			Name: "query",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Query = v.(*APIItemPriceItemTagHistoryMonthGetQuery)
		}
	}
	return params
}

func decodeAPIItemPriceItemTagHistoryMonthGetParams(args [1]string, argsEscaped bool, r *http.Request) (params APIItemPriceItemTagHistoryMonthGetParams, _ error) {
	q := uri.NewQueryDecoder(r.URL.Query())
	// Decode path: itemTag.
	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:   "itemTag",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.ItemTag = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "itemTag",
			In:   "path",
			Err:  err,
		}
	}
	// Decode query: query.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "query",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotQueryVal APIItemPriceItemTagHistoryMonthGetQuery
				if err := func() error {
					return paramsDotQueryVal.DecodeURI(d)
				}(); err != nil {
					return err
				}
				params.Query = &paramsDotQueryVal
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "query",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// APIItemPriceItemTagHistoryWeekGetParams is parameters of GET /api/item/price/{itemTag}/history/week operation.
type APIItemPriceItemTagHistoryWeekGetParams struct {
	// The tag of the item.
	ItemTag string
	// Filter query.
	Query *APIItemPriceItemTagHistoryWeekGetQuery
}

func unpackAPIItemPriceItemTagHistoryWeekGetParams(packed middleware.Parameters) (params APIItemPriceItemTagHistoryWeekGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "itemTag",
			In:   "path",
		}
		params.ItemTag = packed[key].(string)
	}
	{
		key := middleware.ParameterKey{
			Name: "query",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Query = v.(*APIItemPriceItemTagHistoryWeekGetQuery)
		}
	}
	return params
}

func decodeAPIItemPriceItemTagHistoryWeekGetParams(args [1]string, argsEscaped bool, r *http.Request) (params APIItemPriceItemTagHistoryWeekGetParams, _ error) {
	q := uri.NewQueryDecoder(r.URL.Query())
	// Decode path: itemTag.
	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:   "itemTag",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.ItemTag = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "itemTag",
			In:   "path",
			Err:  err,
		}
	}
	// Decode query: query.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "query",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotQueryVal APIItemPriceItemTagHistoryWeekGetQuery
				if err := func() error {
					return paramsDotQueryVal.DecodeURI(d)
				}(); err != nil {
					return err
				}
				params.Query = &paramsDotQueryVal
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "query",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// APIItemSearchSearchValGetParams is parameters of GET /api/item/search/{searchVal} operation.
type APIItemSearchSearchValGetParams struct {
	// The search term to search for.
	SearchVal string
}

func unpackAPIItemSearchSearchValGetParams(packed middleware.Parameters) (params APIItemSearchSearchValGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "searchVal",
			In:   "path",
		}
		params.SearchVal = packed[key].(string)
	}
	return params
}

func decodeAPIItemSearchSearchValGetParams(args [1]string, argsEscaped bool, r *http.Request) (params APIItemSearchSearchValGetParams, _ error) {
	// Decode path: searchVal.
	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:   "searchVal",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.SearchVal = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "searchVal",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// APIMayorGetParams is parameters of GET /api/mayor operation.
type APIMayorGetParams struct {
	// Start ISO 8601.
	From OptDateTime
	// End eg. 2022-09-22T20:03:10.937Z.
	To OptDateTime
}

func unpackAPIMayorGetParams(packed middleware.Parameters) (params APIMayorGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "from",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.From = v.(OptDateTime)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "to",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.To = v.(OptDateTime)
		}
	}
	return params
}

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

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

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

					paramsDotFromVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.From.SetTo(paramsDotFromVal)
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "from",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: to.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "to",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

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

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

					paramsDotToVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.To.SetTo(paramsDotToVal)
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "to",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// APIMayorYearGetParams is parameters of GET /api/mayor/{year} operation.
type APIMayorYearGetParams struct {
	Year int32
}

func unpackAPIMayorYearGetParams(packed middleware.Parameters) (params APIMayorYearGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "year",
			In:   "path",
		}
		params.Year = packed[key].(int32)
	}
	return params
}

func decodeAPIMayorYearGetParams(args [1]string, argsEscaped bool, r *http.Request) (params APIMayorYearGetParams, _ error) {
	// Decode path: year.
	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:   "year",
				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.Year = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "year",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// APIModDescriptionModificationsPostParams is parameters of POST /api/mod/description/modifications operation.
type APIModDescriptionModificationsPostParams struct {
	// (optional) Connection id of the calling mod to apply user settings.
	ConId OptString
	// (optional) The uuid of the calling player.
	UUID OptString
}

func unpackAPIModDescriptionModificationsPostParams(packed middleware.Parameters) (params APIModDescriptionModificationsPostParams) {
	{
		key := middleware.ParameterKey{
			Name: "conId",
			In:   "header",
		}
		if v, ok := packed[key]; ok {
			params.ConId = v.(OptString)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "uuid",
			In:   "header",
		}
		if v, ok := packed[key]; ok {
			params.UUID = v.(OptString)
		}
	}
	return params
}

func decodeAPIModDescriptionModificationsPostParams(args [0]string, argsEscaped bool, r *http.Request) (params APIModDescriptionModificationsPostParams, _ error) {
	h := uri.NewHeaderDecoder(r.Header)
	// Decode header: conId.
	if err := func() error {
		cfg := uri.HeaderParameterDecodingConfig{
			Name:    "conId",
			Explode: false,
		}
		if err := h.HasParam(cfg); err == nil {
			if err := h.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotConIdVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

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

					paramsDotConIdVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.ConId.SetTo(paramsDotConIdVal)
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "conId",
			In:   "header",
			Err:  err,
		}
	}
	// Decode header: uuid.
	if err := func() error {
		cfg := uri.HeaderParameterDecodingConfig{
			Name:    "uuid",
			Explode: false,
		}
		if err := h.HasParam(cfg); err == nil {
			if err := h.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotUUIDVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

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

					paramsDotUUIDVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.UUID.SetTo(paramsDotUUIDVal)
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "uuid",
			In:   "header",
			Err:  err,
		}
	}
	return params, nil
}

// APIModDescriptionPostParams is parameters of POST /api/mod/description operation.
type APIModDescriptionPostParams struct {
	// (optional) Connection id of the calling mod to apply user settings.
	ConId OptString
	// (optional) The uuid of the calling player.
	UUID OptString
}

func unpackAPIModDescriptionPostParams(packed middleware.Parameters) (params APIModDescriptionPostParams) {
	{
		key := middleware.ParameterKey{
			Name: "conId",
			In:   "header",
		}
		if v, ok := packed[key]; ok {
			params.ConId = v.(OptString)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "uuid",
			In:   "header",
		}
		if v, ok := packed[key]; ok {
			params.UUID = v.(OptString)
		}
	}
	return params
}

func decodeAPIModDescriptionPostParams(args [0]string, argsEscaped bool, r *http.Request) (params APIModDescriptionPostParams, _ error) {
	h := uri.NewHeaderDecoder(r.Header)
	// Decode header: conId.
	if err := func() error {
		cfg := uri.HeaderParameterDecodingConfig{
			Name:    "conId",
			Explode: false,
		}
		if err := h.HasParam(cfg); err == nil {
			if err := h.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotConIdVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

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

					paramsDotConIdVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.ConId.SetTo(paramsDotConIdVal)
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "conId",
			In:   "header",
			Err:  err,
		}
	}
	// Decode header: uuid.
	if err := func() error {
		cfg := uri.HeaderParameterDecodingConfig{
			Name:    "uuid",
			Explode: false,
		}
		if err := h.HasParam(cfg); err == nil {
			if err := h.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotUUIDVal string
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

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

					paramsDotUUIDVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.UUID.SetTo(paramsDotUUIDVal)
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "uuid",
			In:   "header",
			Err:  err,
		}
	}
	return params, nil
}

// APIModItemUUIDGetParams is parameters of GET /api/mod/item/{uuid} operation.
type APIModItemUUIDGetParams struct {
	UUID  string
	Count OptInt32
}

func unpackAPIModItemUUIDGetParams(packed middleware.Parameters) (params APIModItemUUIDGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "uuid",
			In:   "path",
		}
		params.UUID = packed[key].(string)
	}
	{
		key := middleware.ParameterKey{
			Name: "count",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Count = v.(OptInt32)
		}
	}
	return params
}

func decodeAPIModItemUUIDGetParams(args [1]string, argsEscaped bool, r *http.Request) (params APIModItemUUIDGetParams, _ error) {
	q := uri.NewQueryDecoder(r.URL.Query())
	// Decode path: uuid.
	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:   "uuid",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.UUID = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "uuid",
			In:   "path",
			Err:  err,
		}
	}
	// Set default value for query: count.
	{
		val := int32(1)
		params.Count.SetTo(val)
	}
	// Decode query: count.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "count",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

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

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

					paramsDotCountVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.Count.SetTo(paramsDotCountVal)
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "count",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// APIPlayerPlayerUuidAuctionsGetParams is parameters of GET /api/player/{playerUuid}/auctions operation.
type APIPlayerPlayerUuidAuctionsGetParams struct {
	// The uuid of the player.
	PlayerUuid string
	// Page of auctions (another 10).
	Page    OptInt32
	Filters *APIPlayerPlayerUuidAuctionsGetFilters
}

func unpackAPIPlayerPlayerUuidAuctionsGetParams(packed middleware.Parameters) (params APIPlayerPlayerUuidAuctionsGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "playerUuid",
			In:   "path",
		}
		params.PlayerUuid = packed[key].(string)
	}
	{
		key := middleware.ParameterKey{
			Name: "page",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Page = v.(OptInt32)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "filters",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Filters = v.(*APIPlayerPlayerUuidAuctionsGetFilters)
		}
	}
	return params
}

func decodeAPIPlayerPlayerUuidAuctionsGetParams(args [1]string, argsEscaped bool, r *http.Request) (params APIPlayerPlayerUuidAuctionsGetParams, _ error) {
	q := uri.NewQueryDecoder(r.URL.Query())
	// Decode path: playerUuid.
	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:   "playerUuid",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.PlayerUuid = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "playerUuid",
			In:   "path",
			Err:  err,
		}
	}
	// Set default value for query: page.
	{
		val := int32(0)
		params.Page.SetTo(val)
	}
	// 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 {
				var paramsDotPageVal int32
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

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

					paramsDotPageVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.Page.SetTo(paramsDotPageVal)
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "page",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: filters.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "filters",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotFiltersVal APIPlayerPlayerUuidAuctionsGetFilters
				if err := func() error {
					return paramsDotFiltersVal.DecodeURI(d)
				}(); err != nil {
					return err
				}
				params.Filters = &paramsDotFiltersVal
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "filters",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// APIPlayerPlayerUuidBidsGetParams is parameters of GET /api/player/{playerUuid}/bids operation.
type APIPlayerPlayerUuidBidsGetParams struct {
	// The uuid of the player.
	PlayerUuid string
	// Page of auctions (another 10).
	Page    OptInt32
	Filters *APIPlayerPlayerUuidBidsGetFilters
}

func unpackAPIPlayerPlayerUuidBidsGetParams(packed middleware.Parameters) (params APIPlayerPlayerUuidBidsGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "playerUuid",
			In:   "path",
		}
		params.PlayerUuid = packed[key].(string)
	}
	{
		key := middleware.ParameterKey{
			Name: "page",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Page = v.(OptInt32)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "filters",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Filters = v.(*APIPlayerPlayerUuidBidsGetFilters)
		}
	}
	return params
}

func decodeAPIPlayerPlayerUuidBidsGetParams(args [1]string, argsEscaped bool, r *http.Request) (params APIPlayerPlayerUuidBidsGetParams, _ error) {
	q := uri.NewQueryDecoder(r.URL.Query())
	// Decode path: playerUuid.
	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:   "playerUuid",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.PlayerUuid = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "playerUuid",
			In:   "path",
			Err:  err,
		}
	}
	// Set default value for query: page.
	{
		val := int32(0)
		params.Page.SetTo(val)
	}
	// 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 {
				var paramsDotPageVal int32
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

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

					paramsDotPageVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.Page.SetTo(paramsDotPageVal)
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "page",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: filters.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "filters",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotFiltersVal APIPlayerPlayerUuidBidsGetFilters
				if err := func() error {
					return paramsDotFiltersVal.DecodeURI(d)
				}(); err != nil {
					return err
				}
				params.Filters = &paramsDotFiltersVal
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "filters",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// APIPlayerPlayerUuidNameGetParams is parameters of GET /api/player/{playerUuid}/name operation.
type APIPlayerPlayerUuidNameGetParams struct {
	// The uuid of the player.
	PlayerUuid string
}

func unpackAPIPlayerPlayerUuidNameGetParams(packed middleware.Parameters) (params APIPlayerPlayerUuidNameGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "playerUuid",
			In:   "path",
		}
		params.PlayerUuid = packed[key].(string)
	}
	return params
}

func decodeAPIPlayerPlayerUuidNameGetParams(args [1]string, argsEscaped bool, r *http.Request) (params APIPlayerPlayerUuidNameGetParams, _ error) {
	// Decode path: playerUuid.
	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:   "playerUuid",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.PlayerUuid = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "playerUuid",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// APIPlayerPlayerUuidNamePostParams is parameters of POST /api/player/{playerUuid}/name operation.
type APIPlayerPlayerUuidNamePostParams struct {
	// The uuid of the player.
	PlayerUuid string
}

func unpackAPIPlayerPlayerUuidNamePostParams(packed middleware.Parameters) (params APIPlayerPlayerUuidNamePostParams) {
	{
		key := middleware.ParameterKey{
			Name: "playerUuid",
			In:   "path",
		}
		params.PlayerUuid = packed[key].(string)
	}
	return params
}

func decodeAPIPlayerPlayerUuidNamePostParams(args [1]string, argsEscaped bool, r *http.Request) (params APIPlayerPlayerUuidNamePostParams, _ error) {
	// Decode path: playerUuid.
	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:   "playerUuid",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.PlayerUuid = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "playerUuid",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// APISearchPlayerPlayerNameGetParams is parameters of GET /api/search/player/{playerName} operation.
type APISearchPlayerPlayerNameGetParams struct {
	// The player name to search for.
	PlayerName string
}

func unpackAPISearchPlayerPlayerNameGetParams(packed middleware.Parameters) (params APISearchPlayerPlayerNameGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "playerName",
			In:   "path",
		}
		params.PlayerName = packed[key].(string)
	}
	return params
}

func decodeAPISearchPlayerPlayerNameGetParams(args [1]string, argsEscaped bool, r *http.Request) (params APISearchPlayerPlayerNameGetParams, _ error) {
	// Decode path: playerName.
	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:   "playerName",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.PlayerName = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "playerName",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// APISearchSearchValGetParams is parameters of GET /api/search/{searchVal} operation.
type APISearchSearchValGetParams struct {
	// The search term to search for.
	SearchVal string
	// The maximum amount of results to return.
	Limit OptInt32
}

func unpackAPISearchSearchValGetParams(packed middleware.Parameters) (params APISearchSearchValGetParams) {
	{
		key := middleware.ParameterKey{
			Name: "searchVal",
			In:   "path",
		}
		params.SearchVal = packed[key].(string)
	}
	{
		key := middleware.ParameterKey{
			Name: "limit",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Limit = v.(OptInt32)
		}
	}
	return params
}

func decodeAPISearchSearchValGetParams(args [1]string, argsEscaped bool, r *http.Request) (params APISearchSearchValGetParams, _ error) {
	q := uri.NewQueryDecoder(r.URL.Query())
	// Decode path: searchVal.
	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:   "searchVal",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.SearchVal = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "searchVal",
			In:   "path",
			Err:  err,
		}
	}
	// Set default value for query: limit.
	{
		val := int32(5)
		params.Limit.SetTo(val)
	}
	// 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 {
				var paramsDotLimitVal int32
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

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

					paramsDotLimitVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.Limit.SetTo(paramsDotLimitVal)
				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "limit",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// APITopupPaypalProductSlugPostParams is parameters of POST /api/topup/paypal/{productSlug} operation.
type APITopupPaypalProductSlugPostParams struct {
	ProductSlug string
}

func unpackAPITopupPaypalProductSlugPostParams(packed middleware.Parameters) (params APITopupPaypalProductSlugPostParams) {
	{
		key := middleware.ParameterKey{
			Name: "productSlug",
			In:   "path",
		}
		params.ProductSlug = packed[key].(string)
	}
	return params
}

func decodeAPITopupPaypalProductSlugPostParams(args [1]string, argsEscaped bool, r *http.Request) (params APITopupPaypalProductSlugPostParams, _ error) {
	// Decode path: productSlug.
	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:   "productSlug",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.ProductSlug = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "productSlug",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}

// APITopupStripeProductSlugPostParams is parameters of POST /api/topup/stripe/{productSlug} operation.
type APITopupStripeProductSlugPostParams struct {
	ProductSlug string
}

func unpackAPITopupStripeProductSlugPostParams(packed middleware.Parameters) (params APITopupStripeProductSlugPostParams) {
	{
		key := middleware.ParameterKey{
			Name: "productSlug",
			In:   "path",
		}
		params.ProductSlug = packed[key].(string)
	}
	return params
}

func decodeAPITopupStripeProductSlugPostParams(args [1]string, argsEscaped bool, r *http.Request) (params APITopupStripeProductSlugPostParams, _ error) {
	// Decode path: productSlug.
	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:   "productSlug",
				Value:   param,
				Style:   uri.PathStyleSimple,
				Explode: false,
			})

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

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

				params.ProductSlug = c
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return validate.ErrFieldRequired
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "productSlug",
			In:   "path",
			Err:  err,
		}
	}
	return params, nil
}