feat: predictor works

.gitignore

@@ -52,3 +52,7 @@ Thumbs.db
 # GRIB files
 /grib_data/
 /grib_data/*
+
+# Leaflet WebUI
+/leaflet_predictor
+/leaflet_predictor/*

api/rest/predictor.swagger.yml

@@ -4,25 +4,77 @@ info:
   version: 0.0.1
 paths:
   /api/v1/prediction:
-    post:
+    get:
       tags:
         - Prediction
-      summary: Perform preidction
+      summary: Perform prediction
       operationId: performPrediction
       parameters:
         - in: query
-          name: parameters
+          name: launch_latitude
-          required: false
           schema:
-            $ref: '#/components/schemas/PredictionParameters'
+            type: number
-          style: form
+        - in: query
-          explode: true
+          name: launch_longitude
-      requestBody:
+          schema:
-        required: false
+            type: number
-        content:
+        - in: query
-          application/json:
+          name: launch_datetime
-            schema:
+          schema:
-              $ref: '#/components/schemas/PredictionParameters'
+            type: string
+            format: date-time
+        - in: query
+          name: launch_altitude
+          schema:
+            type: number
+        - in: query
+          name: profile
+          schema:
+            type: string
+            enum: [standard_profile, float_profile, reverse_profile, custom_profile]
+        - in: query
+          name: ascent_rate
+          schema:
+            type: number
+        - in: query
+          name: burst_altitude
+          schema:
+            type: number
+        - in: query
+          name: descent_rate
+          schema:
+            type: number
+        - in: query
+          name: float_altitude
+          schema:
+            type: number
+        - in: query
+          name: stop_datetime
+          schema:
+            type: string
+            format: date-time
+        - in: query
+          name: ascent_curve
+          schema:
+            type: string
+        - in: query
+          name: descent_curve
+          schema:
+            type: string
+        - in: query
+          name: interpolate
+          schema:
+            type: boolean
+        - in: query
+          name: format
+          schema:
+            type: string
+            enum: [json]
+        - in: query
+          name: dataset
+          schema:
+            type: string
+            format: date-time
       responses:
         "200":
           description: "Prediction response"
@@ -67,48 +119,6 @@ components:
           type: string
         details:
           type: string
-    PredictionParameters: 
-      type: object
-      properties:
-        launch_latitude: # TODO: altitude not required with fallback to https://github.com/priyeshpatel/ruaumoko Go analog
-          type: number
-        launch_longitude:
-          type: number
-        launch_datetime:
-          type: string
-          format: date-time
-        launch_altitude:
-          type: number
-        profile:
-          type: string
-          enum: ["standard_profile", "float_profile", "reverse_profile", "custom_profile"]
-        ascent_rate:
-          type: number
-        burst_altitude:
-          type: number
-        descent_rate:
-          type: number
-        float_altitude:
-          type: number
-        stop_datetime:
-          type: string
-          format: date-time
-        ascent_curve:
-          type: string
-          description: "Base64 encoded ascent curve"
-        descent_curve:
-          type: string
-          description: "Base64 encoded descent curve"
-        interpolate:
-          type: boolean
-          default: false
-        format: # TODO: custom output format (csv, kml) with json as default 
-          type: string
-          enum: ["json"]
-          default: json
-        dataset:
-          type: string
-          format: date-time
     PredictionResult:
       type: object
       required:

go.mod

@@ -32,6 +32,7 @@ require (
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/redis/go-redis/v9 v9.10.0 // indirect
 	github.com/robfig/cron/v3 v3.0.1 // indirect
+	github.com/rs/cors v1.11.1 // indirect
 	github.com/segmentio/asm v1.2.0 // indirect
 	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
 	go.uber.org/atomic v1.9.0 // indirect

go.sum

@@ -65,6 +65,8 @@ github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTE
 github.com/rogpeppe/go-internal v1.8.1/go.mod h1:JeRgkft04UBgHMgCIwADu4Pn6Mtm5d4nPKWu0nJ5d+o=
 github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
 github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
+github.com/rs/cors v1.11.1 h1:eU3gRzXLRK57F5rKMGMZURNdIG4EoAmX8k94r9wXWHA=
+github.com/rs/cors v1.11.1/go.mod h1:XyqrcTp5zjWr1wsJ8PIRZssZ8b/WMcMf71DJnit4EMU=
 github.com/segmentio/asm v1.2.0 h1:9BQrFxC+YOHJlTlHGkTrFWf59nbL3XnCoFLTwDCI7ys=
 github.com/segmentio/asm v1.2.0/go.mod h1:BqMnlJP91P8d+4ibuonYZw9mfnzI9HfxselHZr5aAcs=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=

internal/pkg/ds/predictor.go

@@ -35,60 +35,54 @@ type PredicitonResult struct {
 	// Add other result fields as needed
 }
 
-// ConvertOptPredictionParameters converts ogen's OptPredictionParameters to the internal pointer-based model.
+// Converts flat ogen params to internal pointer-based model
-// Returns nil if the input is not set.
+func ConvertFlatPredictionParams(params api.PerformPredictionParams) *PredictionParameters {
-func ConvertOptPredictionParameters(opt api.OptPredictionParameters) *PredictionParameters {
-	if !opt.Set {
-		return nil
-	}
-	in := opt.Value
 	out := &PredictionParameters{}
-
+	if v, ok := params.LaunchLatitude.Get(); ok {
-	if v, ok := in.LaunchLatitude.Get(); ok {
 		out.LaunchLatitude = &v
 	}
-	if v, ok := in.LaunchLongitude.Get(); ok {
+	if v, ok := params.LaunchLongitude.Get(); ok {
 		out.LaunchLongitude = &v
 	}
-	if v, ok := in.LaunchDatetime.Get(); ok {
+	if v, ok := params.LaunchDatetime.Get(); ok {
 		out.LaunchDatetime = &v
 	}
-	if v, ok := in.LaunchAltitude.Get(); ok {
+	if v, ok := params.LaunchAltitude.Get(); ok {
 		out.LaunchAltitude = &v
 	}
-	if v, ok := in.Profile.Get(); ok {
+	if v, ok := params.Profile.Get(); ok {
 		s := string(v)
 		out.Profile = &s
 	}
-	if v, ok := in.AscentRate.Get(); ok {
+	if v, ok := params.AscentRate.Get(); ok {
 		out.AscentRate = &v
 	}
-	if v, ok := in.BurstAltitude.Get(); ok {
+	if v, ok := params.BurstAltitude.Get(); ok {
 		out.BurstAltitude = &v
 	}
-	if v, ok := in.DescentRate.Get(); ok {
+	if v, ok := params.DescentRate.Get(); ok {
 		out.DescentRate = &v
 	}
-	if v, ok := in.FloatAltitude.Get(); ok {
+	if v, ok := params.FloatAltitude.Get(); ok {
 		out.FloatAltitude = &v
 	}
-	if v, ok := in.StopDatetime.Get(); ok {
+	if v, ok := params.StopDatetime.Get(); ok {
 		out.StopDatetime = &v
 	}
-	if v, ok := in.AscentCurve.Get(); ok {
+	if v, ok := params.AscentCurve.Get(); ok {
 		out.AscentCurve = &v
 	}
-	if v, ok := in.DescentCurve.Get(); ok {
+	if v, ok := params.DescentCurve.Get(); ok {
 		out.DescentCurve = &v
 	}
-	if v, ok := in.Interpolate.Get(); ok {
+	if v, ok := params.Interpolate.Get(); ok {
 		out.Interpolate = &v
 	}
-	if v, ok := in.Format.Get(); ok {
+	if v, ok := params.Format.Get(); ok {
 		s := string(v)
 		out.Format = &s
 	}
-	if v, ok := in.Dataset.Get(); ok {
+	if v, ok := params.Dataset.Get(); ok {
 		out.Dataset = &v
 	}
 	return out

internal/transport/rest/handler/handler.go

@@ -24,8 +24,8 @@ func New(svc Service) *Handler {
 	}
 }
 
-func (h *Handler) PerformPrediction(ctx context.Context, req api.OptPredictionParameters, params api.PerformPredictionParams) (*api.PredictionResult, error) {
+func (h *Handler) PerformPrediction(ctx context.Context, params api.PerformPredictionParams) (*api.PredictionResult, error) {
-	internalParams := ds.ConvertOptPredictionParameters(req)
+	internalParams := ds.ConvertFlatPredictionParams(params)
 	if internalParams == nil {
 		return nil, errcodes.New(http.StatusBadRequest, "invalid or missing parameters")
 	}

internal/transport/rest/transport.go

@@ -9,6 +9,7 @@ import (
 	"git.intra.yksa.space/gsn/predictor/internal/transport/middleware"
 	handler "git.intra.yksa.space/gsn/predictor/internal/transport/rest/handler"
 	api "git.intra.yksa.space/gsn/predictor/pkg/rest"
+	"github.com/rs/cors"
 )
 
 type Transport struct {
@@ -18,7 +19,10 @@ type Transport struct {
 }
 
 func New(handler *handler.Handler, cfg *Config) (*Transport, error) {
-	srv, err := api.NewServer(handler, api.WithMiddleware(middleware.Logging()))
+	srv, err := api.NewServer(
+		handler,
+		api.WithMiddleware(middleware.Logging()),
+	)
 	if err != nil {
 		return nil, err
 	}
@@ -33,6 +37,10 @@ func New(handler *handler.Handler, cfg *Config) (*Transport, error) {
 func (t *Transport) Run() {
 	log.Ctx(context.Background()).Info("started")
 
+	mux := http.NewServeMux()
+	mux.Handle("/", t.srv)
+	cors.AllowAll().Handler(mux)
+
 	if err := http.ListenAndServe(fmt.Sprintf(":%d", t.cfg.Port), t.srv); err != nil {
 		panic(err)
 	}

pkg/rest/oas_client_gen.go

@@ -15,6 +15,7 @@ import (
 	semconv "go.opentelemetry.io/otel/semconv/v1.26.0"
 	"go.opentelemetry.io/otel/trace"
 
+	"github.com/ogen-go/ogen/conv"
 	ht "github.com/ogen-go/ogen/http"
 	"github.com/ogen-go/ogen/otelogen"
 	"github.com/ogen-go/ogen/uri"
@@ -29,10 +30,10 @@ func trimTrailingSlashes(u *url.URL) {
 type Invoker interface {
 	// PerformPrediction invokes performPrediction operation.
 	//
-	// Perform preidction.
+	// Perform prediction.
 	//
-	// POST /api/v1/prediction
+	// GET /api/v1/prediction
-	PerformPrediction(ctx context.Context, request OptPredictionParameters, params PerformPredictionParams) (*PredictionResult, error)
+	PerformPrediction(ctx context.Context, params PerformPredictionParams) (*PredictionResult, error)
 	// ReadinessCheck invokes readinessCheck operation.
 	//
 	// Readiness check.
@@ -90,18 +91,18 @@ func (c *Client) requestURL(ctx context.Context) *url.URL {
 
 // PerformPrediction invokes performPrediction operation.
 //
-// Perform preidction.
+// Perform prediction.
 //
-// POST /api/v1/prediction
+// GET /api/v1/prediction
-func (c *Client) PerformPrediction(ctx context.Context, request OptPredictionParameters, params PerformPredictionParams) (*PredictionResult, error) {
+func (c *Client) PerformPrediction(ctx context.Context, params PerformPredictionParams) (*PredictionResult, error) {
-	res, err := c.sendPerformPrediction(ctx, request, params)
+	res, err := c.sendPerformPrediction(ctx, params)
 	return res, err
 }
 
-func (c *Client) sendPerformPrediction(ctx context.Context, request OptPredictionParameters, params PerformPredictionParams) (res *PredictionResult, err error) {
+func (c *Client) sendPerformPrediction(ctx context.Context, params PerformPredictionParams) (res *PredictionResult, err error) {
 	otelAttrs := []attribute.KeyValue{
 		otelogen.OperationID("performPrediction"),
-		semconv.HTTPRequestMethodKey.String("POST"),
+		semconv.HTTPRequestMethodKey.String("GET"),
 		semconv.HTTPRouteKey.String("/api/v1/prediction"),
 	}
 
@@ -141,16 +142,254 @@ func (c *Client) sendPerformPrediction(ctx context.Context, request OptPredictio
 	stage = "EncodeQueryParams"
 	q := uri.NewQueryEncoder()
 	{
-		// Encode "parameters" parameter.
+		// Encode "launch_latitude" parameter.
 		cfg := uri.QueryParameterEncodingConfig{
-			Name:    "parameters",
+			Name:    "launch_latitude",
 			Style:   uri.QueryStyleForm,
 			Explode: true,
 		}
 
 		if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
-			if val, ok := params.Parameters.Get(); ok {
+			if val, ok := params.LaunchLatitude.Get(); ok {
-				return val.EncodeURI(e)
+				return e.EncodeValue(conv.Float64ToString(val))
+			}
+			return nil
+		}); err != nil {
+			return res, errors.Wrap(err, "encode query")
+		}
+	}
+	{
+		// Encode "launch_longitude" parameter.
+		cfg := uri.QueryParameterEncodingConfig{
+			Name:    "launch_longitude",
+			Style:   uri.QueryStyleForm,
+			Explode: true,
+		}
+
+		if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
+			if val, ok := params.LaunchLongitude.Get(); ok {
+				return e.EncodeValue(conv.Float64ToString(val))
+			}
+			return nil
+		}); err != nil {
+			return res, errors.Wrap(err, "encode query")
+		}
+	}
+	{
+		// Encode "launch_datetime" parameter.
+		cfg := uri.QueryParameterEncodingConfig{
+			Name:    "launch_datetime",
+			Style:   uri.QueryStyleForm,
+			Explode: true,
+		}
+
+		if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
+			if val, ok := params.LaunchDatetime.Get(); ok {
+				return e.EncodeValue(conv.DateTimeToString(val))
+			}
+			return nil
+		}); err != nil {
+			return res, errors.Wrap(err, "encode query")
+		}
+	}
+	{
+		// Encode "launch_altitude" parameter.
+		cfg := uri.QueryParameterEncodingConfig{
+			Name:    "launch_altitude",
+			Style:   uri.QueryStyleForm,
+			Explode: true,
+		}
+
+		if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
+			if val, ok := params.LaunchAltitude.Get(); ok {
+				return e.EncodeValue(conv.Float64ToString(val))
+			}
+			return nil
+		}); err != nil {
+			return res, errors.Wrap(err, "encode query")
+		}
+	}
+	{
+		// Encode "profile" parameter.
+		cfg := uri.QueryParameterEncodingConfig{
+			Name:    "profile",
+			Style:   uri.QueryStyleForm,
+			Explode: true,
+		}
+
+		if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
+			if val, ok := params.Profile.Get(); ok {
+				return e.EncodeValue(conv.StringToString(string(val)))
+			}
+			return nil
+		}); err != nil {
+			return res, errors.Wrap(err, "encode query")
+		}
+	}
+	{
+		// Encode "ascent_rate" parameter.
+		cfg := uri.QueryParameterEncodingConfig{
+			Name:    "ascent_rate",
+			Style:   uri.QueryStyleForm,
+			Explode: true,
+		}
+
+		if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
+			if val, ok := params.AscentRate.Get(); ok {
+				return e.EncodeValue(conv.Float64ToString(val))
+			}
+			return nil
+		}); err != nil {
+			return res, errors.Wrap(err, "encode query")
+		}
+	}
+	{
+		// Encode "burst_altitude" parameter.
+		cfg := uri.QueryParameterEncodingConfig{
+			Name:    "burst_altitude",
+			Style:   uri.QueryStyleForm,
+			Explode: true,
+		}
+
+		if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
+			if val, ok := params.BurstAltitude.Get(); ok {
+				return e.EncodeValue(conv.Float64ToString(val))
+			}
+			return nil
+		}); err != nil {
+			return res, errors.Wrap(err, "encode query")
+		}
+	}
+	{
+		// Encode "descent_rate" parameter.
+		cfg := uri.QueryParameterEncodingConfig{
+			Name:    "descent_rate",
+			Style:   uri.QueryStyleForm,
+			Explode: true,
+		}
+
+		if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
+			if val, ok := params.DescentRate.Get(); ok {
+				return e.EncodeValue(conv.Float64ToString(val))
+			}
+			return nil
+		}); err != nil {
+			return res, errors.Wrap(err, "encode query")
+		}
+	}
+	{
+		// Encode "float_altitude" parameter.
+		cfg := uri.QueryParameterEncodingConfig{
+			Name:    "float_altitude",
+			Style:   uri.QueryStyleForm,
+			Explode: true,
+		}
+
+		if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
+			if val, ok := params.FloatAltitude.Get(); ok {
+				return e.EncodeValue(conv.Float64ToString(val))
+			}
+			return nil
+		}); err != nil {
+			return res, errors.Wrap(err, "encode query")
+		}
+	}
+	{
+		// Encode "stop_datetime" parameter.
+		cfg := uri.QueryParameterEncodingConfig{
+			Name:    "stop_datetime",
+			Style:   uri.QueryStyleForm,
+			Explode: true,
+		}
+
+		if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
+			if val, ok := params.StopDatetime.Get(); ok {
+				return e.EncodeValue(conv.DateTimeToString(val))
+			}
+			return nil
+		}); err != nil {
+			return res, errors.Wrap(err, "encode query")
+		}
+	}
+	{
+		// Encode "ascent_curve" parameter.
+		cfg := uri.QueryParameterEncodingConfig{
+			Name:    "ascent_curve",
+			Style:   uri.QueryStyleForm,
+			Explode: true,
+		}
+
+		if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
+			if val, ok := params.AscentCurve.Get(); ok {
+				return e.EncodeValue(conv.StringToString(val))
+			}
+			return nil
+		}); err != nil {
+			return res, errors.Wrap(err, "encode query")
+		}
+	}
+	{
+		// Encode "descent_curve" parameter.
+		cfg := uri.QueryParameterEncodingConfig{
+			Name:    "descent_curve",
+			Style:   uri.QueryStyleForm,
+			Explode: true,
+		}
+
+		if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
+			if val, ok := params.DescentCurve.Get(); ok {
+				return e.EncodeValue(conv.StringToString(val))
+			}
+			return nil
+		}); err != nil {
+			return res, errors.Wrap(err, "encode query")
+		}
+	}
+	{
+		// Encode "interpolate" parameter.
+		cfg := uri.QueryParameterEncodingConfig{
+			Name:    "interpolate",
+			Style:   uri.QueryStyleForm,
+			Explode: true,
+		}
+
+		if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
+			if val, ok := params.Interpolate.Get(); ok {
+				return e.EncodeValue(conv.BoolToString(val))
+			}
+			return nil
+		}); err != nil {
+			return res, errors.Wrap(err, "encode query")
+		}
+	}
+	{
+		// Encode "format" parameter.
+		cfg := uri.QueryParameterEncodingConfig{
+			Name:    "format",
+			Style:   uri.QueryStyleForm,
+			Explode: true,
+		}
+
+		if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
+			if val, ok := params.Format.Get(); ok {
+				return e.EncodeValue(conv.StringToString(string(val)))
+			}
+			return nil
+		}); err != nil {
+			return res, errors.Wrap(err, "encode query")
+		}
+	}
+	{
+		// Encode "dataset" parameter.
+		cfg := uri.QueryParameterEncodingConfig{
+			Name:    "dataset",
+			Style:   uri.QueryStyleForm,
+			Explode: true,
+		}
+
+		if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
+			if val, ok := params.Dataset.Get(); ok {
+				return e.EncodeValue(conv.DateTimeToString(val))
 			}
 			return nil
 		}); err != nil {
@@ -160,13 +399,10 @@ func (c *Client) sendPerformPrediction(ctx context.Context, request OptPredictio
 	u.RawQuery = q.Values().Encode()
 
 	stage = "EncodeRequest"
-	r, err := ht.NewRequest(ctx, "POST", u)
+	r, err := ht.NewRequest(ctx, "GET", u)
 	if err != nil {
 		return res, errors.Wrap(err, "create request")
 	}
-	if err := encodePerformPredictionRequest(request, r); err != nil {
-		return res, errors.Wrap(err, "encode request")
-	}
 
 	stage = "SendRequest"
 	resp, err := c.cfg.Client.Do(r)

pkg/rest/oas_defaults_gen.go

@@ -1,15 +0,0 @@
-// Code generated by ogen, DO NOT EDIT.
-
-package gsn
-
-// setDefaults set default value of fields.
-func (s *PredictionParameters) setDefaults() {
-	{
-		val := bool(false)
-		s.Interpolate.SetTo(val)
-	}
-	{
-		val := PredictionParametersFormat("json")
-		s.Format.SetTo(val)
-	}
-}

pkg/rest/oas_handlers_gen.go

@@ -32,15 +32,15 @@ func (c *codeRecorder) WriteHeader(status int) {
 
 // handlePerformPredictionRequest handles performPrediction operation.
 //
-// Perform preidction.
+// Perform prediction.
 //
-// POST /api/v1/prediction
+// GET /api/v1/prediction
 func (s *Server) handlePerformPredictionRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) {
 	statusWriter := &codeRecorder{ResponseWriter: w}
 	w = statusWriter
 	otelAttrs := []attribute.KeyValue{
 		otelogen.OperationID("performPrediction"),
-		semconv.HTTPRequestMethodKey.String("POST"),
+		semconv.HTTPRequestMethodKey.String("GET"),
 		semconv.HTTPRouteKey.String("/api/v1/prediction"),
 	}
 
@@ -114,41 +114,82 @@ func (s *Server) handlePerformPredictionRequest(args [0]string, argsEscaped bool
 		s.cfg.ErrorHandler(ctx, w, r, err)
 		return
 	}
-	request, close, err := s.decodePerformPredictionRequest(r)
-	if err != nil {
-		err = &ogenerrors.DecodeRequestError{
-			OperationContext: opErrContext,
-			Err:              err,
-		}
-		defer recordError("DecodeRequest", err)
-		s.cfg.ErrorHandler(ctx, w, r, err)
-		return
-	}
-	defer func() {
-		if err := close(); err != nil {
-			recordError("CloseRequest", err)
-		}
-	}()
 
 	var response *PredictionResult
 	if m := s.cfg.Middleware; m != nil {
 		mreq := middleware.Request{
 			Context:          ctx,
 			OperationName:    PerformPredictionOperation,
-			OperationSummary: "Perform preidction",
+			OperationSummary: "Perform prediction",
 			OperationID:      "performPrediction",
-			Body:             request,
+			Body:             nil,
 			Params: middleware.Parameters{
 				{
-					Name: "parameters",
+					Name: "launch_latitude",
 					In:   "query",
-				}: params.Parameters,
+				}: params.LaunchLatitude,
+				{
+					Name: "launch_longitude",
+					In:   "query",
+				}: params.LaunchLongitude,
+				{
+					Name: "launch_datetime",
+					In:   "query",
+				}: params.LaunchDatetime,
+				{
+					Name: "launch_altitude",
+					In:   "query",
+				}: params.LaunchAltitude,
+				{
+					Name: "profile",
+					In:   "query",
+				}: params.Profile,
+				{
+					Name: "ascent_rate",
+					In:   "query",
+				}: params.AscentRate,
+				{
+					Name: "burst_altitude",
+					In:   "query",
+				}: params.BurstAltitude,
+				{
+					Name: "descent_rate",
+					In:   "query",
+				}: params.DescentRate,
+				{
+					Name: "float_altitude",
+					In:   "query",
+				}: params.FloatAltitude,
+				{
+					Name: "stop_datetime",
+					In:   "query",
+				}: params.StopDatetime,
+				{
+					Name: "ascent_curve",
+					In:   "query",
+				}: params.AscentCurve,
+				{
+					Name: "descent_curve",
+					In:   "query",
+				}: params.DescentCurve,
+				{
+					Name: "interpolate",
+					In:   "query",
+				}: params.Interpolate,
+				{
+					Name: "format",
+					In:   "query",
+				}: params.Format,
+				{
+					Name: "dataset",
+					In:   "query",
+				}: params.Dataset,
 			},
 			Raw: r,
 		}
 
 		type (
-			Request  = OptPredictionParameters
+			Request  = struct{}
 			Params   = PerformPredictionParams
 			Response = *PredictionResult
 		)
@@ -161,12 +202,12 @@ func (s *Server) handlePerformPredictionRequest(args [0]string, argsEscaped bool
 			mreq,
 			unpackPerformPredictionParams,
 			func(ctx context.Context, request Request, params Params) (response Response, err error) {
-				response, err = s.h.PerformPrediction(ctx, request, params)
+				response, err = s.h.PerformPrediction(ctx, params)
 				return response, err
 			},
 		)
 	} else {
-		response, err = s.h.PerformPrediction(ctx, request, params)
+		response, err = s.h.PerformPrediction(ctx, params)
 	}
 	if err != nil {
 		if errRes, ok := errors.Into[*ErrorStatusCode](err); ok {

pkg/rest/oas_json_gen.go

@@ -197,140 +197,6 @@ func (s *OptDateTime) UnmarshalJSON(data []byte) error {
 	return s.Decode(d, json.DecodeDateTime)
 }
 
-// Encode encodes float64 as json.
-func (o OptFloat64) Encode(e *jx.Encoder) {
-	if !o.Set {
-		return
-	}
-	e.Float64(float64(o.Value))
-}
-
-// Decode decodes float64 from json.
-func (o *OptFloat64) Decode(d *jx.Decoder) error {
-	if o == nil {
-		return errors.New("invalid: unable to decode OptFloat64 to nil")
-	}
-	o.Set = true
-	v, err := d.Float64()
-	if err != nil {
-		return err
-	}
-	o.Value = float64(v)
-	return nil
-}
-
-// MarshalJSON implements stdjson.Marshaler.
-func (s OptFloat64) MarshalJSON() ([]byte, error) {
-	e := jx.Encoder{}
-	s.Encode(&e)
-	return e.Bytes(), nil
-}
-
-// UnmarshalJSON implements stdjson.Unmarshaler.
-func (s *OptFloat64) UnmarshalJSON(data []byte) error {
-	d := jx.DecodeBytes(data)
-	return s.Decode(d)
-}
-
-// Encode encodes PredictionParameters as json.
-func (o OptPredictionParameters) Encode(e *jx.Encoder) {
-	if !o.Set {
-		return
-	}
-	o.Value.Encode(e)
-}
-
-// Decode decodes PredictionParameters from json.
-func (o *OptPredictionParameters) Decode(d *jx.Decoder) error {
-	if o == nil {
-		return errors.New("invalid: unable to decode OptPredictionParameters to nil")
-	}
-	o.Set = true
-	if err := o.Value.Decode(d); err != nil {
-		return err
-	}
-	return nil
-}
-
-// MarshalJSON implements stdjson.Marshaler.
-func (s OptPredictionParameters) MarshalJSON() ([]byte, error) {
-	e := jx.Encoder{}
-	s.Encode(&e)
-	return e.Bytes(), nil
-}
-
-// UnmarshalJSON implements stdjson.Unmarshaler.
-func (s *OptPredictionParameters) UnmarshalJSON(data []byte) error {
-	d := jx.DecodeBytes(data)
-	return s.Decode(d)
-}
-
-// Encode encodes PredictionParametersFormat as json.
-func (o OptPredictionParametersFormat) Encode(e *jx.Encoder) {
-	if !o.Set {
-		return
-	}
-	e.Str(string(o.Value))
-}
-
-// Decode decodes PredictionParametersFormat from json.
-func (o *OptPredictionParametersFormat) Decode(d *jx.Decoder) error {
-	if o == nil {
-		return errors.New("invalid: unable to decode OptPredictionParametersFormat to nil")
-	}
-	o.Set = true
-	if err := o.Value.Decode(d); err != nil {
-		return err
-	}
-	return nil
-}
-
-// MarshalJSON implements stdjson.Marshaler.
-func (s OptPredictionParametersFormat) MarshalJSON() ([]byte, error) {
-	e := jx.Encoder{}
-	s.Encode(&e)
-	return e.Bytes(), nil
-}
-
-// UnmarshalJSON implements stdjson.Unmarshaler.
-func (s *OptPredictionParametersFormat) UnmarshalJSON(data []byte) error {
-	d := jx.DecodeBytes(data)
-	return s.Decode(d)
-}
-
-// Encode encodes PredictionParametersProfile as json.
-func (o OptPredictionParametersProfile) Encode(e *jx.Encoder) {
-	if !o.Set {
-		return
-	}
-	e.Str(string(o.Value))
-}
-
-// Decode decodes PredictionParametersProfile from json.
-func (o *OptPredictionParametersProfile) Decode(d *jx.Decoder) error {
-	if o == nil {
-		return errors.New("invalid: unable to decode OptPredictionParametersProfile to nil")
-	}
-	o.Set = true
-	if err := o.Value.Decode(d); err != nil {
-		return err
-	}
-	return nil
-}
-
-// MarshalJSON implements stdjson.Marshaler.
-func (s OptPredictionParametersProfile) MarshalJSON() ([]byte, error) {
-	e := jx.Encoder{}
-	s.Encode(&e)
-	return e.Bytes(), nil
-}
-
-// UnmarshalJSON implements stdjson.Unmarshaler.
-func (s *OptPredictionParametersProfile) UnmarshalJSON(data []byte) error {
-	d := jx.DecodeBytes(data)
-	return s.Decode(d)
-}
-
 // Encode encodes string as json.
 func (o OptString) Encode(e *jx.Encoder) {
 	if !o.Set {
@@ -366,390 +232,6 @@ func (s *OptString) UnmarshalJSON(data []byte) error {
 	return s.Decode(d)
 }
 
-// Encode implements json.Marshaler.
-func (s *PredictionParameters) Encode(e *jx.Encoder) {
-	e.ObjStart()
-	s.encodeFields(e)
-	e.ObjEnd()
-}
-
-// encodeFields encodes fields.
-func (s *PredictionParameters) encodeFields(e *jx.Encoder) {
-	{
-		if s.LaunchLatitude.Set {
-			e.FieldStart("launch_latitude")
-			s.LaunchLatitude.Encode(e)
-		}
-	}
-	{
-		if s.LaunchLongitude.Set {
-			e.FieldStart("launch_longitude")
-			s.LaunchLongitude.Encode(e)
-		}
-	}
-	{
-		if s.LaunchDatetime.Set {
-			e.FieldStart("launch_datetime")
-			s.LaunchDatetime.Encode(e, json.EncodeDateTime)
-		}
-	}
-	{
-		if s.LaunchAltitude.Set {
-			e.FieldStart("launch_altitude")
-			s.LaunchAltitude.Encode(e)
-		}
-	}
-	{
-		if s.Profile.Set {
-			e.FieldStart("profile")
-			s.Profile.Encode(e)
-		}
-	}
-	{
-		if s.AscentRate.Set {
-			e.FieldStart("ascent_rate")
-			s.AscentRate.Encode(e)
-		}
-	}
-	{
-		if s.BurstAltitude.Set {
-			e.FieldStart("burst_altitude")
-			s.BurstAltitude.Encode(e)
-		}
-	}
-	{
-		if s.DescentRate.Set {
-			e.FieldStart("descent_rate")
-			s.DescentRate.Encode(e)
-		}
-	}
-	{
-		if s.FloatAltitude.Set {
-			e.FieldStart("float_altitude")
-			s.FloatAltitude.Encode(e)
-		}
-	}
-	{
-		if s.StopDatetime.Set {
-			e.FieldStart("stop_datetime")
-			s.StopDatetime.Encode(e, json.EncodeDateTime)
-		}
-	}
-	{
-		if s.AscentCurve.Set {
-			e.FieldStart("ascent_curve")
-			s.AscentCurve.Encode(e)
-		}
-	}
-	{
-		if s.DescentCurve.Set {
-			e.FieldStart("descent_curve")
-			s.DescentCurve.Encode(e)
-		}
-	}
-	{
-		if s.Interpolate.Set {
-			e.FieldStart("interpolate")
-			s.Interpolate.Encode(e)
-		}
-	}
-	{
-		if s.Format.Set {
-			e.FieldStart("format")
-			s.Format.Encode(e)
-		}
-	}
-	{
-		if s.Dataset.Set {
-			e.FieldStart("dataset")
-			s.Dataset.Encode(e, json.EncodeDateTime)
-		}
-	}
-}
-
-var jsonFieldsNameOfPredictionParameters = [15]string{
-	0:  "launch_latitude",
-	1:  "launch_longitude",
-	2:  "launch_datetime",
-	3:  "launch_altitude",
-	4:  "profile",
-	5:  "ascent_rate",
-	6:  "burst_altitude",
-	7:  "descent_rate",
-	8:  "float_altitude",
-	9:  "stop_datetime",
-	10: "ascent_curve",
-	11: "descent_curve",
-	12: "interpolate",
-	13: "format",
-	14: "dataset",
-}
-
-// Decode decodes PredictionParameters from json.
-func (s *PredictionParameters) Decode(d *jx.Decoder) error {
-	if s == nil {
-		return errors.New("invalid: unable to decode PredictionParameters to nil")
-	}
-	s.setDefaults()
-
-	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
-		switch string(k) {
-		case "launch_latitude":
-			if err := func() error {
-				s.LaunchLatitude.Reset()
-				if err := s.LaunchLatitude.Decode(d); err != nil {
-					return err
-				}
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"launch_latitude\"")
-			}
-		case "launch_longitude":
-			if err := func() error {
-				s.LaunchLongitude.Reset()
-				if err := s.LaunchLongitude.Decode(d); err != nil {
-					return err
-				}
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"launch_longitude\"")
-			}
-		case "launch_datetime":
-			if err := func() error {
-				s.LaunchDatetime.Reset()
-				if err := s.LaunchDatetime.Decode(d, json.DecodeDateTime); err != nil {
-					return err
-				}
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"launch_datetime\"")
-			}
-		case "launch_altitude":
-			if err := func() error {
-				s.LaunchAltitude.Reset()
-				if err := s.LaunchAltitude.Decode(d); err != nil {
-					return err
-				}
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"launch_altitude\"")
-			}
-		case "profile":
-			if err := func() error {
-				s.Profile.Reset()
-				if err := s.Profile.Decode(d); err != nil {
-					return err
-				}
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"profile\"")
-			}
-		case "ascent_rate":
-			if err := func() error {
-				s.AscentRate.Reset()
-				if err := s.AscentRate.Decode(d); err != nil {
-					return err
-				}
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"ascent_rate\"")
-			}
-		case "burst_altitude":
-			if err := func() error {
-				s.BurstAltitude.Reset()
-				if err := s.BurstAltitude.Decode(d); err != nil {
-					return err
-				}
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"burst_altitude\"")
-			}
-		case "descent_rate":
-			if err := func() error {
-				s.DescentRate.Reset()
-				if err := s.DescentRate.Decode(d); err != nil {
-					return err
-				}
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"descent_rate\"")
-			}
-		case "float_altitude":
-			if err := func() error {
-				s.FloatAltitude.Reset()
-				if err := s.FloatAltitude.Decode(d); err != nil {
-					return err
-				}
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"float_altitude\"")
-			}
-		case "stop_datetime":
-			if err := func() error {
-				s.StopDatetime.Reset()
-				if err := s.StopDatetime.Decode(d, json.DecodeDateTime); err != nil {
-					return err
-				}
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"stop_datetime\"")
-			}
-		case "ascent_curve":
-			if err := func() error {
-				s.AscentCurve.Reset()
-				if err := s.AscentCurve.Decode(d); err != nil {
-					return err
-				}
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"ascent_curve\"")
-			}
-		case "descent_curve":
-			if err := func() error {
-				s.DescentCurve.Reset()
-				if err := s.DescentCurve.Decode(d); err != nil {
-					return err
-				}
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"descent_curve\"")
-			}
-		case "interpolate":
-			if err := func() error {
-				s.Interpolate.Reset()
-				if err := s.Interpolate.Decode(d); err != nil {
-					return err
-				}
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"interpolate\"")
-			}
-		case "format":
-			if err := func() error {
-				s.Format.Reset()
-				if err := s.Format.Decode(d); err != nil {
-					return err
-				}
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"format\"")
-			}
-		case "dataset":
-			if err := func() error {
-				s.Dataset.Reset()
-				if err := s.Dataset.Decode(d, json.DecodeDateTime); err != nil {
-					return err
-				}
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"dataset\"")
-			}
-		default:
-			return d.Skip()
-		}
-		return nil
-	}); err != nil {
-		return errors.Wrap(err, "decode PredictionParameters")
-	}
-
-	return nil
-}
-
-// MarshalJSON implements stdjson.Marshaler.
-func (s *PredictionParameters) MarshalJSON() ([]byte, error) {
-	e := jx.Encoder{}
-	s.Encode(&e)
-	return e.Bytes(), nil
-}
-
-// UnmarshalJSON implements stdjson.Unmarshaler.
-func (s *PredictionParameters) UnmarshalJSON(data []byte) error {
-	d := jx.DecodeBytes(data)
-	return s.Decode(d)
-}
-
-// Encode encodes PredictionParametersFormat as json.
-func (s PredictionParametersFormat) Encode(e *jx.Encoder) {
-	e.Str(string(s))
-}
-
-// Decode decodes PredictionParametersFormat from json.
-func (s *PredictionParametersFormat) Decode(d *jx.Decoder) error {
-	if s == nil {
-		return errors.New("invalid: unable to decode PredictionParametersFormat to nil")
-	}
-	v, err := d.StrBytes()
-	if err != nil {
-		return err
-	}
-	// Try to use constant string.
-	switch PredictionParametersFormat(v) {
-	case PredictionParametersFormatJSON:
-		*s = PredictionParametersFormatJSON
-	default:
-		*s = PredictionParametersFormat(v)
-	}
-
-	return nil
-}
-
-// MarshalJSON implements stdjson.Marshaler.
-func (s PredictionParametersFormat) MarshalJSON() ([]byte, error) {
-	e := jx.Encoder{}
-	s.Encode(&e)
-	return e.Bytes(), nil
-}
-
-// UnmarshalJSON implements stdjson.Unmarshaler.
-func (s *PredictionParametersFormat) UnmarshalJSON(data []byte) error {
-	d := jx.DecodeBytes(data)
-	return s.Decode(d)
-}
-
-// Encode encodes PredictionParametersProfile as json.
-func (s PredictionParametersProfile) Encode(e *jx.Encoder) {
-	e.Str(string(s))
-}
-
-// Decode decodes PredictionParametersProfile from json.
-func (s *PredictionParametersProfile) Decode(d *jx.Decoder) error {
-	if s == nil {
-		return errors.New("invalid: unable to decode PredictionParametersProfile to nil")
-	}
-	v, err := d.StrBytes()
-	if err != nil {
-		return err
-	}
-	// Try to use constant string.
-	switch PredictionParametersProfile(v) {
-	case PredictionParametersProfileStandardProfile:
-		*s = PredictionParametersProfileStandardProfile
-	case PredictionParametersProfileFloatProfile:
-		*s = PredictionParametersProfileFloatProfile
-	case PredictionParametersProfileReverseProfile:
-		*s = PredictionParametersProfileReverseProfile
-	case PredictionParametersProfileCustomProfile:
-		*s = PredictionParametersProfileCustomProfile
-	default:
-		*s = PredictionParametersProfile(v)
-	}
-
-	return nil
-}
-
-// MarshalJSON implements stdjson.Marshaler.
-func (s PredictionParametersProfile) MarshalJSON() ([]byte, error) {
-	e := jx.Encoder{}
-	s.Encode(&e)
-	return e.Bytes(), nil
-}
-
-// UnmarshalJSON implements stdjson.Unmarshaler.
-func (s *PredictionParametersProfile) UnmarshalJSON(data []byte) error {
-	d := jx.DecodeBytes(data)
-	return s.Decode(d)
-}
-
 // Encode implements json.Marshaler.
 func (s *PredictionResult) Encode(e *jx.Encoder) {
 	e.ObjStart()

pkg/rest/oas_parameters_gen.go

@@ -4,25 +4,170 @@ package gsn
 
 import (
 	"net/http"
+	"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"
 )
 
 // PerformPredictionParams is parameters of performPrediction operation.
 type PerformPredictionParams struct {
-	Parameters OptPredictionParameters
+	LaunchLatitude  OptFloat64
+	LaunchLongitude OptFloat64
+	LaunchDatetime  OptDateTime
+	LaunchAltitude  OptFloat64
+	Profile         OptPerformPredictionProfile
+	AscentRate      OptFloat64
+	BurstAltitude   OptFloat64
+	DescentRate     OptFloat64
+	FloatAltitude   OptFloat64
+	StopDatetime    OptDateTime
+	AscentCurve     OptString
+	DescentCurve    OptString
+	Interpolate     OptBool
+	Format          OptPerformPredictionFormat
+	Dataset         OptDateTime
 }
 
 func unpackPerformPredictionParams(packed middleware.Parameters) (params PerformPredictionParams) {
 	{
 		key := middleware.ParameterKey{
-			Name: "parameters",
+			Name: "launch_latitude",
 			In:   "query",
 		}
 		if v, ok := packed[key]; ok {
-			params.Parameters = v.(OptPredictionParameters)
+			params.LaunchLatitude = v.(OptFloat64)
+		}
+	}
+	{
+		key := middleware.ParameterKey{
+			Name: "launch_longitude",
+			In:   "query",
+		}
+		if v, ok := packed[key]; ok {
+			params.LaunchLongitude = v.(OptFloat64)
+		}
+	}
+	{
+		key := middleware.ParameterKey{
+			Name: "launch_datetime",
+			In:   "query",
+		}
+		if v, ok := packed[key]; ok {
+			params.LaunchDatetime = v.(OptDateTime)
+		}
+	}
+	{
+		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: "ascent_curve",
+			In:   "query",
+		}
+		if v, ok := packed[key]; ok {
+			params.AscentCurve = v.(OptString)
+		}
+	}
+	{
+		key := middleware.ParameterKey{
+			Name: "descent_curve",
+			In:   "query",
+		}
+		if v, ok := packed[key]; ok {
+			params.DescentCurve = v.(OptString)
+		}
+	}
+	{
+		key := middleware.ParameterKey{
+			Name: "interpolate",
+			In:   "query",
+		}
+		if v, ok := packed[key]; ok {
+			params.Interpolate = v.(OptBool)
+		}
+	}
+	{
+		key := middleware.ParameterKey{
+			Name: "format",
+			In:   "query",
+		}
+		if v, ok := packed[key]; ok {
+			params.Format = v.(OptPerformPredictionFormat)
+		}
+	}
+	{
+		key := middleware.ParameterKey{
+			Name: "dataset",
+			In:   "query",
+		}
+		if v, ok := packed[key]; ok {
+			params.Dataset = v.(OptDateTime)
 		}
 	}
 	return params
@@ -30,30 +175,249 @@ func unpackPerformPredictionParams(packed middleware.Parameters) (params Perform
 
 func decodePerformPredictionParams(args [0]string, argsEscaped bool, r *http.Request) (params PerformPredictionParams, _ error) {
 	q := uri.NewQueryDecoder(r.URL.Query())
-	// Decode query: parameters.
+	// Decode query: launch_latitude.
 	if err := func() error {
 		cfg := uri.QueryParameterDecodingConfig{
-			Name:    "parameters",
+			Name:    "launch_latitude",
 			Style:   uri.QueryStyleForm,
 			Explode: true,
-			Fields:  []uri.QueryParameterObjectField{{Name: "launch_latitude", Required: false}, {Name: "launch_longitude", Required: false}, {Name: "launch_datetime", Required: false}, {Name: "launch_altitude", Required: false}, {Name: "profile", Required: false}, {Name: "ascent_rate", Required: false}, {Name: "burst_altitude", Required: false}, {Name: "descent_rate", Required: false}, {Name: "float_altitude", Required: false}, {Name: "stop_datetime", Required: false}, {Name: "ascent_curve", Required: false}, {Name: "descent_curve", Required: false}, {Name: "interpolate", Required: false}, {Name: "format", Required: false}, {Name: "dataset", Required: false}},
 		}
 
 		if err := q.HasParam(cfg); err == nil {
 			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
-				var paramsDotParametersVal PredictionParameters
+				var paramsDotLaunchLatitudeVal float64
 				if err := func() error {
-					return paramsDotParametersVal.DecodeURI(d)
+					val, err := d.DecodeValue()
+					if err != nil {
+						return err
+					}
+
+					c, err := conv.ToFloat64(val)
+					if err != nil {
+						return err
+					}
+
+					paramsDotLaunchLatitudeVal = c
+					return nil
 				}(); err != nil {
 					return err
 				}
-				params.Parameters.SetTo(paramsDotParametersVal)
+				params.LaunchLatitude.SetTo(paramsDotLaunchLatitudeVal)
 				return nil
 			}); err != nil {
 				return err
 			}
 			if err := func() error {
-				if value, ok := params.Parameters.Get(); ok {
+				if value, ok := params.LaunchLatitude.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_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 {
+				var paramsDotLaunchLongitudeVal float64
+				if err := func() error {
+					val, err := d.DecodeValue()
+					if err != nil {
+						return err
+					}
+
+					c, err := conv.ToFloat64(val)
+					if err != nil {
+						return err
+					}
+
+					paramsDotLaunchLongitudeVal = c
+					return nil
+				}(); err != nil {
+					return err
+				}
+				params.LaunchLongitude.SetTo(paramsDotLaunchLongitudeVal)
+				return nil
+			}); err != nil {
+				return err
+			}
+			if err := func() error {
+				if value, ok := params.LaunchLongitude.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_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 {
+				var paramsDotLaunchDatetimeVal 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
+					}
+
+					paramsDotLaunchDatetimeVal = c
+					return nil
+				}(); err != nil {
+					return err
+				}
+				params.LaunchDatetime.SetTo(paramsDotLaunchDatetimeVal)
+				return nil
+			}); err != nil {
+				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,
+		}
+	}
+	// 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
@@ -71,7 +435,492 @@ func decodePerformPredictionParams(args [0]string, argsEscaped bool, r *http.Req
 		return nil
 	}(); err != nil {
 		return params, &ogenerrors.DecodeParamError{
-			Name: "parameters",
+			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: ascent_curve.
+	if err := func() error {
+		cfg := uri.QueryParameterDecodingConfig{
+			Name:    "ascent_curve",
+			Style:   uri.QueryStyleForm,
+			Explode: true,
+		}
+
+		if err := q.HasParam(cfg); err == nil {
+			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
+				var paramsDotAscentCurveVal string
+				if err := func() error {
+					val, err := d.DecodeValue()
+					if err != nil {
+						return err
+					}
+
+					c, err := conv.ToString(val)
+					if err != nil {
+						return err
+					}
+
+					paramsDotAscentCurveVal = c
+					return nil
+				}(); err != nil {
+					return err
+				}
+				params.AscentCurve.SetTo(paramsDotAscentCurveVal)
+				return nil
+			}); err != nil {
+				return err
+			}
+		}
+		return nil
+	}(); err != nil {
+		return params, &ogenerrors.DecodeParamError{
+			Name: "ascent_curve",
+			In:   "query",
+			Err:  err,
+		}
+	}
+	// Decode query: descent_curve.
+	if err := func() error {
+		cfg := uri.QueryParameterDecodingConfig{
+			Name:    "descent_curve",
+			Style:   uri.QueryStyleForm,
+			Explode: true,
+		}
+
+		if err := q.HasParam(cfg); err == nil {
+			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
+				var paramsDotDescentCurveVal string
+				if err := func() error {
+					val, err := d.DecodeValue()
+					if err != nil {
+						return err
+					}
+
+					c, err := conv.ToString(val)
+					if err != nil {
+						return err
+					}
+
+					paramsDotDescentCurveVal = c
+					return nil
+				}(); err != nil {
+					return err
+				}
+				params.DescentCurve.SetTo(paramsDotDescentCurveVal)
+				return nil
+			}); err != nil {
+				return err
+			}
+		}
+		return nil
+	}(); err != nil {
+		return params, &ogenerrors.DecodeParamError{
+			Name: "descent_curve",
+			In:   "query",
+			Err:  err,
+		}
+	}
+	// Decode query: interpolate.
+	if err := func() error {
+		cfg := uri.QueryParameterDecodingConfig{
+			Name:    "interpolate",
+			Style:   uri.QueryStyleForm,
+			Explode: true,
+		}
+
+		if err := q.HasParam(cfg); err == nil {
+			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
+				var paramsDotInterpolateVal bool
+				if err := func() error {
+					val, err := d.DecodeValue()
+					if err != nil {
+						return err
+					}
+
+					c, err := conv.ToBool(val)
+					if err != nil {
+						return err
+					}
+
+					paramsDotInterpolateVal = c
+					return nil
+				}(); err != nil {
+					return err
+				}
+				params.Interpolate.SetTo(paramsDotInterpolateVal)
+				return nil
+			}); err != nil {
+				return err
+			}
+		}
+		return nil
+	}(); err != nil {
+		return params, &ogenerrors.DecodeParamError{
+			Name: "interpolate",
+			In:   "query",
+			Err:  err,
+		}
+	}
+	// Decode query: format.
+	if err := func() error {
+		cfg := uri.QueryParameterDecodingConfig{
+			Name:    "format",
+			Style:   uri.QueryStyleForm,
+			Explode: true,
+		}
+
+		if err := q.HasParam(cfg); err == nil {
+			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
+				var paramsDotFormatVal PerformPredictionFormat
+				if err := func() error {
+					val, err := d.DecodeValue()
+					if err != nil {
+						return err
+					}
+
+					c, err := conv.ToString(val)
+					if err != nil {
+						return err
+					}
+
+					paramsDotFormatVal = PerformPredictionFormat(c)
+					return nil
+				}(); err != nil {
+					return err
+				}
+				params.Format.SetTo(paramsDotFormatVal)
+				return nil
+			}); err != nil {
+				return err
+			}
+			if err := func() error {
+				if value, ok := params.Format.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: "format",
+			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,
 		}

pkg/rest/oas_request_decoders_gen.go

@@ -1,97 +1,3 @@
 // Code generated by ogen, DO NOT EDIT.
 
 package gsn
-
-import (
-	"io"
-	"mime"
-	"net/http"
-
-	"github.com/go-faster/errors"
-	"github.com/go-faster/jx"
-
-	"github.com/ogen-go/ogen/ogenerrors"
-	"github.com/ogen-go/ogen/validate"
-)
-
-func (s *Server) decodePerformPredictionRequest(r *http.Request) (
-	req OptPredictionParameters,
-	close func() error,
-	rerr error,
-) {
-	var closers []func() error
-	close = func() error {
-		var merr error
-		// Close in reverse order, to match defer behavior.
-		for i := len(closers) - 1; i >= 0; i-- {
-			c := closers[i]
-			merr = errors.Join(merr, c())
-		}
-		return merr
-	}
-	defer func() {
-		if rerr != nil {
-			rerr = errors.Join(rerr, close())
-		}
-	}()
-	if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 {
-		return req, close, nil
-	}
-	ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
-	if err != nil {
-		return req, close, errors.Wrap(err, "parse media type")
-	}
-	switch {
-	case ct == "application/json":
-		if r.ContentLength == 0 {
-			return req, close, nil
-		}
-		buf, err := io.ReadAll(r.Body)
-		if err != nil {
-			return req, close, err
-		}
-
-		if len(buf) == 0 {
-			return req, close, nil
-		}
-
-		d := jx.DecodeBytes(buf)
-
-		var request OptPredictionParameters
-		if err := func() error {
-			request.Reset()
-			if err := request.Decode(d); err != nil {
-				return err
-			}
-			if err := d.Skip(); err != io.EOF {
-				return errors.New("unexpected trailing data")
-			}
-			return nil
-		}(); err != nil {
-			err = &ogenerrors.DecodeBodyError{
-				ContentType: ct,
-				Body:        buf,
-				Err:         err,
-			}
-			return req, close, err
-		}
-		if err := func() error {
-			if value, ok := request.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 req, close, errors.Wrap(err, "validate")
-		}
-		return request, close, nil
-	default:
-		return req, close, validate.InvalidContentType(ct)
-	}
-}

pkg/rest/oas_request_encoders_gen.go

@@ -1,32 +1,3 @@
 // Code generated by ogen, DO NOT EDIT.
 
 package gsn
-
-import (
-	"bytes"
-	"net/http"
-
-	"github.com/go-faster/jx"
-
-	ht "github.com/ogen-go/ogen/http"
-)
-
-func encodePerformPredictionRequest(
-	req OptPredictionParameters,
-	r *http.Request,
-) error {
-	const contentType = "application/json"
-	if !req.Set {
-		// Keep request with empty body if value is not set.
-		return nil
-	}
-	e := new(jx.Encoder)
-	{
-		if req.Set {
-			req.Encode(e)
-		}
-	}
-	encoded := e.Bytes()
-	ht.SetBody(r, bytes.NewReader(encoded), contentType)
-	return nil
-}

pkg/rest/oas_router_gen.go

@@ -71,10 +71,10 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 				if len(elem) == 0 {
 					// Leaf node.
 					switch r.Method {
-					case "POST":
+					case "GET":
 						s.handlePerformPredictionRequest([0]string{}, elemIsEscaped, w, r)
 					default:
-						s.notAllowed(w, r, "POST")
+						s.notAllowed(w, r, "GET")
 					}
 
 					return
@@ -205,9 +205,9 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) {
 				if len(elem) == 0 {
 					// Leaf node.
 					switch method {
-					case "POST":
+					case "GET":
 						r.name = PerformPredictionOperation
-						r.summary = "Perform preidction"
+						r.summary = "Perform prediction"
 						r.operationID = "performPrediction"
 						r.pathPattern = "/api/v1/prediction"
 						r.args = args

pkg/rest/oas_schemas_gen.go

@@ -203,38 +203,38 @@ func (o OptFloat64) Or(d float64) float64 {
 	return d
 }
 
-// NewOptPredictionParameters returns new OptPredictionParameters with value set to v.
+// NewOptPerformPredictionFormat returns new OptPerformPredictionFormat with value set to v.
-func NewOptPredictionParameters(v PredictionParameters) OptPredictionParameters {
+func NewOptPerformPredictionFormat(v PerformPredictionFormat) OptPerformPredictionFormat {
-	return OptPredictionParameters{
+	return OptPerformPredictionFormat{
 		Value: v,
 		Set:   true,
 	}
 }
 
-// OptPredictionParameters is optional PredictionParameters.
+// OptPerformPredictionFormat is optional PerformPredictionFormat.
-type OptPredictionParameters struct {
+type OptPerformPredictionFormat struct {
-	Value PredictionParameters
+	Value PerformPredictionFormat
 	Set   bool
 }
 
-// IsSet returns true if OptPredictionParameters was set.
+// IsSet returns true if OptPerformPredictionFormat was set.
-func (o OptPredictionParameters) IsSet() bool { return o.Set }
+func (o OptPerformPredictionFormat) IsSet() bool { return o.Set }
 
 // Reset unsets value.
-func (o *OptPredictionParameters) Reset() {
+func (o *OptPerformPredictionFormat) Reset() {
-	var v PredictionParameters
+	var v PerformPredictionFormat
 	o.Value = v
 	o.Set = false
 }
 
 // SetTo sets value to v.
-func (o *OptPredictionParameters) SetTo(v PredictionParameters) {
+func (o *OptPerformPredictionFormat) SetTo(v PerformPredictionFormat) {
 	o.Set = true
 	o.Value = v
 }
 
 // Get returns value and boolean that denotes whether value was set.
-func (o OptPredictionParameters) Get() (v PredictionParameters, ok bool) {
+func (o OptPerformPredictionFormat) Get() (v PerformPredictionFormat, ok bool) {
 	if !o.Set {
 		return v, false
 	}
@@ -242,45 +242,45 @@ func (o OptPredictionParameters) Get() (v PredictionParameters, ok bool) {
 }
 
 // Or returns value if set, or given parameter if does not.
-func (o OptPredictionParameters) Or(d PredictionParameters) PredictionParameters {
+func (o OptPerformPredictionFormat) Or(d PerformPredictionFormat) PerformPredictionFormat {
 	if v, ok := o.Get(); ok {
 		return v
 	}
 	return d
 }
 
-// NewOptPredictionParametersFormat returns new OptPredictionParametersFormat with value set to v.
+// NewOptPerformPredictionProfile returns new OptPerformPredictionProfile with value set to v.
-func NewOptPredictionParametersFormat(v PredictionParametersFormat) OptPredictionParametersFormat {
+func NewOptPerformPredictionProfile(v PerformPredictionProfile) OptPerformPredictionProfile {
-	return OptPredictionParametersFormat{
+	return OptPerformPredictionProfile{
 		Value: v,
 		Set:   true,
 	}
 }
 
-// OptPredictionParametersFormat is optional PredictionParametersFormat.
+// OptPerformPredictionProfile is optional PerformPredictionProfile.
-type OptPredictionParametersFormat struct {
+type OptPerformPredictionProfile struct {
-	Value PredictionParametersFormat
+	Value PerformPredictionProfile
 	Set   bool
 }
 
-// IsSet returns true if OptPredictionParametersFormat was set.
+// IsSet returns true if OptPerformPredictionProfile was set.
-func (o OptPredictionParametersFormat) IsSet() bool { return o.Set }
+func (o OptPerformPredictionProfile) IsSet() bool { return o.Set }
 
 // Reset unsets value.
-func (o *OptPredictionParametersFormat) Reset() {
+func (o *OptPerformPredictionProfile) Reset() {
-	var v PredictionParametersFormat
+	var v PerformPredictionProfile
 	o.Value = v
 	o.Set = false
 }
 
 // SetTo sets value to v.
-func (o *OptPredictionParametersFormat) SetTo(v PredictionParametersFormat) {
+func (o *OptPerformPredictionProfile) SetTo(v PerformPredictionProfile) {
 	o.Set = true
 	o.Value = v
 }
 
 // Get returns value and boolean that denotes whether value was set.
-func (o OptPredictionParametersFormat) Get() (v PredictionParametersFormat, ok bool) {
+func (o OptPerformPredictionProfile) Get() (v PerformPredictionProfile, ok bool) {
 	if !o.Set {
 		return v, false
 	}
@@ -288,53 +288,7 @@ func (o OptPredictionParametersFormat) Get() (v PredictionParametersFormat, ok b
 }
 
 // Or returns value if set, or given parameter if does not.
-func (o OptPredictionParametersFormat) Or(d PredictionParametersFormat) PredictionParametersFormat {
+func (o OptPerformPredictionProfile) Or(d PerformPredictionProfile) PerformPredictionProfile {
-	if v, ok := o.Get(); ok {
-		return v
-	}
-	return d
-}
-
-// NewOptPredictionParametersProfile returns new OptPredictionParametersProfile with value set to v.
-func NewOptPredictionParametersProfile(v PredictionParametersProfile) OptPredictionParametersProfile {
-	return OptPredictionParametersProfile{
-		Value: v,
-		Set:   true,
-	}
-}
-
-// OptPredictionParametersProfile is optional PredictionParametersProfile.
-type OptPredictionParametersProfile struct {
-	Value PredictionParametersProfile
-	Set   bool
-}
-
-// IsSet returns true if OptPredictionParametersProfile was set.
-func (o OptPredictionParametersProfile) IsSet() bool { return o.Set }
-
-// Reset unsets value.
-func (o *OptPredictionParametersProfile) Reset() {
-	var v PredictionParametersProfile
-	o.Value = v
-	o.Set = false
-}
-
-// SetTo sets value to v.
-func (o *OptPredictionParametersProfile) SetTo(v PredictionParametersProfile) {
-	o.Set = true
-	o.Value = v
-}
-
-// Get returns value and boolean that denotes whether value was set.
-func (o OptPredictionParametersProfile) Get() (v PredictionParametersProfile, ok bool) {
-	if !o.Set {
-		return v, false
-	}
-	return o.Value, true
-}
-
-// Or returns value if set, or given parameter if does not.
-func (o OptPredictionParametersProfile) Or(d PredictionParametersProfile) PredictionParametersProfile {
 	if v, ok := o.Get(); ok {
 		return v
 	}
@@ -387,194 +341,23 @@ func (o OptString) Or(d string) string {
 	return d
 }
 
-// Ref: #/components/schemas/PredictionParameters
+type PerformPredictionFormat string
-type PredictionParameters struct {
-	LaunchLatitude  OptFloat64                     `json:"launch_latitude"`
-	LaunchLongitude OptFloat64                     `json:"launch_longitude"`
-	LaunchDatetime  OptDateTime                    `json:"launch_datetime"`
-	LaunchAltitude  OptFloat64                     `json:"launch_altitude"`
-	Profile         OptPredictionParametersProfile `json:"profile"`
-	AscentRate      OptFloat64                     `json:"ascent_rate"`
-	BurstAltitude   OptFloat64                     `json:"burst_altitude"`
-	DescentRate     OptFloat64                     `json:"descent_rate"`
-	FloatAltitude   OptFloat64                     `json:"float_altitude"`
-	StopDatetime    OptDateTime                    `json:"stop_datetime"`
-	// Base64 encoded ascent curve.
-	AscentCurve OptString `json:"ascent_curve"`
-	// Base64 encoded descent curve.
-	DescentCurve OptString                     `json:"descent_curve"`
-	Interpolate  OptBool                       `json:"interpolate"`
-	Format       OptPredictionParametersFormat `json:"format"`
-	Dataset      OptDateTime                   `json:"dataset"`
-}
-
-// GetLaunchLatitude returns the value of LaunchLatitude.
-func (s *PredictionParameters) GetLaunchLatitude() OptFloat64 {
-	return s.LaunchLatitude
-}
-
-// GetLaunchLongitude returns the value of LaunchLongitude.
-func (s *PredictionParameters) GetLaunchLongitude() OptFloat64 {
-	return s.LaunchLongitude
-}
-
-// GetLaunchDatetime returns the value of LaunchDatetime.
-func (s *PredictionParameters) GetLaunchDatetime() OptDateTime {
-	return s.LaunchDatetime
-}
-
-// GetLaunchAltitude returns the value of LaunchAltitude.
-func (s *PredictionParameters) GetLaunchAltitude() OptFloat64 {
-	return s.LaunchAltitude
-}
-
-// GetProfile returns the value of Profile.
-func (s *PredictionParameters) GetProfile() OptPredictionParametersProfile {
-	return s.Profile
-}
-
-// GetAscentRate returns the value of AscentRate.
-func (s *PredictionParameters) GetAscentRate() OptFloat64 {
-	return s.AscentRate
-}
-
-// GetBurstAltitude returns the value of BurstAltitude.
-func (s *PredictionParameters) GetBurstAltitude() OptFloat64 {
-	return s.BurstAltitude
-}
-
-// GetDescentRate returns the value of DescentRate.
-func (s *PredictionParameters) GetDescentRate() OptFloat64 {
-	return s.DescentRate
-}
-
-// GetFloatAltitude returns the value of FloatAltitude.
-func (s *PredictionParameters) GetFloatAltitude() OptFloat64 {
-	return s.FloatAltitude
-}
-
-// GetStopDatetime returns the value of StopDatetime.
-func (s *PredictionParameters) GetStopDatetime() OptDateTime {
-	return s.StopDatetime
-}
-
-// GetAscentCurve returns the value of AscentCurve.
-func (s *PredictionParameters) GetAscentCurve() OptString {
-	return s.AscentCurve
-}
-
-// GetDescentCurve returns the value of DescentCurve.
-func (s *PredictionParameters) GetDescentCurve() OptString {
-	return s.DescentCurve
-}
-
-// GetInterpolate returns the value of Interpolate.
-func (s *PredictionParameters) GetInterpolate() OptBool {
-	return s.Interpolate
-}
-
-// GetFormat returns the value of Format.
-func (s *PredictionParameters) GetFormat() OptPredictionParametersFormat {
-	return s.Format
-}
-
-// GetDataset returns the value of Dataset.
-func (s *PredictionParameters) GetDataset() OptDateTime {
-	return s.Dataset
-}
-
-// SetLaunchLatitude sets the value of LaunchLatitude.
-func (s *PredictionParameters) SetLaunchLatitude(val OptFloat64) {
-	s.LaunchLatitude = val
-}
-
-// SetLaunchLongitude sets the value of LaunchLongitude.
-func (s *PredictionParameters) SetLaunchLongitude(val OptFloat64) {
-	s.LaunchLongitude = val
-}
-
-// SetLaunchDatetime sets the value of LaunchDatetime.
-func (s *PredictionParameters) SetLaunchDatetime(val OptDateTime) {
-	s.LaunchDatetime = val
-}
-
-// SetLaunchAltitude sets the value of LaunchAltitude.
-func (s *PredictionParameters) SetLaunchAltitude(val OptFloat64) {
-	s.LaunchAltitude = val
-}
-
-// SetProfile sets the value of Profile.
-func (s *PredictionParameters) SetProfile(val OptPredictionParametersProfile) {
-	s.Profile = val
-}
-
-// SetAscentRate sets the value of AscentRate.
-func (s *PredictionParameters) SetAscentRate(val OptFloat64) {
-	s.AscentRate = val
-}
-
-// SetBurstAltitude sets the value of BurstAltitude.
-func (s *PredictionParameters) SetBurstAltitude(val OptFloat64) {
-	s.BurstAltitude = val
-}
-
-// SetDescentRate sets the value of DescentRate.
-func (s *PredictionParameters) SetDescentRate(val OptFloat64) {
-	s.DescentRate = val
-}
-
-// SetFloatAltitude sets the value of FloatAltitude.
-func (s *PredictionParameters) SetFloatAltitude(val OptFloat64) {
-	s.FloatAltitude = val
-}
-
-// SetStopDatetime sets the value of StopDatetime.
-func (s *PredictionParameters) SetStopDatetime(val OptDateTime) {
-	s.StopDatetime = val
-}
-
-// SetAscentCurve sets the value of AscentCurve.
-func (s *PredictionParameters) SetAscentCurve(val OptString) {
-	s.AscentCurve = val
-}
-
-// SetDescentCurve sets the value of DescentCurve.
-func (s *PredictionParameters) SetDescentCurve(val OptString) {
-	s.DescentCurve = val
-}
-
-// SetInterpolate sets the value of Interpolate.
-func (s *PredictionParameters) SetInterpolate(val OptBool) {
-	s.Interpolate = val
-}
-
-// SetFormat sets the value of Format.
-func (s *PredictionParameters) SetFormat(val OptPredictionParametersFormat) {
-	s.Format = val
-}
-
-// SetDataset sets the value of Dataset.
-func (s *PredictionParameters) SetDataset(val OptDateTime) {
-	s.Dataset = val
-}
-
-type PredictionParametersFormat string
 
 const (
-	PredictionParametersFormatJSON PredictionParametersFormat = "json"
+	PerformPredictionFormatJSON PerformPredictionFormat = "json"
 )
 
-// AllValues returns all PredictionParametersFormat values.
+// AllValues returns all PerformPredictionFormat values.
-func (PredictionParametersFormat) AllValues() []PredictionParametersFormat {
+func (PerformPredictionFormat) AllValues() []PerformPredictionFormat {
-	return []PredictionParametersFormat{
+	return []PerformPredictionFormat{
-		PredictionParametersFormatJSON,
+		PerformPredictionFormatJSON,
 	}
 }
 
 // MarshalText implements encoding.TextMarshaler.
-func (s PredictionParametersFormat) MarshalText() ([]byte, error) {
+func (s PerformPredictionFormat) MarshalText() ([]byte, error) {
 	switch s {
-	case PredictionParametersFormatJSON:
+	case PerformPredictionFormatJSON:
 		return []byte(s), nil
 	default:
 		return nil, errors.Errorf("invalid value: %q", s)
@@ -582,45 +365,45 @@ func (s PredictionParametersFormat) MarshalText() ([]byte, error) {
 }
 
 // UnmarshalText implements encoding.TextUnmarshaler.
-func (s *PredictionParametersFormat) UnmarshalText(data []byte) error {
+func (s *PerformPredictionFormat) UnmarshalText(data []byte) error {
-	switch PredictionParametersFormat(data) {
+	switch PerformPredictionFormat(data) {
-	case PredictionParametersFormatJSON:
+	case PerformPredictionFormatJSON:
-		*s = PredictionParametersFormatJSON
+		*s = PerformPredictionFormatJSON
 		return nil
 	default:
 		return errors.Errorf("invalid value: %q", data)
 	}
 }
 
-type PredictionParametersProfile string
+type PerformPredictionProfile string
 
 const (
-	PredictionParametersProfileStandardProfile PredictionParametersProfile = "standard_profile"
+	PerformPredictionProfileStandardProfile PerformPredictionProfile = "standard_profile"
-	PredictionParametersProfileFloatProfile    PredictionParametersProfile = "float_profile"
+	PerformPredictionProfileFloatProfile    PerformPredictionProfile = "float_profile"
-	PredictionParametersProfileReverseProfile  PredictionParametersProfile = "reverse_profile"
+	PerformPredictionProfileReverseProfile  PerformPredictionProfile = "reverse_profile"
-	PredictionParametersProfileCustomProfile   PredictionParametersProfile = "custom_profile"
+	PerformPredictionProfileCustomProfile   PerformPredictionProfile = "custom_profile"
 )
 
-// AllValues returns all PredictionParametersProfile values.
+// AllValues returns all PerformPredictionProfile values.
-func (PredictionParametersProfile) AllValues() []PredictionParametersProfile {
+func (PerformPredictionProfile) AllValues() []PerformPredictionProfile {
-	return []PredictionParametersProfile{
+	return []PerformPredictionProfile{
-		PredictionParametersProfileStandardProfile,
+		PerformPredictionProfileStandardProfile,
-		PredictionParametersProfileFloatProfile,
+		PerformPredictionProfileFloatProfile,
-		PredictionParametersProfileReverseProfile,
+		PerformPredictionProfileReverseProfile,
-		PredictionParametersProfileCustomProfile,
+		PerformPredictionProfileCustomProfile,
 	}
 }
 
 // MarshalText implements encoding.TextMarshaler.
-func (s PredictionParametersProfile) MarshalText() ([]byte, error) {
+func (s PerformPredictionProfile) MarshalText() ([]byte, error) {
 	switch s {
-	case PredictionParametersProfileStandardProfile:
+	case PerformPredictionProfileStandardProfile:
 		return []byte(s), nil
-	case PredictionParametersProfileFloatProfile:
+	case PerformPredictionProfileFloatProfile:
 		return []byte(s), nil
-	case PredictionParametersProfileReverseProfile:
+	case PerformPredictionProfileReverseProfile:
 		return []byte(s), nil
-	case PredictionParametersProfileCustomProfile:
+	case PerformPredictionProfileCustomProfile:
 		return []byte(s), nil
 	default:
 		return nil, errors.Errorf("invalid value: %q", s)
@@ -628,19 +411,19 @@ func (s PredictionParametersProfile) MarshalText() ([]byte, error) {
 }
 
 // UnmarshalText implements encoding.TextUnmarshaler.
-func (s *PredictionParametersProfile) UnmarshalText(data []byte) error {
+func (s *PerformPredictionProfile) UnmarshalText(data []byte) error {
-	switch PredictionParametersProfile(data) {
+	switch PerformPredictionProfile(data) {
-	case PredictionParametersProfileStandardProfile:
+	case PerformPredictionProfileStandardProfile:
-		*s = PredictionParametersProfileStandardProfile
+		*s = PerformPredictionProfileStandardProfile
 		return nil
-	case PredictionParametersProfileFloatProfile:
+	case PerformPredictionProfileFloatProfile:
-		*s = PredictionParametersProfileFloatProfile
+		*s = PerformPredictionProfileFloatProfile
 		return nil
-	case PredictionParametersProfileReverseProfile:
+	case PerformPredictionProfileReverseProfile:
-		*s = PredictionParametersProfileReverseProfile
+		*s = PerformPredictionProfileReverseProfile
 		return nil
-	case PredictionParametersProfileCustomProfile:
+	case PerformPredictionProfileCustomProfile:
-		*s = PredictionParametersProfileCustomProfile
+		*s = PerformPredictionProfileCustomProfile
 		return nil
 	default:
 		return errors.Errorf("invalid value: %q", data)

pkg/rest/oas_server_gen.go

@@ -10,10 +10,10 @@ import (
 type Handler interface {
 	// PerformPrediction implements performPrediction operation.
 	//
-	// Perform preidction.
+	// Perform prediction.
 	//
-	// POST /api/v1/prediction
+	// GET /api/v1/prediction
-	PerformPrediction(ctx context.Context, req OptPredictionParameters, params PerformPredictionParams) (*PredictionResult, error)
+	PerformPrediction(ctx context.Context, params PerformPredictionParams) (*PredictionResult, error)
 	// ReadinessCheck implements readinessCheck operation.
 	//
 	// Readiness check.

pkg/rest/oas_unimplemented_gen.go

@@ -15,10 +15,10 @@ var _ Handler = UnimplementedHandler{}
 
 // PerformPrediction implements performPrediction operation.
 //
-// Perform preidction.
+// Perform prediction.
 //
-// POST /api/v1/prediction
+// GET /api/v1/prediction
-func (UnimplementedHandler) PerformPrediction(ctx context.Context, req OptPredictionParameters, params PerformPredictionParams) (r *PredictionResult, _ error) {
+func (UnimplementedHandler) PerformPrediction(ctx context.Context, params PerformPredictionParams) (r *PredictionResult, _ error) {
 	return r, ht.ErrNotImplemented
 }
 

pkg/rest/oas_uri_gen.go

@@ -1,535 +0,0 @@
-// Code generated by ogen, DO NOT EDIT.
-
-package gsn
-
-import (
-	"time"
-
-	"github.com/go-faster/errors"
-
-	"github.com/ogen-go/ogen/conv"
-	"github.com/ogen-go/ogen/uri"
-)
-
-// EncodeURI encodes PredictionParameters as URI form.
-func (s *PredictionParameters) EncodeURI(e uri.Encoder) error {
-	if err := e.EncodeField("launch_latitude", func(e uri.Encoder) error {
-		if val, ok := s.LaunchLatitude.Get(); ok {
-			return e.EncodeValue(conv.Float64ToString(val))
-		}
-		return nil
-	}); err != nil {
-		return errors.Wrap(err, "encode field \"launch_latitude\"")
-	}
-	if err := e.EncodeField("launch_longitude", func(e uri.Encoder) error {
-		if val, ok := s.LaunchLongitude.Get(); ok {
-			return e.EncodeValue(conv.Float64ToString(val))
-		}
-		return nil
-	}); err != nil {
-		return errors.Wrap(err, "encode field \"launch_longitude\"")
-	}
-	if err := e.EncodeField("launch_datetime", func(e uri.Encoder) error {
-		if val, ok := s.LaunchDatetime.Get(); ok {
-			return e.EncodeValue(conv.DateTimeToString(val))
-		}
-		return nil
-	}); err != nil {
-		return errors.Wrap(err, "encode field \"launch_datetime\"")
-	}
-	if err := e.EncodeField("launch_altitude", func(e uri.Encoder) error {
-		if val, ok := s.LaunchAltitude.Get(); ok {
-			return e.EncodeValue(conv.Float64ToString(val))
-		}
-		return nil
-	}); err != nil {
-		return errors.Wrap(err, "encode field \"launch_altitude\"")
-	}
-	if err := e.EncodeField("profile", func(e uri.Encoder) error {
-		if val, ok := s.Profile.Get(); ok {
-			return e.EncodeValue(conv.StringToString(string(val)))
-		}
-		return nil
-	}); err != nil {
-		return errors.Wrap(err, "encode field \"profile\"")
-	}
-	if err := e.EncodeField("ascent_rate", func(e uri.Encoder) error {
-		if val, ok := s.AscentRate.Get(); ok {
-			return e.EncodeValue(conv.Float64ToString(val))
-		}
-		return nil
-	}); err != nil {
-		return errors.Wrap(err, "encode field \"ascent_rate\"")
-	}
-	if err := e.EncodeField("burst_altitude", func(e uri.Encoder) error {
-		if val, ok := s.BurstAltitude.Get(); ok {
-			return e.EncodeValue(conv.Float64ToString(val))
-		}
-		return nil
-	}); err != nil {
-		return errors.Wrap(err, "encode field \"burst_altitude\"")
-	}
-	if err := e.EncodeField("descent_rate", func(e uri.Encoder) error {
-		if val, ok := s.DescentRate.Get(); ok {
-			return e.EncodeValue(conv.Float64ToString(val))
-		}
-		return nil
-	}); err != nil {
-		return errors.Wrap(err, "encode field \"descent_rate\"")
-	}
-	if err := e.EncodeField("float_altitude", func(e uri.Encoder) error {
-		if val, ok := s.FloatAltitude.Get(); ok {
-			return e.EncodeValue(conv.Float64ToString(val))
-		}
-		return nil
-	}); err != nil {
-		return errors.Wrap(err, "encode field \"float_altitude\"")
-	}
-	if err := e.EncodeField("stop_datetime", func(e uri.Encoder) error {
-		if val, ok := s.StopDatetime.Get(); ok {
-			return e.EncodeValue(conv.DateTimeToString(val))
-		}
-		return nil
-	}); err != nil {
-		return errors.Wrap(err, "encode field \"stop_datetime\"")
-	}
-	if err := e.EncodeField("ascent_curve", func(e uri.Encoder) error {
-		if val, ok := s.AscentCurve.Get(); ok {
-			return e.EncodeValue(conv.StringToString(val))
-		}
-		return nil
-	}); err != nil {
-		return errors.Wrap(err, "encode field \"ascent_curve\"")
-	}
-	if err := e.EncodeField("descent_curve", func(e uri.Encoder) error {
-		if val, ok := s.DescentCurve.Get(); ok {
-			return e.EncodeValue(conv.StringToString(val))
-		}
-		return nil
-	}); err != nil {
-		return errors.Wrap(err, "encode field \"descent_curve\"")
-	}
-	if err := e.EncodeField("interpolate", func(e uri.Encoder) error {
-		if val, ok := s.Interpolate.Get(); ok {
-			return e.EncodeValue(conv.BoolToString(val))
-		}
-		return nil
-	}); err != nil {
-		return errors.Wrap(err, "encode field \"interpolate\"")
-	}
-	if err := e.EncodeField("format", func(e uri.Encoder) error {
-		if val, ok := s.Format.Get(); ok {
-			return e.EncodeValue(conv.StringToString(string(val)))
-		}
-		return nil
-	}); err != nil {
-		return errors.Wrap(err, "encode field \"format\"")
-	}
-	if err := e.EncodeField("dataset", func(e uri.Encoder) error {
-		if val, ok := s.Dataset.Get(); ok {
-			return e.EncodeValue(conv.DateTimeToString(val))
-		}
-		return nil
-	}); err != nil {
-		return errors.Wrap(err, "encode field \"dataset\"")
-	}
-	return nil
-}
-
-var uriFieldsNameOfPredictionParameters = [15]string{
-	0:  "launch_latitude",
-	1:  "launch_longitude",
-	2:  "launch_datetime",
-	3:  "launch_altitude",
-	4:  "profile",
-	5:  "ascent_rate",
-	6:  "burst_altitude",
-	7:  "descent_rate",
-	8:  "float_altitude",
-	9:  "stop_datetime",
-	10: "ascent_curve",
-	11: "descent_curve",
-	12: "interpolate",
-	13: "format",
-	14: "dataset",
-}
-
-// DecodeURI decodes PredictionParameters from URI form.
-func (s *PredictionParameters) DecodeURI(d uri.Decoder) error {
-	if s == nil {
-		return errors.New("invalid: unable to decode PredictionParameters to nil")
-	}
-	s.setDefaults()
-
-	if err := d.DecodeFields(func(k string, d uri.Decoder) error {
-		switch k {
-		case "launch_latitude":
-			if err := func() error {
-				var sDotLaunchLatitudeVal float64
-				if err := func() error {
-					val, err := d.DecodeValue()
-					if err != nil {
-						return err
-					}
-
-					c, err := conv.ToFloat64(val)
-					if err != nil {
-						return err
-					}
-
-					sDotLaunchLatitudeVal = c
-					return nil
-				}(); err != nil {
-					return err
-				}
-				s.LaunchLatitude.SetTo(sDotLaunchLatitudeVal)
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"launch_latitude\"")
-			}
-		case "launch_longitude":
-			if err := func() error {
-				var sDotLaunchLongitudeVal float64
-				if err := func() error {
-					val, err := d.DecodeValue()
-					if err != nil {
-						return err
-					}
-
-					c, err := conv.ToFloat64(val)
-					if err != nil {
-						return err
-					}
-
-					sDotLaunchLongitudeVal = c
-					return nil
-				}(); err != nil {
-					return err
-				}
-				s.LaunchLongitude.SetTo(sDotLaunchLongitudeVal)
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"launch_longitude\"")
-			}
-		case "launch_datetime":
-			if err := func() error {
-				var sDotLaunchDatetimeVal 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
-					}
-
-					sDotLaunchDatetimeVal = c
-					return nil
-				}(); err != nil {
-					return err
-				}
-				s.LaunchDatetime.SetTo(sDotLaunchDatetimeVal)
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"launch_datetime\"")
-			}
-		case "launch_altitude":
-			if err := func() error {
-				var sDotLaunchAltitudeVal float64
-				if err := func() error {
-					val, err := d.DecodeValue()
-					if err != nil {
-						return err
-					}
-
-					c, err := conv.ToFloat64(val)
-					if err != nil {
-						return err
-					}
-
-					sDotLaunchAltitudeVal = c
-					return nil
-				}(); err != nil {
-					return err
-				}
-				s.LaunchAltitude.SetTo(sDotLaunchAltitudeVal)
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"launch_altitude\"")
-			}
-		case "profile":
-			if err := func() error {
-				var sDotProfileVal PredictionParametersProfile
-				if err := func() error {
-					val, err := d.DecodeValue()
-					if err != nil {
-						return err
-					}
-
-					c, err := conv.ToString(val)
-					if err != nil {
-						return err
-					}
-
-					sDotProfileVal = PredictionParametersProfile(c)
-					return nil
-				}(); err != nil {
-					return err
-				}
-				s.Profile.SetTo(sDotProfileVal)
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"profile\"")
-			}
-		case "ascent_rate":
-			if err := func() error {
-				var sDotAscentRateVal float64
-				if err := func() error {
-					val, err := d.DecodeValue()
-					if err != nil {
-						return err
-					}
-
-					c, err := conv.ToFloat64(val)
-					if err != nil {
-						return err
-					}
-
-					sDotAscentRateVal = c
-					return nil
-				}(); err != nil {
-					return err
-				}
-				s.AscentRate.SetTo(sDotAscentRateVal)
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"ascent_rate\"")
-			}
-		case "burst_altitude":
-			if err := func() error {
-				var sDotBurstAltitudeVal float64
-				if err := func() error {
-					val, err := d.DecodeValue()
-					if err != nil {
-						return err
-					}
-
-					c, err := conv.ToFloat64(val)
-					if err != nil {
-						return err
-					}
-
-					sDotBurstAltitudeVal = c
-					return nil
-				}(); err != nil {
-					return err
-				}
-				s.BurstAltitude.SetTo(sDotBurstAltitudeVal)
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"burst_altitude\"")
-			}
-		case "descent_rate":
-			if err := func() error {
-				var sDotDescentRateVal float64
-				if err := func() error {
-					val, err := d.DecodeValue()
-					if err != nil {
-						return err
-					}
-
-					c, err := conv.ToFloat64(val)
-					if err != nil {
-						return err
-					}
-
-					sDotDescentRateVal = c
-					return nil
-				}(); err != nil {
-					return err
-				}
-				s.DescentRate.SetTo(sDotDescentRateVal)
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"descent_rate\"")
-			}
-		case "float_altitude":
-			if err := func() error {
-				var sDotFloatAltitudeVal float64
-				if err := func() error {
-					val, err := d.DecodeValue()
-					if err != nil {
-						return err
-					}
-
-					c, err := conv.ToFloat64(val)
-					if err != nil {
-						return err
-					}
-
-					sDotFloatAltitudeVal = c
-					return nil
-				}(); err != nil {
-					return err
-				}
-				s.FloatAltitude.SetTo(sDotFloatAltitudeVal)
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"float_altitude\"")
-			}
-		case "stop_datetime":
-			if err := func() error {
-				var sDotStopDatetimeVal 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
-					}
-
-					sDotStopDatetimeVal = c
-					return nil
-				}(); err != nil {
-					return err
-				}
-				s.StopDatetime.SetTo(sDotStopDatetimeVal)
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"stop_datetime\"")
-			}
-		case "ascent_curve":
-			if err := func() error {
-				var sDotAscentCurveVal string
-				if err := func() error {
-					val, err := d.DecodeValue()
-					if err != nil {
-						return err
-					}
-
-					c, err := conv.ToString(val)
-					if err != nil {
-						return err
-					}
-
-					sDotAscentCurveVal = c
-					return nil
-				}(); err != nil {
-					return err
-				}
-				s.AscentCurve.SetTo(sDotAscentCurveVal)
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"ascent_curve\"")
-			}
-		case "descent_curve":
-			if err := func() error {
-				var sDotDescentCurveVal string
-				if err := func() error {
-					val, err := d.DecodeValue()
-					if err != nil {
-						return err
-					}
-
-					c, err := conv.ToString(val)
-					if err != nil {
-						return err
-					}
-
-					sDotDescentCurveVal = c
-					return nil
-				}(); err != nil {
-					return err
-				}
-				s.DescentCurve.SetTo(sDotDescentCurveVal)
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"descent_curve\"")
-			}
-		case "interpolate":
-			if err := func() error {
-				var sDotInterpolateVal bool
-				if err := func() error {
-					val, err := d.DecodeValue()
-					if err != nil {
-						return err
-					}
-
-					c, err := conv.ToBool(val)
-					if err != nil {
-						return err
-					}
-
-					sDotInterpolateVal = c
-					return nil
-				}(); err != nil {
-					return err
-				}
-				s.Interpolate.SetTo(sDotInterpolateVal)
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"interpolate\"")
-			}
-		case "format":
-			if err := func() error {
-				var sDotFormatVal PredictionParametersFormat
-				if err := func() error {
-					val, err := d.DecodeValue()
-					if err != nil {
-						return err
-					}
-
-					c, err := conv.ToString(val)
-					if err != nil {
-						return err
-					}
-
-					sDotFormatVal = PredictionParametersFormat(c)
-					return nil
-				}(); err != nil {
-					return err
-				}
-				s.Format.SetTo(sDotFormatVal)
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"format\"")
-			}
-		case "dataset":
-			if err := func() error {
-				var sDotDatasetVal 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
-					}
-
-					sDotDatasetVal = c
-					return nil
-				}(); err != nil {
-					return err
-				}
-				s.Dataset.SetTo(sDotDatasetVal)
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"dataset\"")
-			}
-		default:
-			return nil
-		}
-		return nil
-	}); err != nil {
-		return errors.Wrap(err, "decode PredictionParameters")
-	}
-
-	return nil
-}

pkg/rest/oas_validators_gen.go

@@ -10,181 +10,7 @@ import (
 	"github.com/ogen-go/ogen/validate"
 )
 
-func (s *PredictionParameters) Validate() error {
+func (s PerformPredictionFormat) Validate() error {
-	if s == nil {
-		return validate.ErrNilPointer
-	}
-
-	var failures []validate.FieldError
-	if err := func() error {
-		if value, ok := s.LaunchLatitude.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 {
-		failures = append(failures, validate.FieldError{
-			Name:  "launch_latitude",
-			Error: err,
-		})
-	}
-	if err := func() error {
-		if value, ok := s.LaunchLongitude.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 {
-		failures = append(failures, validate.FieldError{
-			Name:  "launch_longitude",
-			Error: err,
-		})
-	}
-	if err := func() error {
-		if value, ok := s.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 {
-		failures = append(failures, validate.FieldError{
-			Name:  "launch_altitude",
-			Error: err,
-		})
-	}
-	if err := func() error {
-		if value, ok := s.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 {
-		failures = append(failures, validate.FieldError{
-			Name:  "profile",
-			Error: err,
-		})
-	}
-	if err := func() error {
-		if value, ok := s.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 {
-		failures = append(failures, validate.FieldError{
-			Name:  "ascent_rate",
-			Error: err,
-		})
-	}
-	if err := func() error {
-		if value, ok := s.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 {
-		failures = append(failures, validate.FieldError{
-			Name:  "burst_altitude",
-			Error: err,
-		})
-	}
-	if err := func() error {
-		if value, ok := s.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 {
-		failures = append(failures, validate.FieldError{
-			Name:  "descent_rate",
-			Error: err,
-		})
-	}
-	if err := func() error {
-		if value, ok := s.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 {
-		failures = append(failures, validate.FieldError{
-			Name:  "float_altitude",
-			Error: err,
-		})
-	}
-	if err := func() error {
-		if value, ok := s.Format.Get(); ok {
-			if err := func() error {
-				if err := value.Validate(); err != nil {
-					return err
-				}
-				return nil
-			}(); err != nil {
-				return err
-			}
-		}
-		return nil
-	}(); err != nil {
-		failures = append(failures, validate.FieldError{
-			Name:  "format",
-			Error: err,
-		})
-	}
-	if len(failures) > 0 {
-		return &validate.Error{Fields: failures}
-	}
-	return nil
-}
-
-func (s PredictionParametersFormat) Validate() error {
 	switch s {
 	case "json":
 		return nil
@@ -193,7 +19,7 @@ func (s PredictionParametersFormat) Validate() error {
 	}
 }
 
-func (s PredictionParametersProfile) Validate() error {
+func (s PerformPredictionProfile) Validate() error {
 	switch s {
 	case "standard_profile":
 		return nil