// Code generated by ogen, DO NOT EDIT.

package rest

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

// CancelDatasetJobParams is parameters of cancelDatasetJob operation.
type CancelDatasetJobParams struct {
	ID string
}

func unpackCancelDatasetJobParams(packed middleware.Parameters) (params CancelDatasetJobParams) {
	{
		key := middleware.ParameterKey{
			Name: "id",
			In:   "path",
		}
		params.ID = packed[key].(string)
	}
	return params
}

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

// CancelPredictionJobParams is parameters of cancelPredictionJob operation.
type CancelPredictionJobParams struct {
	ID string
}

func unpackCancelPredictionJobParams(packed middleware.Parameters) (params CancelPredictionJobParams) {
	{
		key := middleware.ParameterKey{
			Name: "id",
			In:   "path",
		}
		params.ID = packed[key].(string)
	}
	return params
}

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

// DeleteDatasetParams is parameters of deleteDataset operation.
type DeleteDatasetParams struct {
	Name string
}

func unpackDeleteDatasetParams(packed middleware.Parameters) (params DeleteDatasetParams) {
	{
		key := middleware.ParameterKey{
			Name: "name",
			In:   "path",
		}
		params.Name = packed[key].(string)
	}
	return params
}

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

// GetDatasetJobParams is parameters of getDatasetJob operation.
type GetDatasetJobParams struct {
	ID string
}

func unpackGetDatasetJobParams(packed middleware.Parameters) (params GetDatasetJobParams) {
	{
		key := middleware.ParameterKey{
			Name: "id",
			In:   "path",
		}
		params.ID = packed[key].(string)
	}
	return params
}

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

// GetPredictionJobParams is parameters of getPredictionJob operation.
type GetPredictionJobParams struct {
	ID string
}

func unpackGetPredictionJobParams(packed middleware.Parameters) (params GetPredictionJobParams) {
	{
		key := middleware.ParameterKey{
			Name: "id",
			In:   "path",
		}
		params.ID = packed[key].(string)
	}
	return params
}

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

// GetWindFieldParams is parameters of getWindField operation.
type GetWindFieldParams struct {
	Time     OptDateTime `json:",omitempty,omitzero"`
	Altitude OptFloat64  `json:",omitempty,omitzero"`
	MinLat   OptFloat64  `json:",omitempty,omitzero"`
	MaxLat   OptFloat64  `json:",omitempty,omitzero"`
	MinLng   OptFloat64  `json:",omitempty,omitzero"`
	MaxLng   OptFloat64  `json:",omitempty,omitzero"`
	Step     OptFloat64  `json:",omitempty,omitzero"`
}

func unpackGetWindFieldParams(packed middleware.Parameters) (params GetWindFieldParams) {
	{
		key := middleware.ParameterKey{
			Name: "time",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Time = v.(OptDateTime)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "altitude",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Altitude = v.(OptFloat64)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "min_lat",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.MinLat = v.(OptFloat64)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "max_lat",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.MaxLat = v.(OptFloat64)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "min_lng",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.MinLng = v.(OptFloat64)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "max_lng",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.MaxLng = v.(OptFloat64)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "step",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Step = v.(OptFloat64)
		}
	}
	return params
}

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

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotTimeVal 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
					}

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

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

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

					paramsDotAltitudeVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.Altitude.SetTo(paramsDotAltitudeVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.Altitude.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: "altitude",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: min_lat.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "min_lat",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

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

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

					paramsDotMinLatVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.MinLat.SetTo(paramsDotMinLatVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.MinLat.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: "min_lat",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: max_lat.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "max_lat",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

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

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

					paramsDotMaxLatVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.MaxLat.SetTo(paramsDotMaxLatVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.MaxLat.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: "max_lat",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: min_lng.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "min_lng",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

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

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

					paramsDotMinLngVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.MinLng.SetTo(paramsDotMinLngVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.MinLng.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: "min_lng",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: max_lng.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "max_lng",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

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

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

					paramsDotMaxLngVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.MaxLng.SetTo(paramsDotMaxLngVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.MaxLng.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: "max_lng",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: step.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "step",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

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

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

					paramsDotStepVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.Step.SetTo(paramsDotStepVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.Step.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: "step",
			In:   "query",
			Err:  err,
		}
	}
	return params, nil
}

// PerformPredictionParams is parameters of performPrediction operation.
type PerformPredictionParams struct {
	LaunchLatitude  float64
	LaunchLongitude float64
	LaunchDatetime  time.Time
	LaunchAltitude  OptFloat64                  `json:",omitempty,omitzero"`
	Profile         OptPerformPredictionProfile `json:",omitempty,omitzero"`
	AscentRate      OptFloat64                  `json:",omitempty,omitzero"`
	BurstAltitude   OptFloat64                  `json:",omitempty,omitzero"`
	DescentRate     OptFloat64                  `json:",omitempty,omitzero"`
	FloatAltitude   OptFloat64                  `json:",omitempty,omitzero"`
	StopDatetime    OptDateTime                 `json:",omitempty,omitzero"`
	Dataset         OptDateTime                 `json:",omitempty,omitzero"`
}

func unpackPerformPredictionParams(packed middleware.Parameters) (params PerformPredictionParams) {
	{
		key := middleware.ParameterKey{
			Name: "launch_latitude",
			In:   "query",
		}
		params.LaunchLatitude = packed[key].(float64)
	}
	{
		key := middleware.ParameterKey{
			Name: "launch_longitude",
			In:   "query",
		}
		params.LaunchLongitude = packed[key].(float64)
	}
	{
		key := middleware.ParameterKey{
			Name: "launch_datetime",
			In:   "query",
		}
		params.LaunchDatetime = packed[key].(time.Time)
	}
	{
		key := middleware.ParameterKey{
			Name: "launch_altitude",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.LaunchAltitude = v.(OptFloat64)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "profile",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Profile = v.(OptPerformPredictionProfile)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "ascent_rate",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.AscentRate = v.(OptFloat64)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "burst_altitude",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.BurstAltitude = v.(OptFloat64)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "descent_rate",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.DescentRate = v.(OptFloat64)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "float_altitude",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.FloatAltitude = v.(OptFloat64)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "stop_datetime",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.StopDatetime = v.(OptDateTime)
		}
	}
	{
		key := middleware.ParameterKey{
			Name: "dataset",
			In:   "query",
		}
		if v, ok := packed[key]; ok {
			params.Dataset = v.(OptDateTime)
		}
	}
	return params
}

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

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

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

				params.LaunchLatitude = c
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Float{}).Validate(float64(params.LaunchLatitude)); err != nil {
					return errors.Wrap(err, "float")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return err
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "launch_latitude",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: launch_longitude.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "launch_longitude",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

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

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

				params.LaunchLongitude = c
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if err := (validate.Float{}).Validate(float64(params.LaunchLongitude)); err != nil {
					return errors.Wrap(err, "float")
				}
				return nil
			}(); err != nil {
				return err
			}
		} else {
			return err
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "launch_longitude",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: launch_datetime.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "launch_datetime",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

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

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

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

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

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

					paramsDotLaunchAltitudeVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.LaunchAltitude.SetTo(paramsDotLaunchAltitudeVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.LaunchAltitude.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: "launch_altitude",
			In:   "query",
			Err:  err,
		}
	}
	// Set default value for query: profile.
	{
		val := PerformPredictionProfile("standard_profile")
		params.Profile.SetTo(val)
	}
	// 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 PerformPredictionProfile
				if err := func() error {
					val, err := d.DecodeValue()
					if err != nil {
						return err
					}

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

					paramsDotProfileVal = PerformPredictionProfile(c)
					return nil
				}(); err != nil {
					return err
				}
				params.Profile.SetTo(paramsDotProfileVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.Profile.Get(); ok {
					if err := func() error {
						if err := value.Validate(); err != nil {
							return err
						}
						return nil
					}(); err != nil {
						return err
					}
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		return params, &ogenerrors.DecodeParamError{
			Name: "profile",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: ascent_rate.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "ascent_rate",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

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

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

					paramsDotAscentRateVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.AscentRate.SetTo(paramsDotAscentRateVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.AscentRate.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: "ascent_rate",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: burst_altitude.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "burst_altitude",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

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

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

					paramsDotBurstAltitudeVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.BurstAltitude.SetTo(paramsDotBurstAltitudeVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.BurstAltitude.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: "burst_altitude",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: descent_rate.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "descent_rate",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

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

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

					paramsDotDescentRateVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.DescentRate.SetTo(paramsDotDescentRateVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.DescentRate.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: "descent_rate",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: float_altitude.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "float_altitude",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

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

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

					paramsDotFloatAltitudeVal = c
					return nil
				}(); err != nil {
					return err
				}
				params.FloatAltitude.SetTo(paramsDotFloatAltitudeVal)
				return nil
			}); err != nil {
				return err
			}
			if err := func() error {
				if value, ok := params.FloatAltitude.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: "float_altitude",
			In:   "query",
			Err:  err,
		}
	}
	// Decode query: stop_datetime.
	if err := func() error {
		cfg := uri.QueryParameterDecodingConfig{
			Name:    "stop_datetime",
			Style:   uri.QueryStyleForm,
			Explode: true,
		}

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotStopDatetimeVal 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
					}

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

		if err := q.HasParam(cfg); err == nil {
			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
				var paramsDotDatasetVal 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
					}

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