@solvice/routing 0.0.0-stage → 0.1.0-beta.0

package/dist/v3.d.ts

@@ -0,0 +1,4138 @@
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+export interface paths {
+    "/v3/routing/evaluate": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Evaluate an imported solution
+         * @description Scores the `plan` you send against `problem` without searching for a better one. Returns the plan's cost, timing and loads, and lists each constraint violation on the stop or route where it occurs; `summary.score.violations` is 0 when there are none. Tasks that appear in no route are reported in `unassigned[]`. `problem` has the same shape as on `POST /v3/routing/solve`, and a solve response's `plan` can be sent as it stands.
+         */
+        post: operations["evaluate"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v3/routing/solve": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Solve a vehicle routing problem
+         * @description Assigns the jobs and shipments in `problem` to the vehicles' shifts and returns the routes, the `plan` they follow and any tasks left unassigned, each with the reasons. The request is validated first: an invalid one is rejected with a 400 whose `errors[]` says what to fix. Travel times and distances for the request's locations are then looked up, and the search runs for `options.time_limit_s` seconds (default 1). Send a previous result's `plan` to re-optimize starting from it. `POST /v3/routing/evaluate` and `POST /v3/routing/suggest` take the same `problem`.
+         */
+        post: operations["solve"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v3/routing/suggest": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Suggest best insertions for the tasks outside the plan
+         * @description Takes the same body as `POST /v3/routing/evaluate` (`problem` + committed `plan`), plus optional `options`. Every task of `problem` that is not in `plan` is a task to place: finds its feasible insertion positions and returns them as `insertions`, ranked by `delta.cost`, the change in the plan's cost in money. Each insertion lists the stops it adds (`placements`) and every plan route it changes, whole (`routes`): swap those routes into `plan` to apply it. An empty `insertions` carries a `reason_code` (`time_limit`, `candidates_exhausted` or `infeasible`; an open set). The committed plan is never modified. Limitation: suggest never opens a new reload trip on a multi-trip vehicle.
+         */
+        post: operations["suggest"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+export type webhooks = Record<string, never>;
+export interface components {
+    schemas: {
+        /**
+         * @description Absolute price of serving one task on one vehicle.
+         * @example {
+         *       "cost": 12.5,
+         *       "vehicle": "v1"
+         *     }
+         */
+        AssignmentCost: {
+            /**
+             * Format: double
+             * @description Cost, in the objective's currency, incurred when this vehicle serves
+             *     the task. Must be finite and `>= 0`. A vehicle not listed costs `0`.
+             * @example 12.5
+             */
+            cost: number;
+            /**
+             * @description Vehicle id; applies to every shift of that vehicle. An id that matches
+             *     no vehicle is rejected with HTTP 400.
+             * @example v1
+             */
+            vehicle: string;
+        };
+        /**
+         * @description Named capacity/demand/load dimensions, e.g. `{"weight": 30, "volume": 2}`. Keys are user-chosen dimension names; values are integer quantities. Order-independent and self-documenting.
+         * @example {
+         *       "volume": 2,
+         *       "weight": 20
+         *     }
+         */
+        BTreeMap: {
+            [key: string]: number;
+        };
+        /**
+         * @description A scheduled break within a shift. Tagged by `type`:
+         *
+         *     - `windowed`: a break of `duration_s` that starts inside its window.
+         *     - `triggered`: a break of `duration_s` taken once drive or duty time
+         *       passes `threshold_s` (the EU-561 mechanism).
+         *     - `fixed`: a hard off-duty interval from `from` to `to`.
+         *
+         *     Breaks are injected between stops and appear in the response as `break`
+         *     stops.
+         *
+         *     **Not yet supported** — rejected with HTTP 400 `not_supported`: more than
+         *     one `windows` entry, a `location` on a `triggered` break, and
+         *     `resets_accumulator: false`.
+         *
+         *     There is no paid/unpaid cost accounting: a break's duration is never
+         *     separately priced, and no `paid` field exists on this schema — sending one
+         *     is rejected as an unknown field (HTTP 400, `unknown_field`), like any other extra key.
+         * @example {
+         *       "after": "drive",
+         *       "duration_s": 1800,
+         *       "threshold_s": 14400,
+         *       "type": "triggered"
+         *     }
+         */
+        Break: {
+            /**
+             * Format: int32
+             * @description Break duration in seconds.
+             */
+            duration_s: number;
+            /** @description Where the break is taken. Absent: wherever the vehicle is. */
+            location?: null | components["schemas"]["Place"];
+            /** @enum {string} */
+            type: "windowed";
+            /**
+             * @description The window bounding the break's **start**. Exactly one entry; a
+             *     second one is rejected with HTTP 400 (`not_supported`).
+             */
+            windows: components["schemas"]["BreakWindow"][];
+        } | {
+            /** @description What to accumulate: drive time or duty time. */
+            after: components["schemas"]["TriggerAfter"];
+            /**
+             * Format: int32
+             * @description Break duration in seconds.
+             */
+            duration_s: number;
+            /** @description Not supported yet: any value is rejected with HTTP 400. */
+            location?: null | components["schemas"]["Place"];
+            /**
+             * @description Whether the accumulator resets after the break. Default `true` (the
+             *     EU-561 semantics; the accumulation window restarts after a qualifying
+             *     break). `false` is not supported yet and is rejected with HTTP 400.
+             * @example true
+             */
+            resets_accumulator?: boolean | null;
+            /**
+             * Format: int64
+             * @description Trigger threshold in seconds (strict `>` — the break fires when the
+             *     accumulator exceeds this). EU 561/2006 drive rule: `16200` (4 h 30).
+             * @example 14400
+             */
+            threshold_s: number;
+            /** @enum {string} */
+            type: "triggered";
+        } | {
+            /**
+             * Format: date-time
+             * @description Start of the break (RFC 3339 instant, UTC offset required).
+             */
+            from: string;
+            /**
+             * Format: date-time
+             * @description End of the break (RFC 3339 instant, UTC offset required).
+             */
+            to: string;
+            /** @enum {string} */
+            type: "fixed";
+        };
+        /**
+         * @description The window a `windowed` break must start in. Always hard.
+         * @example {
+         *       "from": "2026-07-01T12:00:00+02:00",
+         *       "to": "2026-07-01T13:30:00+02:00"
+         *     }
+         */
+        BreakWindow: {
+            /**
+             * Format: date-time
+             * @description Earliest break start (RFC 3339 instant, UTC offset required).
+             */
+            from: string;
+            /**
+             * Format: date-time
+             * @description Latest break start (RFC 3339 instant, UTC offset required).
+             */
+            to: string;
+        };
+        /**
+         * @description What running a vehicle costs, in the request's currency
+         *     (`objective.currency` is only a label). The same type at three levels:
+         *     `objective.costs` prices the fleet, `vehicles[].costs` replaces a field for
+         *     one vehicle, and `shifts[].costs` replaces it for one shift. Each field
+         *     resolves on its own: the shift's value, else the vehicle's, else the
+         *     fleet's, else the default. Nothing is added on top of a fleet rate, and
+         *     every field is reported under the same `score.components` key at every
+         *     level. `0` means priced at zero; absent means inherit.
+         *
+         *     Rates are rounded to the internal grid (1/100 000 of a currency unit per
+         *     second or per metre); a nonzero rate too small to represent is rejected.
+         *     Every value must be finite and `>= 0`.
+         * @example {
+         *       "fixed": 50,
+         *       "per_route_hour": 35,
+         *       "per_travel_km": 0.2
+         *     }
+         */
+        Costs: {
+            /**
+             * Format: double
+             * @description Flat charge for each used shift (a route with at least one task),
+             *     reported in `score.components.fixed`. Default `0`. Pricing vehicles is
+             *     how the solver is made to use fewer of them: the higher it is, the
+             *     more travel it accepts to avoid opening another route.
+             * @example 50
+             */
+            fixed?: number | null;
+            /**
+             * Format: double
+             * @description Per hour a route finishes past its shift's `to` (possible only with
+             *     `max_overtime_s`), reported in `score.components.overtime`, on top of
+             *     `per_route_hour`. Default `0`: overtime is unpriced.
+             * @example 0
+             */
+            per_overtime_hour?: number | null;
+            /**
+             * Format: double
+             * @description Per hour of each route's wall-clock span (travel, service, waiting
+             *     and breaks), reported in `score.components.time`. Default **35**.
+             * @example 35
+             */
+            per_route_hour?: number | null;
+            /**
+             * Format: double
+             * @description Per kilometre driven, reported in `score.components.distance`.
+             *     Default **0.20**.
+             * @example 0.2
+             */
+            per_travel_km?: number | null;
+            /**
+             * Format: double
+             * @description Per hour spent waiting for a time window to open, reported in
+             *     `score.components.waiting`, on top of `per_route_hour` (the span
+             *     includes the wait). Default `0`.
+             * @example 0
+             */
+            per_wait_hour?: number | null;
+        };
+        /**
+         * @description A depot: a place a shift starts from, ends at, or reloads at mid-shift,
+         *     referenced by `id` from `shifts[].start`, `shifts[].end` and
+         *     `shifts[].reloads`. Each depot keeps its own handling time and visit cost.
+         * @example {
+         *       "id": "gent",
+         *       "location": [
+         *         3.7174,
+         *         51.0543
+         *       ],
+         *       "service_duration_s": 900
+         *     }
+         */
+        Depot: {
+            /**
+             * Format: double
+             * @description Money charged once per reload visit, in the objective's currency.
+             *     Default 0. A shift that only starts or ends here is not charged.
+             *
+             *     Set this when a reload has a real per-visit price the travel terms
+             *     cannot see — typically the driver labour for the unload itself
+             *     (`service_duration_s` × the hourly rate). Without it, a reload that
+             *     consumes only *slack* is free in the objective: it adds no route
+             *     duration, so the solver will happily insert one to displace time that
+             *     `objective.costs.per_wait_hour` would otherwise charge as idle, parking
+             *     the vehicle at a depot for no capacity benefit.
+             * @example 38.66
+             */
+            cost_per_visit?: number | null;
+            /**
+             * @description Depot id: 1 to 128 characters, unique across `depots[]`.
+             * @example gent
+             */
+            id: string;
+            /** @description Where the depot is. */
+            location: components["schemas"]["Place"];
+            /**
+             * Format: int32
+             * @description Handling time in seconds per visit: the load before a shift that starts
+             *     here, the unload after a shift that ends here, and each reload. A shift
+             *     end's own `service_duration_s` overrides it for that end. Default 0.
+             *     The unload after a shift must finish by that shift's `to` (or
+             *     `to + max_overtime_s`). Not scaled by `service_factor`: this is
+             *     depot-side handling, not the driver's on-site work rate.
+             * @example 900
+             */
+            service_duration_s?: number | null;
+        };
+        /**
+         * @description Hard vehicle eligibility: whitelist or blacklist (mutually exclusive).
+         * @example {
+         *       "allowed": [
+         *         "v1",
+         *         "v2"
+         *       ]
+         *     }
+         */
+        Eligibility: {
+            /** @description Hard whitelist of vehicle ids. Omit = all vehicles allowed. */
+            allowed?: string[] | null;
+            /** @description Hard blacklist of vehicle ids. Mutually exclusive with `allowed`. */
+            excluded?: string[] | null;
+        };
+        /**
+         * @description Error body of every `/v3/routing/*` endpoint.
+         *
+         *     `status` is the HTTP status as text, `code` says what kind of failure it
+         *     is, `request_id` identifies the request, and `errors` holds one item per
+         *     problem found in the request. Branch on `code`, and on `errors[].code` for
+         *     400s; the messages are for people.
+         * @example {
+         *       "code": "invalid_request",
+         *       "errors": [
+         *         {
+         *           "code": "out_of_range",
+         *           "message": "depot 'gent': service_duration_s must be >= 0, got -60",
+         *           "pointer": "/problem/depots/0/service_duration_s"
+         *         }
+         *       ],
+         *       "message": "depot 'gent': service_duration_s must be >= 0, got -60",
+         *       "request_id": "req_7f3a2c90d1e4b5a6",
+         *       "status": "BAD_REQUEST"
+         *     }
+         */
+        ErrorBody: {
+            /** @description What kind of failure this is. One value per HTTP status class. */
+            code: components["schemas"]["ErrorCode"];
+            /** @description One entry per problem found in the request. Empty for non-input errors. */
+            errors?: components["schemas"]["ErrorItem"][];
+            /**
+             * @description Human-readable summary. With exactly one item it is that item's
+             *     message; with several, `"{n} problems in request"` (at most 100 items
+             *     are listed, and the message says when the list is cut).
+             */
+            message: string;
+            /** @description The `X-Request-Id` of the request (echoed, or generated when absent). */
+            request_id?: string | null;
+            /**
+             * @description The HTTP status as text, e.g. `"BAD_REQUEST"` or
+             *     `"SERVICE_UNAVAILABLE"`.
+             * @example BAD_REQUEST
+             */
+            status: string;
+        };
+        /**
+         * @description The top-level `code` of an error body.
+         * @enum {string}
+         */
+        ErrorCode: "invalid_request" | "feature_not_enabled" | "payload_too_large" | "unsupported_media_type" | "internal" | "matrix_provider_error" | "overloaded";
+        /** @description One problem in a request. */
+        ErrorItem: {
+            /**
+             * Format: int64
+             * @description `limit_exceeded` only: the count this request has.
+             */
+            actual?: number | null;
+            /** @description What is wrong. */
+            code: components["schemas"]["ErrorItemCode"];
+            /**
+             * Format: int64
+             * @description `limit_exceeded` only: the published cap.
+             */
+            limit?: number | null;
+            /** @description Human-readable description. */
+            message: string;
+            /**
+             * @description RFC 6901 JSON Pointer into the request body, when the problem has a
+             *     location. It is relative to the root of the body, so a field of the
+             *     problem reads `/problem/...` (e.g.
+             *     `"/problem/vehicles/0/shifts/0/from"`).
+             */
+            pointer?: string | null;
+        };
+        /**
+         * @description The `code` of one `errors[]` item. Clients should accept values they do
+         *     not know yet.
+         * @enum {string}
+         */
+        ErrorItemCode: "invalid_json" | "invalid_type" | "unknown_field" | "missing_field" | "invalid_value" | "not_supported" | "out_of_range" | "duplicate_id" | "unknown_reference" | "conflicting_fields" | "limit_exceeded";
+        /**
+         * @description Request body for `POST /v3/routing/evaluate`.
+         *
+         *     Scores `plan` against `problem` without running the optimizer: objective
+         *     totals, timing, loads and constraint violations. Tasks absent from every
+         *     route are reported as unassigned. A solve response's `plan` goes in as it
+         *     stands.
+         * @example {
+         *       "plan": {
+         *         "routes": [
+         *           {
+         *             "shift": "mon",
+         *             "stops": [
+         *               {
+         *                 "id": "job-1",
+         *                 "type": "job"
+         *               }
+         *             ],
+         *             "vehicle": "v1"
+         *           }
+         *         ]
+         *       },
+         *       "problem": {
+         *         "jobs": [
+         *           {
+         *             "id": "job-1",
+         *             "location": [
+         *               3.725,
+         *               51.05
+         *             ],
+         *             "pickup": {
+         *               "weight": 10
+         *             },
+         *             "service_duration_s": 300
+         *           }
+         *         ],
+         *         "vehicles": [
+         *           {
+         *             "capacity": {
+         *               "weight": 500
+         *             },
+         *             "id": "v1",
+         *             "shifts": [
+         *               {
+         *                 "end": {
+         *                   "location": [
+         *                     3.7174,
+         *                     51.0543
+         *                   ]
+         *                 },
+         *                 "from": "2026-07-01T08:00:00+02:00",
+         *                 "id": "mon",
+         *                 "start": {
+         *                   "location": [
+         *                     3.7174,
+         *                     51.0543
+         *                   ]
+         *                 },
+         *                 "to": "2026-07-01T17:00:00+02:00"
+         *               }
+         *             ]
+         *           }
+         *         ]
+         *       }
+         *     }
+         */
+        EvaluateRequest: {
+            /** @description The plan to score. */
+            plan: components["schemas"]["Plan"];
+            /** @description Problem definition — identical to `POST /v3/routing/solve`. */
+            problem: components["schemas"]["ProblemInput"];
+        };
+        /**
+         * @description Keep geographically clustered tasks consecutive in a route.
+         *
+         *     Two tasks are in the same **group** when they lie within `radius_m` of
+         *     each other. The solver adds `cost_per_reentry` to the objective each time
+         *     a route leaves a group and comes back — minimising the "passing-waypoint"
+         *     / area re-entry count last-mile fleets track. Presence of this object
+         *     enables the feature; omit it to disable.
+         * @example {
+         *       "cost_per_reentry": 0.5,
+         *       "distance": "straight_line",
+         *       "radius_m": 180
+         *     }
+         */
+        Grouping: {
+            /**
+             * Format: double
+             * @description Cost added to the objective per group re-entry, in the objective's
+             *     currency. At most 1000 currency units: a larger value is rejected with
+             *     HTTP 400. Higher keeps clusters together more aggressively at the
+             *     expense of total travel.
+             * @example 0.5
+             */
+            cost_per_reentry: number;
+            /** @description How neighbour distance is measured. Default `"straight_line"`. */
+            distance?: null | components["schemas"]["GroupingDistance"];
+            /**
+             * Format: int32
+             * @description Radius defining a group, in metres. Default `180`.
+             * @example 180
+             */
+            radius_m?: number | null;
+        };
+        /**
+         * @description How neighbour distance is measured for `objective.grouping`.
+         * @example straight_line
+         * @enum {string}
+         */
+        GroupingDistance: "straight_line" | "road";
+        /**
+         * @description How an option changes the plan: the change in its score's `cost` and in
+         *     its routes' summed `distance_m` and `time.travel_s`. Equal to the difference
+         *     between two `/evaluate` calls, with and without the option (`cost` up to
+         *     floating-point rounding).
+         * @example {
+         *       "cost": 12.4,
+         *       "distance_m": 2400,
+         *       "duration_s": 240
+         *     }
+         */
+        InsertionDelta: {
+            /**
+             * Format: double
+             * @description Change in the score's `cost`, in the request's currency. Negative when
+             *     serving a task saves more `drop_fee` than it costs to route.
+             * @example 12.4
+             */
+            cost: number;
+            /**
+             * Format: int64
+             * @description Change in the summed route `distance_m`, in metres.
+             * @example 2400
+             */
+            distance_m: number;
+            /**
+             * Format: int64
+             * @description Change in the summed route `time.travel_s` (driving time only), in
+             *     seconds.
+             * @example 240
+             */
+            duration_s: number;
+        };
+        /**
+         * @description One feasible way to place the whole unit.
+         * @example {
+         *       "delta": {
+         *         "cost": 12.4,
+         *         "distance_m": 2400,
+         *         "duration_s": 240
+         *       },
+         *       "placements": [
+         *         {
+         *           "arrival": "2026-07-01T09:30:00+02:00",
+         *           "id": "job-2",
+         *           "latest_arrival": "2026-07-01T10:15:00+02:00",
+         *           "shift": "mon",
+         *           "type": "job",
+         *           "vehicle": "v1"
+         *         }
+         *       ],
+         *       "routes": [
+         *         {
+         *           "shift": "mon",
+         *           "stops": [
+         *             {
+         *               "id": "job-1",
+         *               "type": "job"
+         *             },
+         *             {
+         *               "id": "job-2",
+         *               "type": "job"
+         *             }
+         *           ],
+         *           "vehicle": "v1"
+         *         }
+         *       ]
+         *     }
+         */
+        InsertionOption: {
+            /** @description What the option changes: `plan` with `routes` swapped in, minus `plan`. */
+            delta: components["schemas"]["InsertionDelta"];
+            /**
+             * @description Other idle vehicles, each on its own shift, that give the same `delta`
+             *     once `vehicle` and `shift` are swapped for theirs in `placements` and
+             *     `routes`. Present only when the option opens a vehicle with no stops
+             *     in `plan`. Not guaranteed exhaustive.
+             */
+            interchangeable_vehicles?: components["schemas"]["ShiftRef"][];
+            /** @description Every stop the option adds, in route order. */
+            placements: components["schemas"]["Placement"][];
+            /**
+             * @description Every plan route the option changes, as it reads with the option in:
+             *     the request's route (its `locked_count` kept), or a new one, with the
+             *     placements inserted. Replace the routes of `plan` with the same
+             *     `vehicle` and `shift` by these to get the plan `delta` scores.
+             */
+            routes: components["schemas"]["PlanRoute"][];
+        };
+        /**
+         * @description Ranked insertion suggestions for a single unit.
+         * @example {
+         *       "insertions": [
+         *         {
+         *           "delta": {
+         *             "cost": 12.4,
+         *             "distance_m": 2400,
+         *             "duration_s": 240
+         *           },
+         *           "placements": [
+         *             {
+         *               "arrival": "2026-07-01T09:30:00+02:00",
+         *               "id": "job-2",
+         *               "latest_arrival": "2026-07-01T10:15:00+02:00",
+         *               "shift": "mon",
+         *               "type": "job",
+         *               "vehicle": "v1"
+         *             }
+         *           ],
+         *           "routes": [
+         *             {
+         *               "shift": "mon",
+         *               "stops": [
+         *                 {
+         *                   "id": "job-1",
+         *                   "type": "job"
+         *                 },
+         *                 {
+         *                   "id": "job-2",
+         *                   "type": "job"
+         *                 }
+         *               ],
+         *               "vehicle": "v1"
+         *             }
+         *           ]
+         *         }
+         *       ],
+         *       "job_id": "job-2"
+         *     }
+         */
+        JobSuggestions: {
+            /**
+             * @description Ranked feasible insertions, lowest `delta.cost` first. Empty if none
+             *     was found; `reason_code` then says why. Known limitation: suggest
+             *     never opens a **new reload trip** on a multi-trip vehicle.
+             */
+            insertions: components["schemas"]["InsertionOption"][];
+            /**
+             * @description The unit's lead: its first member in placement order (the visit, the
+             *     shipment, or the first relation member).
+             * @example job-2
+             */
+            job_id: string;
+            /**
+             * @description `reason_code` as an English sentence, for people and logs; present
+             *     exactly when `reason_code` is. Do not parse the text.
+             * @example No feasible insertion position found
+             */
+            reason?: string | null;
+            /** @description Why `insertions` is empty; absent otherwise. Branch on this. */
+            reason_code?: null | components["schemas"]["SuggestReasonCode"];
+        };
+        /**
+         * @description Which road-network data prices travel times and distances.
+         *
+         *     - `tomtom` (default): TomTom historical-typical traffic at the departure
+         *       time.
+         *     - `osm`: OpenStreetMap free-flow times. No traffic, so
+         *       `travel.departure_time` is rejected with 400.
+         *     - `tomtom_real_time`: TomTom live traffic at the moment of the request.
+         *       **Not yet enabled: currently always rejected with 403 `feature_not_enabled`.** Once enabled:
+         *       `travel.departure_time` is rejected; every vehicle must use the `car`
+         *       profile; at most 100 distinct locations; up to ~25 s of matrix fetch at
+         *       100 locations.
+         * @example osm
+         * @enum {string}
+         */
+        MatrixEngine: "tomtom" | "osm" | "tomtom_real_time";
+        /**
+         * @description Top-level objective configuration.
+         *
+         *     Plans are compared in a fixed order: first **serve the required tasks**
+         *     (the summed `priority` of the required tasks left unassigned is
+         *     minimised), then **minimise cost** — the `costs` rates plus every priced
+         *     preference, reported as `score.cost`. There is no separate vehicle-count
+         *     step: to use fewer vehicles, price them with `costs.fixed` or
+         *     `vehicles[].costs.fixed`.
+         * @example {
+         *       "costs": {
+         *         "per_route_hour": 35,
+         *         "per_travel_km": 0.2
+         *       },
+         *       "currency": "EUR"
+         *     }
+         */
+        Objective: {
+            /**
+             * @description Fleet cost rates: the default for every vehicle and shift that does
+             *     not set its own. See the `Costs` schema.
+             */
+            costs?: null | components["schemas"]["Costs"];
+            /**
+             * @description Currency label (ISO 4217, e.g. `EUR`) for every amount in the request
+             *     and in `score`. Informational: echoed as `score.currency`, it never
+             *     converts anything.
+             * @example EUR
+             */
+            currency?: string | null;
+            /** @description Job-proximity cluster cohesion. See the `Grouping` schema. */
+            grouping?: null | components["schemas"]["Grouping"];
+            /**
+             * Format: double
+             * @description Flat charge, in the objective's currency, for serving a task on a day
+             *     other than its `preferred_date`.
+             *
+             *     Applied once per task whose `preferred_date` resolves to a different
+             *     calendar day (in its own offset) than the shift serving it; tasks without a `preferred_date`
+             *     are never charged. Unset or `0.0` disables the preference entirely,
+             *     which also makes every `preferred_date` in the request inert.
+             *
+             *     Part of `score.cost`, so it trades off against travel and vehicle
+             *     cost but never against serving a required task.
+             * @example 50
+             */
+            non_preferred_date_cost?: number | null;
+            /**
+             * Format: double
+             * @description Cost per hour of lateness: the default rate for every task window
+             *     that does not carry its own `time_windows[].per_late_hour`. Omit for
+             *     hard windows. An explicit `0.0` is rejected as ambiguous (free
+             *     lateness and hard windows read opposite ways, and lateness is never
+             *     free). There is no earliness rate. It prices task windows only: a
+             *     shift's `to` (plus `max_overtime_s` when set) stays a hard limit.
+             *     Setting it `> 0` alongside a nonzero `time_windows[].cost` anywhere in
+             *     the request is rejected with HTTP 400.
+             * @example 60
+             */
+            per_late_hour?: number | null;
+        };
+        /**
+         * @description The 200 body of solve, evaluate and suggest: the call's result, or with
+         *     `?validate_only=true` the validation verdict (`ValidateOnlyResponse`).
+         */
+        OrValidateOnly_SolveResponse: {
+            /**
+             * @description The plan these routes follow, in the request's vocabulary: valid input
+             *     to evaluate, suggest or a warm-started solve as it stands.
+             */
+            plan: components["schemas"]["Plan"];
+            /** @description One entry per non-empty route. */
+            routes: components["schemas"]["Route"][];
+            /** @description Aggregate statistics for the solve run. */
+            summary: components["schemas"]["Summary"];
+            /** @description Tasks that could not be feasibly assigned. */
+            unassigned: components["schemas"]["Unassigned"][];
+        } | components["schemas"]["ValidateOnlyResponse"];
+        /**
+         * @description The 200 body of solve, evaluate and suggest: the call's result, or with
+         *     `?validate_only=true` the validation verdict (`ValidateOnlyResponse`).
+         */
+        OrValidateOnly_SuggestResponse: {
+            /**
+             * Format: int64
+             * @description Wall-clock time taken by the request, in milliseconds.
+             * @example 8
+             */
+            elapsed_ms: number;
+            /**
+             * @description One entry per unit of tasks outside `plan`, in problem order (jobs,
+             *     then shipments; a relation group sorts at its first-listed member).
+             */
+            suggestions: components["schemas"]["JobSuggestions"][];
+            /**
+             * @description `true` when `options.time_limit_s` cut the search short, or a
+             *     multi-member unit came back empty after the search had discarded
+             *     candidates (an inconclusive "not found"; its `reason_code` is
+             *     `candidates_exhausted`). Lists may then be incomplete or missing the
+             *     best insertion. A single visit's only level is never pruned, so its
+             *     empty list is proof of infeasibility unless the budget cut it, and its
+             *     `reason_code` is then `time_limit`.
+             */
+            truncated?: boolean;
+        } | components["schemas"]["ValidateOnlyResponse"];
+        /**
+         * @description The recurrence of a period limit (`limits.periods[].every`).
+         * @enum {string}
+         */
+        PeriodEvery: "day" | "week";
+        /**
+         * @description A cap on a vehicle's totals across every shift that starts in one period.
+         *     Set exactly one of `every`, or `from` and `to`; and at least one maximum.
+         * @example {
+         *       "every": "week",
+         *       "max_duration_s": 144000,
+         *       "max_tasks": 40
+         *     }
+         */
+        PeriodLimit: {
+            /** @description A recurring period: every `day`, or every `week` (weeks start Monday). */
+            every?: null | components["schemas"]["PeriodEvery"];
+            /**
+             * Format: date-time
+             * @description Start of one explicit period (RFC 3339, UTC offset required), with `to`. The window must
+             *     hold at least one of the vehicle's shift starts; a period inside one
+             *     shift is not supported.
+             * @example 2026-10-05T00:00:00+02:00
+             */
+            from?: string | null;
+            /**
+             * Format: int64
+             * @description Hard cap on the summed distance driven, in metres.
+             * @example 900000
+             */
+            max_distance_m?: number | null;
+            /**
+             * Format: int64
+             * @description Hard cap on the summed route span of the period's shifts, measured as
+             *     for `max_route_duration_s`. An unused shift adds nothing.
+             * @example 144000
+             */
+            max_duration_s?: number | null;
+            /**
+             * Format: int32
+             * @description Hard cap on served stops, counted as a shift's `max_tasks` counts
+             *     them: a job is one stop, a shipment two (pickup and delivery).
+             * @example 40
+             */
+            max_tasks?: number | null;
+            /**
+             * Format: date-time
+             * @description End of one explicit period (RFC 3339, UTC offset required, exclusive), with `from`.
+             * @example 2026-10-12T00:00:00+02:00
+             */
+            to?: string | null;
+        };
+        /**
+         * @description A place: a coordinate `[longitude, latitude]` in GeoJSON order — exactly two numbers. Tasks at the same coordinate are treated as one location.
+         * @example [
+         *       3.725,
+         *       51.05
+         *     ]
+         */
+        Place: number[];
+        /**
+         * @description One stop an option adds: the plan stop, the plan route it goes into and
+         *     when it is reached.
+         * @example {
+         *       "arrival": "2026-07-01T09:30:00+02:00",
+         *       "id": "s1:pickup",
+         *       "latest_arrival": "2026-07-01T10:15:00+02:00",
+         *       "shift": "mon",
+         *       "type": "pickup",
+         *       "vehicle": "v1"
+         *     }
+         */
+        Placement: {
+            /**
+             * Format: date-time
+             * @description Arrival at this stop (RFC 3339), in the UTC offset of `shift`'s
+             *     `from` (`Z` when that `from` is UTC or has no offset), as on routes.
+             * @example 2026-07-01T09:30:00+02:00
+             */
+            arrival: string;
+            /** @description The plan stop's `id`: the job id, or the shipment leg's stop id. */
+            id: string;
+            /**
+             * Format: date-time
+             * @description Latest arrival that still keeps the rest of the route feasible
+             *     (RFC 3339, in the offset of `arrival`) — the smaller of the task's own time-window latest and
+             *     the route's forward slack here. Under priced lateness it may be
+             *     **earlier** than `arrival`.
+             * @example 2026-07-01T10:15:00+02:00
+             */
+            latest_arrival: string;
+            /** @description Shift of that plan route. */
+            shift: string;
+            /**
+             * @description The plan stop's `type`: `job`, `pickup` or `delivery` (never `reload`:
+             *     suggest does not open reload trips).
+             */
+            type: components["schemas"]["PlanStopType"];
+            /** @description Vehicle of the plan route the stop goes into. */
+            vehicle: string;
+        };
+        /**
+         * @description A plan: which stops each vehicle shift serves, in order. A result's `plan`
+         *     has exactly this shape and goes back into evaluate, suggest or a
+         *     warm-started solve unchanged.
+         */
+        Plan: {
+            /** @description One entry per vehicle shift that serves something. */
+            routes: components["schemas"]["PlanRoute"][];
+        };
+        /**
+         * @description One vehicle shift's route: every trip of the shift, split by `reload` stops.
+         * @example {
+         *       "shift": "mon",
+         *       "stops": [
+         *         {
+         *           "id": "boiler-17",
+         *           "type": "job"
+         *         }
+         *       ],
+         *       "vehicle": "van-3"
+         *     }
+         */
+        PlanRoute: {
+            /**
+             * Format: int32
+             * @description On solve, the first `locked_count` stops stay where they are (already
+             *     dispatched). Counts every listed stop. Cannot be combined with a
+             *     `reload` stop, and must not exceed the route's stop count — both are
+             *     validated on every endpoint that takes a plan. Otherwise inert on
+             *     evaluate. On suggest, no insertion lands before them.
+             * @example 1
+             */
+            locked_count?: number | null;
+            /** @description Shift id, within that vehicle. */
+            shift: string;
+            /** @description Stops in visiting order. */
+            stops: components["schemas"]["PlanStop"][];
+            /** @description Vehicle id. */
+            vehicle: string;
+        };
+        /**
+         * @description One stop of a plan route. Start, end and breaks are placed by the solver
+         *     and are not listed.
+         * @example {
+         *       "id": "parts-9:pickup",
+         *       "type": "pickup"
+         *     }
+         */
+        PlanStop: {
+            /**
+             * @description Job id.
+             * @example boiler-17
+             */
+            id: string;
+            /** @enum {string} */
+            type: "job";
+        } | {
+            /**
+             * @description The leg's stop id: its own `id`, else `{shipment}:pickup`.
+             * @example parts-9:pickup
+             */
+            id: string;
+            /** @enum {string} */
+            type: "pickup";
+        } | {
+            /**
+             * @description The leg's stop id: its own `id`, else `{shipment}:delivery`.
+             * @example parts-9:delivery
+             */
+            id: string;
+            /** @enum {string} */
+            type: "delivery";
+        } | {
+            /**
+             * @description A depot id from the shift's `reloads`.
+             * @example gent
+             */
+            depot: string;
+            /** @enum {string} */
+            type: "reload";
+        };
+        /**
+         * @description The `type` of a plan stop.
+         * @enum {string}
+         */
+        PlanStopType: "job" | "pickup" | "delivery" | "reload";
+        /**
+         * @description How much road detail `routes[].polyline` carries.
+         *
+         *     This is the knob that decides whether a drawn route follows the roads or
+         *     cuts corners — **not** the polyline encoding precision, which is fixed at 5
+         *     and is a sub-metre concern. Measured on a three-stop, 150 km route:
+         *
+         *     | detail | shape points | geometry bytes | added latency |
+         *     |--------|--------------|----------------|---------------|
+         *     | `simplified` | 34 | ~200 | ~0 |
+         *     | `full` | 1,728 | ~5,300 | ~0 (inside run-to-run noise) |
+         *
+         *     Prefer `full` unless response size is the binding constraint: the extra
+         *     detail is nearly free in time, and `simplified` is what makes a route look
+         *     like straight lines between stops.
+         * @example full
+         * @enum {string}
+         */
+        PolylineDetail: "simplified" | "full";
+        /**
+         * @description A soft vehicle affinity preference, priced.
+         * @example {
+         *       "vehicle": "v1",
+         *       "violation_cost": 50
+         *     }
+         */
+        Preference: {
+            /**
+             * @description Preferred vehicle id.
+             * @example v1
+             */
+            vehicle: string;
+            /**
+             * Format: double
+             * @description Cost, in the objective's currency, incurred when a different vehicle
+             *     serves the job. Must be finite and `>= 0`.
+             * @example 50
+             */
+            violation_cost: number;
+        };
+        /**
+         * @description The problem part of every V3 request body.
+         * @example {
+         *       "depots": [
+         *         {
+         *           "id": "gent",
+         *           "location": [
+         *             3.7174,
+         *             51.0543
+         *           ]
+         *         }
+         *       ],
+         *       "jobs": [
+         *         {
+         *           "id": "job-1",
+         *           "location": [
+         *             3.725,
+         *             51.05
+         *           ],
+         *           "pickup": {
+         *             "weight": 20
+         *           },
+         *           "service_duration_s": 300
+         *         }
+         *       ],
+         *       "vehicles": [
+         *         {
+         *           "capacity": {
+         *             "weight": 500
+         *           },
+         *           "id": "v1",
+         *           "shifts": [
+         *             {
+         *               "end": {
+         *                 "depot": "gent"
+         *               },
+         *               "from": "2026-07-01T08:00:00+02:00",
+         *               "id": "mon",
+         *               "start": {
+         *                 "depot": "gent"
+         *               },
+         *               "to": "2026-07-01T17:00:00+02:00"
+         *             }
+         *           ]
+         *         }
+         *       ]
+         *     }
+         */
+        ProblemInput: {
+            /** @description Depots that shifts start from, end at, or reload at, by id. */
+            depots?: components["schemas"]["Depot"][];
+            /** @description Single-stop visits to serve. */
+            jobs?: components["schemas"]["Visit"][];
+            /** @description Objective configuration. */
+            objective?: null | components["schemas"]["Objective"];
+            /** @description Stop caps shared by a set of vehicles. */
+            quotas?: components["schemas"]["Quota"][];
+            /** @description Ordering, grouping, and synchronization constraints. */
+            relations?: components["schemas"]["Relation"][] | null;
+            /** @description Bound pickup→delivery shipments to serve. */
+            shipments?: components["schemas"]["Shipment"][];
+            /** @description Where travel times and distances come from. */
+            travel?: null | components["schemas"]["Travel"];
+            /** @description Available vehicles. */
+            vehicles: components["schemas"]["Vehicle"][];
+        };
+        /**
+         * @description A vehicle's routing profile.
+         * @example car
+         * @enum {string}
+         */
+        Profile: "car" | "truck" | "bike";
+        /**
+         * @description A hard cap on how many stops of `job_ids` the `vehicles` serve together
+         *     in a window. A stop counts when its service starts in `[from, to)`
+         *     (`arrival + wait_s` in the response); without a window every stop counts.
+         *     Stops count as `max_tasks` counts them: a job one, a shipment two. An
+         *     over-cap job is left unassigned. Unlike `limits.periods[]`, which counts a
+         *     shift by its start, a quota has no `every` recurrence and caps only stop
+         *     counts.
+         * @example {
+         *       "id": "pool-install",
+         *       "job_ids": [
+         *         "j1",
+         *         "j2",
+         *         "j3"
+         *       ],
+         *       "max_tasks": 2,
+         *       "vehicles": [
+         *         "c0",
+         *         "c1"
+         *       ]
+         *     }
+         */
+        Quota: {
+            /**
+             * Format: date-time
+             * @description Window start (RFC 3339, UTC offset required), with `to`.
+             * @example 2026-10-05T00:00:00+02:00
+             */
+            from?: string | null;
+            /**
+             * @description Quota id: 1 to 128 characters, unique among `quotas`; named in the
+             *     `/evaluate` `quota` violation.
+             */
+            id: string;
+            /** @description Job or shipment ids whose stops count, each at most once. */
+            job_ids: string[];
+            /**
+             * Format: int32
+             * @description The cap on counted stops.
+             */
+            max_tasks: number;
+            /**
+             * Format: date-time
+             * @description Window end (RFC 3339, UTC offset required, exclusive), with `from`.
+             * @example 2026-10-06T00:00:00+02:00
+             */
+            to?: string | null;
+            /** @description Vehicle ids that share the cap, each at most once. */
+            vehicles: string[];
+        };
+        /**
+         * @description A hard constraint between tasks, selected by `type`: `sequence`,
+         *     `tag_order`, `same_vehicle`, `same_day`, `same_route`, `synchronized`,
+         *     `time_lag`, `compatible_vehicles` or `all_or_none`.
+         *     Each type carries only its own fields; any other `type` is rejected with
+         *     HTTP 400.
+         *
+         *     Members are named by `stops` (stop ids). `same_vehicle`, `same_day` and
+         *     `same_route` take **either** `stops` **or** a `tag`, not both. Every
+         *     relation is hard.
+         *
+         *     Relations constrain jobs, not shipments. A shipment id in the `stops` of
+         *     a `sequence`, `same_vehicle`, `same_day` or `synchronized` relation, and
+         *     a shipment carrying the `tag` of a `same_vehicle` or `same_day` relation,
+         *     passes validation but is skipped: the request returns HTTP 200 and the
+         *     relation does not constrain that shipment. `same_route`, `time_lag`,
+         *     `compatible_vehicles`, `all_or_none` and `tag_order` reject a shipment
+         *     with HTTP 400.
+         * @example {
+         *       "stops": [
+         *         "job-1",
+         *         "job-2"
+         *       ],
+         *       "type": "sequence"
+         *     }
+         */
+        Relation: {
+            /**
+             * @description Job or shipment ids, in the order they must be served. A shipment
+             *     is named by its id, not by a leg's stop id (stop-id members are
+             *     not resolved yet).
+             */
+            stops: string[];
+            /** @enum {string} */
+            type: "sequence";
+        } | {
+            /** @description Tag labels in precedence order. Requires at least 2 entries. */
+            tags: string[];
+            /** @enum {string} */
+            type: "tag_order";
+        } | {
+            /**
+             * @description Job or shipment ids in the relation (mutually exclusive with
+             *     `tag`; stop-id members are not resolved yet).
+             */
+            stops?: string[] | null;
+            /** @description Tag selecting the relation members (mutually exclusive with `stops`). */
+            tag?: string | null;
+            /** @enum {string} */
+            type: "same_vehicle";
+        } | {
+            /**
+             * @description Job or shipment ids in the relation (mutually exclusive with
+             *     `tag`; stop-id members are not resolved yet).
+             */
+            stops?: string[] | null;
+            /** @description Tag selecting the relation members (mutually exclusive with `stops`). */
+            tag?: string | null;
+            /** @enum {string} */
+            type: "same_day";
+        } | {
+            /**
+             * @description Job or shipment ids in the relation (mutually exclusive with
+             *     `tag`; stop-id members are not resolved yet).
+             */
+            stops?: string[] | null;
+            /** @description Tag selecting the relation members (mutually exclusive with `stops`). */
+            tag?: string | null;
+            /** @enum {string} */
+            type: "same_route";
+        } | {
+            /**
+             * Format: int64
+             * @description Maximum spread between the synchronized instants in seconds
+             *     (`0` = exact simultaneity). Required. A negative value is rejected
+             *     with HTTP 400 `out_of_range`.
+             */
+            max_wait_s: number;
+            /**
+             * @description Which instant is synchronized: the service `start` (default) or
+             *     the service `end`. `arrival` is rejected with HTTP 400.
+             */
+            on?: null | components["schemas"]["StopInstant"];
+            /**
+             * @description Participating job or shipment ids (stop-id members are not
+             *     resolved yet).
+             */
+            stops: string[];
+            /** @enum {string} */
+            type: "synchronized";
+        } | {
+            /** @description The reference end. */
+            from: components["schemas"]["TimeLagEnd"];
+            /**
+             * Format: int64
+             * @description Upper bound on `t(to) − t(from)` in seconds. Absent = unbounded.
+             */
+            max_s?: number | null;
+            /**
+             * Format: int64
+             * @description Lower bound on `t(to) − t(from)` in seconds. Default `0`.
+             */
+            min_s?: number | null;
+            /** @description The bounded end. */
+            to: components["schemas"]["TimeLagEnd"];
+            /** @enum {string} */
+            type: "time_lag";
+        } | {
+            /**
+             * @description Job or shipment ids, at least two (stop-id members are not
+             *     resolved yet).
+             * @example [
+             *       "job-1",
+             *       "job-2"
+             *     ]
+             */
+            stops: string[];
+            /** @enum {string} */
+            type: "compatible_vehicles";
+        } | {
+            /**
+             * @description Job ids, at least two.
+             * @example [
+             *       "job-1",
+             *       "job-2"
+             *     ]
+             */
+            stops: string[];
+            /** @enum {string} */
+            type: "all_or_none";
+        };
+        /**
+         * @description A best-effort, actionable suggestion for relaxing the problem so a task can be
+         *     assigned — derived from the smallest constraint relaxation the solver found.
+         * @example {
+         *       "amount": 900,
+         *       "field": "/jobs/job-2/time_windows",
+         *       "op": "extend_time_window",
+         *       "suggestion": "Extend a time window by 900s (~15 min).",
+         *       "unit": "s"
+         *     }
+         */
+        Relaxation: {
+            /**
+             * Format: int64
+             * @description Magnitude of the change, expressed in `unit`.
+             * @example 900
+             */
+            amount: number;
+            /**
+             * @description Names the task and the field to change. For a job: `/jobs/{id}/pickup`
+             *     (`/jobs/{id}/delivery` for a job with only a `delivery`) or
+             *     `/jobs/{id}/time_windows`. For a shipment: `/shipments/{id}/load` or
+             *     `/shipments/{id}/pickup/time_windows` (either leg's window may be the
+             *     one to extend). `{id}` is the task id, the same value as `job_id`. It is
+             *     a label, not a JSON Pointer into the request body: it uses the id, not
+             *     the array index, and has no `/problem` prefix.
+             * @example /jobs/job-2/time_windows
+             */
+            field: string;
+            /** @description The kind of change suggested. */
+            op: components["schemas"]["RelaxationOp"];
+            /**
+             * @description Human-readable suggestion.
+             * @example Extend a time window by 900s (~15 min).
+             */
+            suggestion: string;
+            /**
+             * @description Unit of `amount`: `"s"` (seconds, for `extend_time_window`) or
+             *     `"load"` (demand units, for `reduce_demand`).
+             * @example s
+             */
+            unit: string;
+        };
+        /**
+         * @description The kind of change a relaxation suggests.
+         * @example extend_time_window
+         * @enum {string}
+         */
+        RelaxationOp: "reduce_demand" | "extend_time_window";
+        /**
+         * @description A single vehicle's route.
+         * @example {
+         *       "distance_m": 8450,
+         *       "load_peak": {
+         *         "weight": 55
+         *       },
+         *       "shift": "mon",
+         *       "stops": [
+         *         {
+         *           "arrival": "2026-07-01T08:00:00+02:00",
+         *           "departure": "2026-07-01T08:00:00+02:00",
+         *           "depot": "gent",
+         *           "load_after": {
+         *             "weight": 0
+         *           },
+         *           "location": [
+         *             3.7174,
+         *             51.0543
+         *           ],
+         *           "service_s": 0,
+         *           "type": "start"
+         *         },
+         *         {
+         *           "arrival": "2026-07-01T08:10:00+02:00",
+         *           "departure": "2026-07-01T09:05:00+02:00",
+         *           "distance_m": 2600,
+         *           "id": "job-1",
+         *           "lateness_s": 0,
+         *           "load_after": {
+         *             "weight": 20
+         *           },
+         *           "location": [
+         *             3.725,
+         *             51.05
+         *           ],
+         *           "service_s": 300,
+         *           "travel_s": 600,
+         *           "type": "job",
+         *           "wait_s": 3000
+         *         },
+         *         {
+         *           "arrival": "2026-07-01T09:13:00+02:00",
+         *           "departure": "2026-07-01T09:23:00+02:00",
+         *           "distance_m": 2350,
+         *           "id": "job-2",
+         *           "lateness_s": 0,
+         *           "load_after": {
+         *             "weight": 55
+         *           },
+         *           "location": [
+         *             3.71,
+         *             51.06
+         *           ],
+         *           "service_s": 600,
+         *           "travel_s": 480,
+         *           "type": "job",
+         *           "wait_s": 0
+         *         },
+         *         {
+         *           "arrival": "2026-07-01T09:38:00+02:00",
+         *           "departure": "2026-07-01T09:38:00+02:00",
+         *           "depot": "gent",
+         *           "distance_m": 3500,
+         *           "load_after": {
+         *             "weight": 55
+         *           },
+         *           "location": [
+         *             3.7174,
+         *             51.0543
+         *           ],
+         *           "service_s": 0,
+         *           "travel_s": 900,
+         *           "type": "end"
+         *         }
+         *       ],
+         *       "time": {
+         *         "break_s": 0,
+         *         "depot_s": 0,
+         *         "overtime_s": 0,
+         *         "service_s": 900,
+         *         "span_s": 5880,
+         *         "travel_s": 1980,
+         *         "wait_s": 3000
+         *       },
+         *       "vehicle": "v1"
+         *     }
+         */
+        Route: {
+            /**
+             * Format: int64
+             * @description Total route distance, in metres.
+             * @example 8450
+             */
+            distance_m: number;
+            /** @description Peak load reached on the route, by named dimension. */
+            load_peak?: null | components["schemas"]["BTreeMap"];
+            /**
+             * @description Road geometry for this route as an [encoded polyline] at precision 5
+             *     (~1.1 m), ready to hand to a map library. Present only when
+             *     `options.polylines` was set, and absent for a route whose geometry the
+             *     routing engine could not produce.
+             *
+             *     Traced with this vehicle's `profile` at the solve's departure time, so
+             *     it is the same road path the plan was costed on — not a generic car
+             *     route. It is a decoration, though: `distance_m` and `time` come
+             *     from the solver's matrix and are authoritative if the two ever disagree.
+             *
+             *     [encoded polyline]: https://developers.google.com/maps/documentation/utilities/polylinealgorithm
+             * @example _p~iF~ps|U_ulLnnqC_mqNvxq`@
+             */
+            polyline?: string | null;
+            /**
+             * @description The shift id (`vehicles[].shifts[].id`) this route runs on.
+             * @example mon
+             */
+            shift: string;
+            /** @description Ordered stops, including depot bookends. */
+            stops: components["schemas"]["StopOutput"][];
+            /**
+             * @description Where this route's time goes. `time.span_s` is what the route's
+             *     `costs.per_route_hour` is charged on: the shift's rate, else its
+             *     vehicle's, else `objective.costs.per_route_hour`.
+             */
+            time: components["schemas"]["TimeTotals"];
+            /** @description The vehicle id (`vehicle.id` from the request) serving this route. */
+            vehicle: string;
+            /**
+             * @description Route-level constraint violations (e.g. `max_distance`, `max_duration`,
+             *     or `unreachable` for a leg whose destination is not a job stop — the
+             *     return to the end depot, or a leg into a reload).
+             *     Only populated by `POST /v3/routing/evaluate`; absent on solve responses.
+             */
+            violations?: components["schemas"]["Violation"][];
+        };
+        /**
+         * @description How good a plan is. Plans compare in order: fewer `violations` first,
+         *     then less `unserved_priority`, then less `cost`.
+         * @example {
+         *       "components": {
+         *         "depot_visits": 0,
+         *         "distance": 1.69,
+         *         "drop_fees": 0,
+         *         "fixed": 0,
+         *         "grouping": 0,
+         *         "lateness": 0,
+         *         "other": 0,
+         *         "overtime": 0,
+         *         "tag_preference": 0,
+         *         "target": 0,
+         *         "time": 57.1536,
+         *         "waiting": 0,
+         *         "window_choice": 0
+         *       },
+         *       "cost": 58.8436,
+         *       "currency": "EUR",
+         *       "unserved_priority": 0,
+         *       "violations": 0
+         *     }
+         */
+        Score: {
+            /** @description The money of each objective term. */
+            components: components["schemas"]["ScoreComponents"];
+            /**
+             * Format: double
+             * @description Total cost, in the objective's currency: the sum of `components`.
+             * @example 58.8436
+             */
+            cost: number;
+            /**
+             * @description Informational currency label, echoed from `objective.currency`.
+             * @example EUR
+             */
+            currency?: string | null;
+            /**
+             * Format: int64
+             * @description Summed `priority` of the required tasks left unassigned (a task that
+             *     priced a `drop_fee` counts in `components.drop_fees` instead).
+             * @example 0
+             */
+            unserved_priority: number;
+            /**
+             * Format: int32
+             * @description Hard-constraint violations. Always `0` on a solve result.
+             * @example 0
+             */
+            violations: number;
+        };
+        /**
+         * @description The money of each objective term, in the objective's currency. The
+         *     components always sum to `score.cost` exactly: every term the solver
+         *     charges lands in exactly one of them.
+         * @example {
+         *       "depot_visits": 0,
+         *       "distance": 1.69,
+         *       "drop_fees": 0,
+         *       "fixed": 0,
+         *       "grouping": 0,
+         *       "lateness": 0,
+         *       "other": 0,
+         *       "overtime": 0,
+         *       "tag_preference": 0,
+         *       "target": 0,
+         *       "time": 57.1536,
+         *       "waiting": 0,
+         *       "window_choice": 0
+         *     }
+         */
+        ScoreComponents: {
+            /**
+             * Format: double
+             * @description Cost of reload visits, in currency units (`depots[].cost_per_visit`).
+             */
+            depot_visits: number;
+            /**
+             * Format: double
+             * @description Distance cost, in currency units: each route's distance priced at
+             *     its `costs.per_travel_km` (shift, vehicle or fleet).
+             */
+            distance: number;
+            /**
+             * Format: double
+             * @description The summed `drop_fee` of the tasks left unassigned, in currency units.
+             */
+            drop_fees: number;
+            /**
+             * Format: double
+             * @description Vehicle cost, in currency units: `costs.fixed` once per used shift,
+             *     at the shift's, vehicle's or fleet's rate.
+             */
+            fixed: number;
+            /**
+             * Format: double
+             * @description Cost of splitting close tasks across routes, in currency units
+             *     (`objective.grouping`).
+             */
+            grouping: number;
+            /**
+             * Format: double
+             * @description Cost of priced lateness past a time window, in currency units
+             *     (`objective.per_late_hour` or `time_windows[].per_late_hour`).
+             */
+            lateness: number;
+            /**
+             * Format: double
+             * @description Everything else the solver charges, in currency units: vehicle
+             *     preferences (`preferences[].violation_cost`) and the
+             *     non-preferred-date cost.
+             */
+            other: number;
+            /**
+             * Format: double
+             * @description Cost of work past a soft shift end, in currency units: priced at the
+             *     route's `costs.per_overtime_hour`.
+             */
+            overtime: number;
+            /**
+             * Format: double
+             * @description Cost of serving tasks outside a vehicle's `preferred_tags`, in
+             *     currency units.
+             */
+            tag_preference: number;
+            /**
+             * Format: double
+             * @description Cost of missing tasks' `target` times, in currency units
+             *     (`target.per_late_hour`).
+             */
+            target: number;
+            /**
+             * Format: double
+             * @description Time cost, in currency units: each route's span priced at its
+             *     `costs.per_route_hour` (shift, vehicle or fleet).
+             */
+            time: number;
+            /**
+             * Format: double
+             * @description Cost of waiting for time windows to open, in currency units: each
+             *     route's wait priced at its `costs.per_wait_hour`.
+             */
+            waiting: number;
+            /**
+             * Format: double
+             * @description The price of the time window each task was served in, in currency
+             *     units (`time_windows[].cost`).
+             */
+            window_choice: number;
+        };
+        /**
+         * @description Per-vehicle work-rate override for one task's `service_duration_s`.
+         * @example {
+         *       "factor": 1.25,
+         *       "vehicle": "v1"
+         *     }
+         */
+        ServiceFactor: {
+            /**
+             * Format: double
+             * @description Same meaning, direction and `(0, 5]` range as `vehicles[].service_factor`:
+             *     effective service time = `service_duration_s / (vehicle_or_shift_factor * factor)`.
+             *     `1.0` is a no-op.
+             * @example 1.25
+             */
+            factor: number;
+            /**
+             * @description Vehicle id; applies to every shift of that vehicle.
+             * @example v1
+             */
+            vehicle: string;
+        };
+        /**
+         * @description One working shift for a vehicle.
+         * @example {
+         *       "end": {
+         *         "location": [
+         *           3.7174,
+         *           51.0543
+         *         ]
+         *       },
+         *       "from": "2026-07-01T08:00:00+02:00",
+         *       "id": "mon",
+         *       "start": {
+         *         "location": [
+         *           3.7174,
+         *           51.0543
+         *         ]
+         *       },
+         *       "to": "2026-07-01T17:00:00+02:00"
+         *     }
+         */
+        Shift: {
+            /**
+             * @description Scheduled driver breaks within this shift — see the `Break` schema for
+             *     the supported forms. Injected breaks appear as `break` stops in the
+             *     response routes.
+             */
+            breaks?: components["schemas"]["Break"][] | null;
+            /**
+             * @description Capacity for this shift only. Each dimension named here replaces the
+             *     vehicle's value for that dimension; dimensions not named keep the
+             *     vehicle's `capacity`.
+             */
+            capacity?: null | components["schemas"]["BTreeMap"];
+            /**
+             * @description Costs for this shift only. Each field set here replaces the same
+             *     field of the vehicle's `costs` (or, when the vehicle does not set it,
+             *     of `objective.costs`) for this shift; fields not set keep that value.
+             */
+            costs?: null | components["schemas"]["Costs"];
+            /** @description Where the shift ends. Absent = open end. */
+            end?: null | components["schemas"]["ShiftEnd"];
+            /**
+             * Format: date-time
+             * @description Shift start (RFC 3339 instant, UTC offset required).
+             * @example 2026-07-01T08:00:00+02:00
+             */
+            from: string;
+            /**
+             * @description Shift id: 1 to 128 characters, unique within this vehicle.
+             * @example mon
+             */
+            id: string;
+            /**
+             * @description Symmetric to `ignore_start_leg` for the last-task → `end` leg.
+             * @example false
+             */
+            ignore_end_leg?: boolean | null;
+            /**
+             * @description When `true`, the `start` → first-task leg costs nothing (not counted
+             *     in objective, feasibility timing, or total distance/duration) — the
+             *     depot is still known and reported (a real stop, snapped coordinate,
+             *     departure time). Distinct from omitting `start` (a fully open route,
+             *     which drops the depot entirely): this keeps the depot visible while
+             *     making the leg to it free. Requires `start`; a no-op when `start` is
+             *     absent. Default `false`.
+             * @example false
+             */
+            ignore_start_leg?: boolean | null;
+            /**
+             * @description Load already on the vehicle at shift start (pre-loaded), per
+             *     dimension. Occupies capacity on the first trip only — flushed at the
+             *     first reload — so it reduces first-trip room per dimension, enforced
+             *     by the per-trip capacity constraint. Not validated against
+             *     `capacity` at request time: a value at or beyond capacity is
+             *     accepted and surfaces as a solve-time result (jobs left unassigned,
+             *     or deferred until the vehicle's first reload flushes it), not an
+             *     HTTP 400. A dimension named here but absent from `capacity` behaves
+             *     the same as capacity `0` in that dimension.
+             */
+            initial_load?: null | components["schemas"]["BTreeMap"];
+            /**
+             * @description Limits for this shift only. Each field set here replaces the
+             *     vehicle's `limits` value; fields not set keep it.
+             */
+            limits?: null | components["schemas"]["ShiftLimits"];
+            /**
+             * Format: int32
+             * @description Maximum allowed overtime beyond `to` in seconds. Overtime is reached
+             *     by working late, never by waiting: a `synchronized` or `time_lag`
+             *     hold stops at `to`.
+             * @example 1800
+             */
+            max_overtime_s?: number | null;
+            /**
+             * Format: int32
+             * @description Maximum trips (depot legs) in this shift, across all reload depots.
+             *     Counts trips, not reloads: `trips = reloads_used + 1`. `max_trips: 1`
+             *     means a single trip — reloads are permitted in `reloads` but the cap
+             *     prevents ever using one. `reloads` present with `max_trips` absent
+             *     means unlimited trips. A single reload depot can only be
+             *     revisited up to 8 times per vehicle regardless of `max_trips`;
+             *     a `max_trips` beyond that against one depot
+             *     is accepted but the extra headroom is unreachable — list more than
+             *     one reload depot to raise the practical ceiling.
+             * @example 2
+             */
+            max_trips?: number | null;
+            /**
+             * @description Depots (by `depots[].id`, each at most once) the vehicle may return to
+             *     mid-shift to reload and start a fresh trip. Each visit takes that
+             *     depot's `service_duration_s` and `cost_per_visit`. Cap trips with
+             *     `max_trips`.
+             */
+            reloads?: string[] | null;
+            /**
+             * @description Hard tag scope: when set (non-empty), this shift
+             *     serves only tasks carrying at least one of these tags. Untagged tasks
+             *     remain serveable by every shift. Absent or empty = serves everything.
+             */
+            serves_tags?: string[] | null;
+            /**
+             * Format: double
+             * @description Work-rate multiplier for this shift only, overriding
+             *     `vehicles[].service_factor` when set (absent = inherit the vehicle's
+             *     value, which itself defaults to 1.0).
+             *
+             *     Same meaning, direction, and `(0, 5]` range as the vehicle-level field:
+             *     effective service time = `service_duration_s / service_factor`. Use it
+             *     when the same driver works at a different rate on different days — a
+             *     measured per-day efficiency, a trainee shift, a two-person crew on
+             *     Fridays — instead of collapsing those days into one vehicle-level mean.
+             *
+             *     Scope is identical to the vehicle-level field: task
+             *     `service_duration_s` only, never `setup_duration_s`, depot handling
+             *     (`depots[].service_duration_s`, `start`/`end.service_duration_s`),
+             *     waiting, or breaks.
+             */
+            service_factor?: number | null;
+            /**
+             * @description Capabilities this shift provides, replacing the vehicle's `skills`
+             *     for this shift only (a technician covering another region on one
+             *     day, a crew that only carries a certification on some shifts). A
+             *     job's `skills` must all appear in the skills of the shift that
+             *     serves it, at a level of at least the job's `min_level`. Same entry
+             *     shape as `vehicles[].skills`. Absent = the vehicle's `skills`; `[]` =
+             *     this shift provides none.
+             */
+            skills?: components["schemas"]["VehicleSkill"][] | null;
+            /** @description Where the shift starts. Absent = open start. */
+            start?: null | components["schemas"]["ShiftEnd"];
+            /**
+             * Format: date-time
+             * @description Shift end (RFC 3339 instant, UTC offset required; hard unless `max_overtime_s` set). The
+             *     route must be finished by then, end-depot unload included.
+             * @example 2026-07-01T17:00:00+02:00
+             */
+            to: string;
+        };
+        /**
+         * @description Where a shift starts or ends: exactly one of `location` or `depot`.
+         * @example {
+         *       "depot": "gent"
+         *     }
+         */
+        ShiftEnd: {
+            /**
+             * @description A `depots[].id`. Excludes `location`.
+             * @example gent
+             */
+            depot?: string | null;
+            /** @description An inline place. Excludes `depot`. */
+            location?: null | components["schemas"]["Place"];
+            /**
+             * Format: int32
+             * @description Handling time in seconds at this end: the morning load at `start`, the
+             *     evening unload at `end`. Overrides the depot's `service_duration_s`;
+             *     default: the depot's value, or 0 for a `location` end. Not applied on
+             *     an ignored leg (`ignore_start_leg`/`ignore_end_leg`). Not scaled by
+             *     `service_factor`.
+             *
+             *     The unload must finish by the shift's `to` (or `to + max_overtime_s`):
+             *     a route whose unload would run past it is infeasible. A shift whose
+             *     load and unload alone exceed it is rejected with HTTP 400.
+             * @example 600
+             */
+            service_duration_s?: number | null;
+        };
+        /**
+         * @description Per-shift limits: the route-level `limits` fields a shift may override.
+         *     Period limits apply across shifts, so they stay on the vehicle.
+         * @example {
+         *       "max_tasks": 12
+         *     }
+         */
+        ShiftLimits: {
+            /**
+             * Format: int64
+             * @description Hard cap on this shift's route distance, in metres.
+             * @example 200000
+             */
+            max_distance_m?: number | null;
+            /**
+             * Format: int64
+             * @description Hard cap on this shift's route span, in seconds.
+             * @example 32400
+             */
+            max_route_duration_s?: number | null;
+            /**
+             * Format: int32
+             * @description Maximum stops served in this shift: a job counts as one stop, a
+             *     shipment as two (pickup and delivery).
+             * @example 50
+             */
+            max_tasks?: number | null;
+        };
+        /**
+         * @description A vehicle and one of its shifts: the key of a plan route.
+         * @example {
+         *       "shift": "mon",
+         *       "vehicle": "v2"
+         *     }
+         */
+        ShiftRef: {
+            /** @description Shift id, within that vehicle. */
+            shift: string;
+            /** @description Vehicle id. */
+            vehicle: string;
+        };
+        /**
+         * @description A bound pickup→delivery shipment (the `shipments[]` entry type).
+         *
+         *     Two stops served by one vehicle, pickup strictly before delivery, with
+         *     `load` carried on the vehicle between the two legs.
+         *
+         *     `drop_fee` and vehicle eligibility (`eligible_vehicles`, allow
+         *     **and** exclude, any length) are fully supported and applied to both legs — a
+         *     shipment's pickup and delivery share one droppability/eligibility decision,
+         *     since one vehicle must serve both.
+         * @example {
+         *       "delivery": {
+         *         "location": [
+         *           3.71,
+         *           51.06
+         *         ],
+         *         "service_duration_s": 300
+         *       },
+         *       "id": "ship-1",
+         *       "load": {
+         *         "weight": 20
+         *       },
+         *       "pickup": {
+         *         "location": [
+         *           3.725,
+         *           51.05
+         *         ],
+         *         "service_duration_s": 300
+         *       }
+         *     }
+         */
+        Shipment: {
+            /**
+             * @description Absolute price of serving this task on a given vehicle, in the
+             *     objective's currency. Charged once, when that vehicle (on any of its
+             *     shifts) serves the task; unlisted vehicles cost nothing. Unlike
+             *     `preferences`, which charges the vehicles that did NOT get the task,
+             *     this prices the vehicle that did, so a task rated badly everywhere is
+             *     the first one dropped when capacity runs out. It lives in the cost tier,
+             *     below `priority`, and adds to `preferences`, `drop_fee` and travel.
+             *     Not applied by decomposition: a problem that sets it solves monolithically.
+             */
+            assignment_costs?: components["schemas"]["AssignmentCost"][] | null;
+            /** @description Delivery leg (load off). */
+            delivery: components["schemas"]["Stop"];
+            /**
+             * Format: double
+             * @description Drop **price** — what leaving this task unserved costs you, in the same
+             *     currency as `objective.costs`, and the only way to make a task
+             *     droppable. Tasks without a `drop_fee` must be served.
+             *
+             *     This is money, not a priority: it enters the same cost the solver
+             *     minimises, so the task is served only while serving it costs less than
+             *     the fee. Fees the plan chose to pay are reported in
+             *     `score.components.drop_fees` and summed into `score.cost`.
+             *
+             *     On a shipment the fee applies to the pair, charged once.
+             * @example 25
+             */
+            drop_fee?: number | null;
+            /** @description Hard vehicle allow/exclude. */
+            eligible_vehicles?: null | components["schemas"]["Eligibility"];
+            /**
+             * @description Shipment id: 1 to 128 characters, unique across `jobs` + `shipments`.
+             * @example ship-1
+             */
+            id: string;
+            /**
+             * @description Load carried from the pickup to the delivery: picked up at one leg and
+             *     the same quantity dropped off at the other. Non-negative magnitudes
+             *     per named dimension.
+             */
+            load?: null | components["schemas"]["BTreeMap"];
+            /**
+             * @description Hard-pin this job to one vehicle id — only that vehicle (any of its
+             *     shifts) may serve it, and once placed, re-optimization never removes it
+             *     or moves it to another vehicle. Stronger than `eligible_vehicles`
+             *     (which filters a set) and hard, unlike `preferences`.
+             *
+             *     A pin means "stays on this vehicle if placed", **not** "must be
+             *     served": the task can still end up unassigned (for example when it does
+             *     not fit), and with a `drop_fee` it then pays the fee. An id that
+             *     matches no vehicle is rejected with HTTP 400.
+             * @example vehicle-1
+             */
+            locked_vehicle?: string | null;
+            /** @description Pickup leg (load on). */
+            pickup: components["schemas"]["Stop"];
+            /**
+             * @description Soft vehicle affinity preferences, priced. Each entry is independent:
+             *     a job listing several preferred vehicles it doesn't get pays each
+             *     one's `violation_cost` (compounding, the same rule as a vehicle's
+             *     `preferred_tags`).
+             */
+            preferences?: components["schemas"]["Preference"][] | null;
+            /**
+             * Format: date-time
+             * @description Soft preference for the calendar day this task is served on, in a
+             *     multi-day (multi-shift) problem.
+             *
+             *     An RFC 3339 datetime, UTC offset required, on the intended day. A day is the calendar date of
+             *     the value **in its own UTC offset**, the same rule that dates a shift
+             *     from its `from`, so passing the target shift's `from` verbatim is
+             *     always correct.
+             *
+             *     Soft, and priced by `objective.non_preferred_date_cost` — a flat charge
+             *     applied once to a task served on any other day. **With that cost unset or
+             *     zero this field has no effect.** The charge is part of `score.cost`,
+             *     which ranks below serving required tasks, so a task is never left
+             *     unassigned to honour its preferred date; `locked_vehicle` (hard) also
+             *     still wins.
+             *
+             *     Supported on shipments as well as jobs. Both legs of a shipment ride
+             *     the same route, so the preferred day is a property of the pair: set it
+             *     on the shipment itself, and `non_preferred_date_cost` is charged once
+             *     for the pair rather than once per leg.
+             * @example 2026-08-04T08:00:00+02:00
+             */
+            preferred_date?: string | null;
+            /**
+             * Format: int32
+             * @description Importance of a must-serve task when not all of them fit: the solver
+             *     maximises the summed `priority` of served tasks before any cost. `>= 1`,
+             *     default `1` (maximise the count). A rank, not money — it never makes a
+             *     task droppable; use `drop_fee` for that. Both set is a 400.
+             * @example 3
+             */
+            priority?: number | null;
+            /**
+             * @description Per-vehicle work-rate overrides for this task's `service_duration_s`,
+             *     composed multiplicatively with the serving vehicle's or shift's
+             *     `service_factor`. On a shipment the override scales both legs. A
+             *     vehicle not listed works at its own rate.
+             */
+            service_factors?: components["schemas"]["ServiceFactor"][] | null;
+            /**
+             * @description Hard skill requirements — the assigned vehicle must provide every one,
+             *     at or above each requirement's `min_level`.
+             */
+            skills?: components["schemas"]["SkillReq"][] | null;
+            /**
+             * @description Free-form task labels (zones/territories, grouping/relation labels).
+             *     Used for `tag`/relation resolution and, when a shift scopes itself via
+             *     `serves_tags` (hard ANY-overlap) or a vehicle prices them via
+             *     `preferred_tags` (soft), for tag matching. ANY-overlap — contrast with
+             *     `skills`, which requires ALL. Not capability matching on its own.
+             */
+            tags?: string[] | null;
+            /**
+             * @description Soft target for this task, measured at its arrival (default) or
+             *     departure. On a shipment it is measured on the **delivery** leg.
+             */
+            target?: null | components["schemas"]["Target"];
+        };
+        /**
+         * @description A hard skill requirement — the assigned vehicle must provide it.
+         * @example {
+         *       "name": "fridge"
+         *     }
+         */
+        SkillReq: {
+            /**
+             * Format: int32
+             * @description Minimum level the serving vehicle must hold for this skill (`>= 1`).
+             *     Absent = 1. A vehicle skill with no `level` holds level 1.
+             * @example 2
+             */
+            min_level?: number | null;
+            /**
+             * @description Skill name the assigned vehicle must provide.
+             * @example fridge
+             */
+            name: string;
+        };
+        /**
+         * @description Solve options.
+         * @example {
+         *       "polylines": "full",
+         *       "seed": 42,
+         *       "time_limit_s": 5
+         *     }
+         */
+        SolveOptions: {
+            /**
+             * @description Return road geometry for each route as `routes[].polyline`:
+             *     `simplified` or `full`. Omitted → no geometry (the default).
+             */
+            polylines?: null | components["schemas"]["PolylineDetail"];
+            /**
+             * Format: int64
+             * @description Random seed for the search. Default `42`: omitting it is the same as
+             *     sending `42`, so send different values to explore different plans.
+             *     Repeated runs on one machine usually return an identical plan; a
+             *     materially faster or slower machine can differ.
+             * @example 42
+             */
+            seed?: number | null;
+            /**
+             * Format: double
+             * @description Search time budget in seconds, fractions allowed (default 1). Maximum
+             *     300: a larger value is rejected with HTTP 400. A value below 0.1 is
+             *     raised to a 100 ms floor. Pure search time: fetching travel times and
+             *     waiting for capacity are not deducted from it, so the request takes
+             *     longer than this value.
+             * @example 2.5
+             */
+            time_limit_s?: number | null;
+            /**
+             * @description What to do when Solvice Maps cannot answer (outage, timeout,
+             *     overload): `estimate` (the default) solves on estimated travel and
+             *     sets `summary.travel_estimated`; `fail` returns the 502/503
+             *     instead. A request Maps rejects as invalid always fails.
+             */
+            travel_fallback?: null | components["schemas"]["TravelFallback"];
+        };
+        /**
+         * @description Request body for `POST /v3/routing/solve`.
+         * @example {
+         *       "options": {
+         *         "seed": 42,
+         *         "time_limit_s": 5
+         *       },
+         *       "problem": {
+         *         "depots": [
+         *           {
+         *             "id": "gent",
+         *             "location": [
+         *               3.7174,
+         *               51.0543
+         *             ]
+         *           }
+         *         ],
+         *         "jobs": [
+         *           {
+         *             "id": "job-1",
+         *             "location": [
+         *               3.725,
+         *               51.05
+         *             ],
+         *             "pickup": {
+         *               "weight": 20
+         *             },
+         *             "service_duration_s": 300,
+         *             "skills": [
+         *               {
+         *                 "name": "fridge"
+         *               }
+         *             ],
+         *             "time_windows": [
+         *               {
+         *                 "from": "2026-07-01T09:00:00+02:00",
+         *                 "to": "2026-07-01T12:00:00+02:00"
+         *               }
+         *             ]
+         *           },
+         *           {
+         *             "id": "job-2",
+         *             "location": [
+         *               3.71,
+         *               51.06
+         *             ],
+         *             "pickup": {
+         *               "weight": 35
+         *             },
+         *             "service_duration_s": 600
+         *           }
+         *         ],
+         *         "objective": {
+         *           "costs": {
+         *             "per_route_hour": 35,
+         *             "per_travel_km": 0.2
+         *           },
+         *           "currency": "EUR"
+         *         },
+         *         "vehicles": [
+         *           {
+         *             "capacity": {
+         *               "weight": 500
+         *             },
+         *             "id": "v1",
+         *             "profile": "car",
+         *             "shifts": [
+         *               {
+         *                 "end": {
+         *                   "depot": "gent"
+         *                 },
+         *                 "from": "2026-07-01T08:00:00+02:00",
+         *                 "id": "mon",
+         *                 "start": {
+         *                   "depot": "gent"
+         *                 },
+         *                 "to": "2026-07-01T17:00:00+02:00"
+         *               }
+         *             ],
+         *             "skills": [
+         *               {
+         *                 "name": "fridge"
+         *               }
+         *             ]
+         *           }
+         *         ]
+         *       }
+         *     }
+         */
+        SolveRequest: {
+            /** @description Solve options. */
+            options?: null | components["schemas"]["SolveOptions"];
+            /**
+             * @description Warm start: the plan the search starts from instead of constructing
+             *     from scratch (re-optimization). A result's `plan` goes in as it stands.
+             *     See `plan.routes[].locked_count` for freezing a dispatched prefix.
+             *
+             *     A **hint, not a guarantee**: an unlocked stop that violates a hard
+             *     constraint (e.g. capacity, skills, eligibility, `limits.*`, or a time
+             *     window with no `per_late_hour` set) is left unassigned and the
+             *     search reinserts it wherever it legitimately fits, or it surfaces in
+             *     `unassigned[]` with a typed reason. An infeasible locked stop is a 400.
+             */
+            plan?: null | components["schemas"]["Plan"];
+            /** @description The problem: tasks, fleet, depots, relations, objective, travel. */
+            problem: components["schemas"]["ProblemInput"];
+        };
+        /**
+         * @description The result of `POST /v3/routing/solve` and `POST /v3/routing/evaluate`:
+         *     one shape for a plan the solver built and a plan it was given to score.
+         * @example {
+         *       "plan": {
+         *         "routes": [
+         *           {
+         *             "shift": "mon",
+         *             "stops": [
+         *               {
+         *                 "id": "job-1",
+         *                 "type": "job"
+         *               },
+         *               {
+         *                 "id": "job-2",
+         *                 "type": "job"
+         *               }
+         *             ],
+         *             "vehicle": "v1"
+         *           }
+         *         ]
+         *       },
+         *       "routes": [
+         *         {
+         *           "distance_m": 8450,
+         *           "load_peak": {
+         *             "weight": 55
+         *           },
+         *           "shift": "mon",
+         *           "stops": [
+         *             {
+         *               "arrival": "2026-07-01T08:00:00+02:00",
+         *               "departure": "2026-07-01T08:00:00+02:00",
+         *               "depot": "gent",
+         *               "load_after": {
+         *                 "weight": 0
+         *               },
+         *               "location": [
+         *                 3.7174,
+         *                 51.0543
+         *               ],
+         *               "service_s": 0,
+         *               "type": "start"
+         *             },
+         *             {
+         *               "arrival": "2026-07-01T08:10:00+02:00",
+         *               "departure": "2026-07-01T09:05:00+02:00",
+         *               "distance_m": 2600,
+         *               "id": "job-1",
+         *               "lateness_s": 0,
+         *               "load_after": {
+         *                 "weight": 20
+         *               },
+         *               "location": [
+         *                 3.725,
+         *                 51.05
+         *               ],
+         *               "service_s": 300,
+         *               "travel_s": 600,
+         *               "type": "job",
+         *               "wait_s": 3000
+         *             },
+         *             {
+         *               "arrival": "2026-07-01T09:13:00+02:00",
+         *               "departure": "2026-07-01T09:23:00+02:00",
+         *               "distance_m": 2350,
+         *               "id": "job-2",
+         *               "lateness_s": 0,
+         *               "load_after": {
+         *                 "weight": 55
+         *               },
+         *               "location": [
+         *                 3.71,
+         *                 51.06
+         *               ],
+         *               "service_s": 600,
+         *               "travel_s": 480,
+         *               "type": "job",
+         *               "wait_s": 0
+         *             },
+         *             {
+         *               "arrival": "2026-07-01T09:38:00+02:00",
+         *               "departure": "2026-07-01T09:38:00+02:00",
+         *               "depot": "gent",
+         *               "distance_m": 3500,
+         *               "load_after": {
+         *                 "weight": 55
+         *               },
+         *               "location": [
+         *                 3.7174,
+         *                 51.0543
+         *               ],
+         *               "service_s": 0,
+         *               "travel_s": 900,
+         *               "type": "end"
+         *             }
+         *           ],
+         *           "time": {
+         *             "break_s": 0,
+         *             "depot_s": 0,
+         *             "overtime_s": 0,
+         *             "service_s": 900,
+         *             "span_s": 5880,
+         *             "travel_s": 1980,
+         *             "wait_s": 3000
+         *           },
+         *           "vehicle": "v1"
+         *         }
+         *       ],
+         *       "summary": {
+         *         "distance_m": 8450,
+         *         "score": {
+         *           "components": {
+         *             "depot_visits": 0,
+         *             "distance": 1.69,
+         *             "drop_fees": 0,
+         *             "fixed": 0,
+         *             "grouping": 0,
+         *             "lateness": 0,
+         *             "other": 0,
+         *             "overtime": 0,
+         *             "tag_preference": 0,
+         *             "target": 0,
+         *             "time": 57.1536,
+         *             "waiting": 0,
+         *             "window_choice": 0
+         *           },
+         *           "cost": 58.8436,
+         *           "currency": "EUR",
+         *           "unserved_priority": 0,
+         *           "violations": 0
+         *         },
+         *         "shifts_used": 1,
+         *         "tasks": {
+         *           "served": 2,
+         *           "unserved": 0,
+         *           "unserved_required": 0
+         *         },
+         *         "time": {
+         *           "break_s": 0,
+         *           "depot_s": 0,
+         *           "overtime_s": 0,
+         *           "service_s": 900,
+         *           "span_s": 5880,
+         *           "travel_s": 1980,
+         *           "wait_s": 3000
+         *         },
+         *         "timings": {
+         *           "search_ms": 100,
+         *           "total_ms": 142
+         *         },
+         *         "vehicles_used": 1
+         *       },
+         *       "unassigned": []
+         *     }
+         */
+        SolveResponse: {
+            /**
+             * @description The plan these routes follow, in the request's vocabulary: valid input
+             *     to evaluate, suggest or a warm-started solve as it stands.
+             */
+            plan: components["schemas"]["Plan"];
+            /** @description One entry per non-empty route. */
+            routes: components["schemas"]["Route"][];
+            /** @description Aggregate statistics for the solve run. */
+            summary: components["schemas"]["Summary"];
+            /** @description Tasks that could not be feasibly assigned. */
+            unassigned: components["schemas"]["Unassigned"][];
+        };
+        /**
+         * @description One leg of a shipment (pickup or delivery).
+         * @example {
+         *       "id": "ship-1:pickup",
+         *       "location": [
+         *         3.725,
+         *         51.05
+         *       ],
+         *       "service_duration_s": 300,
+         *       "setup_duration_s": 60,
+         *       "time_windows": [
+         *         {
+         *           "from": "2026-07-01T09:00:00+02:00",
+         *           "to": "2026-07-01T12:00:00+02:00"
+         *         }
+         *       ]
+         *     }
+         */
+        Stop: {
+            /**
+             * @description Whether a break may interrupt service here. Default `true`. `false`
+             *     is not supported yet and is rejected with HTTP 400.
+             * @example true
+             */
+            break_interruptible?: boolean | null;
+            /**
+             * @description Stop id: 1 to 128 characters when set. Defaults to
+             *     `"{shipment}:pickup"` / `"{shipment}:delivery"`. The effective id
+             *     (custom or default) must be unique across all job, shipment, and stop
+             *     ids — a collision is rejected with HTTP 400.
+             * @example ship-1:pickup
+             */
+            id?: string | null;
+            /** @description Where this stop happens. */
+            location: components["schemas"]["Place"];
+            /**
+             * Format: int32
+             * @description On-site service time paid per job (seconds).
+             *
+             *     This is the nominal figure. The serving vehicle's `service_factor`
+             *     scales it — the time actually scheduled is
+             *     `service_duration_s / service_factor` — so the solution's
+             *     `stops[].service_s` may differ from what you sent here.
+             * @example 300
+             */
+            service_duration_s?: number | null;
+            /**
+             * Format: int32
+             * @description Setup time paid once on arrival at a new location (seconds),
+             *     distinct from `service_duration_s`. Skipped when the immediate real
+             *     predecessor in the route already sits at this location — co-located
+             *     stops share one setup.
+             *
+             *     Not scaled by the vehicle's `service_factor`: setup is fixed arrival
+             *     overhead (parking, walking to the door), not the work itself.
+             * @example 60
+             */
+            setup_duration_s?: number | null;
+            /** @description Time windows for this stop. */
+            time_windows?: components["schemas"]["TimeWindow"][] | null;
+        };
+        /**
+         * @description Which instant of a stop a `target` or a relation refers to. One vocabulary
+         *     for both, each accepting the values that mean something there.
+         * @enum {string}
+         */
+        StopInstant: "arrival" | "start" | "end";
+        /**
+         * @description A single stop within a route.
+         * @example {
+         *       "arrival": "2026-07-01T08:10:00+02:00",
+         *       "departure": "2026-07-01T09:05:00+02:00",
+         *       "distance_m": 2600,
+         *       "id": "job-1",
+         *       "lateness_s": 0,
+         *       "load_after": {
+         *         "weight": 20
+         *       },
+         *       "location": [
+         *         3.725,
+         *         51.05
+         *       ],
+         *       "service_s": 300,
+         *       "travel_s": 600,
+         *       "type": "job",
+         *       "wait_s": 3000
+         *     }
+         */
+        StopOutput: {
+            /**
+             * Format: date-time
+             * @description Physical arrival time (RFC 3339), before any waiting; the service
+             *     start is `arrival + wait_s`. Every stop time is rendered in the UTC
+             *     offset of the route's shift `from` (`Z` when that `from` is UTC or has
+             *     no offset): a `+02:00` shift reports `2026-07-01T08:10:00+02:00`, the
+             *     same instant as `2026-07-01T06:10:00Z`.
+             * @example 2026-07-01T08:10:00+02:00
+             */
+            arrival?: string | null;
+            /**
+             * Format: date-time
+             * @description Departure time (RFC 3339, in the offset of `arrival`).
+             * @example 2026-07-01T09:05:00+02:00
+             */
+            departure?: string | null;
+            /**
+             * @description The `depots[].id` of this stop: on a `start`/`end` stop whose shift end
+             *     names a depot, and on every `reload` stop. Absent on a `location` or
+             *     open end and on task and break stops.
+             * @example gent
+             */
+            depot?: string | null;
+            /**
+             * Format: int32
+             * @description Travel distance from the previous stop, in metres.
+             * @example 2600
+             */
+            distance_m?: number | null;
+            /**
+             * Format: int32
+             * @description The part of `wait_s` spent holding for a `synchronized` or
+             *     `time_lag` partner on another vehicle, beyond any wait the time
+             *     window already imposed. Present on task stops only when non-zero.
+             * @example 0
+             */
+            hold_s?: number | null;
+            /**
+             * @description Stop id: the job id on a `job` stop, the leg's stop id on
+             *     `pickup`/`delivery` (its own `id`, else `{shipment}:pickup` /
+             *     `{shipment}:delivery`). Absent on start, end, break and reload stops.
+             * @example job-1
+             */
+            id?: string | null;
+            /**
+             * Format: int32
+             * @description Seconds late beyond the latest allowed arrival (`0` when on time).
+             *     Measures the hard time window only; a soft target is reported in
+             *     `target_lateness_s`.
+             * @example 0
+             */
+            lateness_s?: number | null;
+            /** @description Cumulative load carried after this stop, by named dimension. */
+            load_after?: null | components["schemas"]["BTreeMap"];
+            /**
+             * @description Stop location `[longitude, latitude]` (GeoJSON order). Absent on
+             *     every `break` stop, including a break with a pinned location, and on
+             *     `start`/`end` stops for a genuinely open leg (no configured depot
+             *     coordinate for that end of the shift). A virtual (location-less) job
+             *     has no coordinate of its own and reports its nearest located
+             *     neighbor's instead, so it is absent only when the whole route is
+             *     virtual with open depot ends.
+             * @example [
+             *       3.725,
+             *       51.05
+             *     ]
+             */
+            location?: number[] | null;
+            /**
+             * Format: int32
+             * @description On-site service time at this stop, in seconds.
+             *
+             *     The **effective** time, not the nominal `service_duration_s` from the
+             *     request: on a task stop it already has the serving vehicle's
+             *     `service_factor` applied. The timeline reconciles as
+             *     `departure - arrival - wait_s == service_s` only when the stop pays no
+             *     setup time; with `setup_duration_s` set, the difference is larger by
+             *     the (unscaled) setup seconds. Depot, reload, and break stops report
+             *     their own nominal handling/break duration, which `service_factor`
+             *     never scales.
+             *
+             *     On `start`/`end`: the depot handling time applied there (0 on an
+             *     ignored leg); absent on an open end.
+             * @example 300
+             */
+            service_s?: number | null;
+            /**
+             * Format: date-time
+             * @description When service starts (RFC 3339, in the offset of `arrival`): after the
+             *     arrival, any windowed
+             *     break taken on arrival there, and the wait. On task and reload stops;
+             *     like `arrival`, absent on a request without time windows.
+             * @example 2026-07-01T09:00:00+02:00
+             */
+            service_start?: string | null;
+            /** @description The same point snapped to the routable graph, when available. */
+            snapped_location?: number[] | null;
+            /**
+             * Format: int32
+             * @description Seconds past this task's `target.at`, measured at the stop's arrival
+             *     or departure per `target.on`; `0` when met. Present only on a task
+             *     stop carrying a target. A shipment's target is measured
+             *     on its delivery leg, so it appears on the `:delivery` stop and never on
+             *     the `:pickup` stop.
+             * @example 0
+             */
+            target_lateness_s?: number | null;
+            /**
+             * Format: int32
+             * @description Travel time from the previous stop, in seconds.
+             * @example 600
+             */
+            travel_s?: number | null;
+            /** @description What kind of stop this is. */
+            type: components["schemas"]["StopType"];
+            /**
+             * @description Constraint violations detected at this stop. Only populated by
+             *     `POST /v3/routing/evaluate` (imported solutions may be infeasible); a
+             *     solve response never emits violations, so this is absent there.
+             */
+            violations?: components["schemas"]["Violation"][];
+            /**
+             * Format: int32
+             * @description Seconds spent waiting here before service: for the time window to
+             *     open, and for any cross-route hold (`hold_s`, included in this
+             *     figure).
+             * @example 3000
+             */
+            wait_s?: number | null;
+        };
+        /**
+         * @description The kind of a stop in a route.
+         *
+         *     Every route has one `start` and one `end`. A served job is `job`, and a
+         *     shipment's legs are `pickup` and `delivery`. A driver break is `break`,
+         *     and a mid-shift reload at a depot is `reload`.
+         * @example job
+         * @enum {string}
+         */
+        StopType: "start" | "job" | "pickup" | "delivery" | "break" | "reload" | "end";
+        /**
+         * @description Suggest options.
+         * @example {
+         *       "max_suggestions": 5,
+         *       "time_limit_s": 2
+         *     }
+         */
+        SuggestOptions: {
+            /**
+             * @description Max ranked options per task. Default 5; `0` returns every feasible
+             *     placement; positive values are clamped to `1..=100`.
+             * @example 5
+             */
+            max_suggestions?: number | null;
+            /**
+             * Format: double
+             * @description Search budget in seconds, fractions allowed (default 1, as on `/solve`;
+             *     minimum 0.1 — smaller values are raised to it; maximum 300). The clock
+             *     starts when the search starts, after the matrix fetch and any wait for a
+             *     solver slot. Units are searched in problem order (jobs, then
+             *     shipments), each with an equal share of the time left when it starts; a
+             *     unit that finishes early leaves its slack to the ones after it.
+             * @example 2.5
+             */
+            time_limit_s?: number | null;
+        };
+        /**
+         * @description Why a unit's `insertions` is empty: the machine-readable form of
+         *     `reason`, to branch on.
+         *
+         *     Open set: values may be added within `/v3`. Accept values not listed here
+         *     and handle them generically, for example by showing `reason`.
+         * @example infeasible
+         * @enum {string}
+         */
+        SuggestReasonCode: "time_limit" | "candidates_exhausted" | "infeasible";
+        /**
+         * @description Request body for `POST /v3/routing/suggest`.
+         *
+         *     The same body as `POST /v3/routing/evaluate`, plus optional `options`.
+         *     Given the committed `plan` over `problem`, ranks the feasible insertion
+         *     positions for every task of `problem` that is not in `plan` — the tasks a
+         *     solve would place and an evaluate would report as unassigned. Each task
+         *     (or unit — a shipment, or tasks tied by one `sequence`/`same_vehicle`/
+         *     `same_day`/`same_route` relation) is ranked independently against the same
+         *     committed plan; the plan is never modified.
+         * @example {
+         *       "options": {
+         *         "max_suggestions": 5
+         *       },
+         *       "plan": {
+         *         "routes": [
+         *           {
+         *             "shift": "mon",
+         *             "stops": [
+         *               {
+         *                 "id": "job-1",
+         *                 "type": "job"
+         *               }
+         *             ],
+         *             "vehicle": "v1"
+         *           }
+         *         ]
+         *       },
+         *       "problem": {
+         *         "jobs": [
+         *           {
+         *             "id": "job-1",
+         *             "location": [
+         *               3.725,
+         *               51.05
+         *             ],
+         *             "pickup": {
+         *               "weight": 10
+         *             },
+         *             "service_duration_s": 300
+         *           },
+         *           {
+         *             "id": "job-2",
+         *             "location": [
+         *               3.71,
+         *               51.06
+         *             ],
+         *             "pickup": {
+         *               "weight": 10
+         *             },
+         *             "service_duration_s": 300
+         *           }
+         *         ],
+         *         "vehicles": [
+         *           {
+         *             "capacity": {
+         *               "weight": 500
+         *             },
+         *             "id": "v1",
+         *             "shifts": [
+         *               {
+         *                 "end": {
+         *                   "location": [
+         *                     3.7174,
+         *                     51.0543
+         *                   ]
+         *                 },
+         *                 "from": "2026-07-01T08:00:00+02:00",
+         *                 "id": "mon",
+         *                 "start": {
+         *                   "location": [
+         *                     3.7174,
+         *                     51.0543
+         *                   ]
+         *                 },
+         *                 "to": "2026-07-01T17:00:00+02:00"
+         *               }
+         *             ]
+         *           }
+         *         ]
+         *       }
+         *     }
+         */
+        SuggestRequest: {
+            /** @description Suggest options. Absent: the defaults. */
+            options?: null | components["schemas"]["SuggestOptions"];
+            /**
+             * @description The committed plan. Never modified, never reordered. On suggest,
+             *     `locked_count` keeps insertions after a route's dispatched prefix.
+             */
+            plan: components["schemas"]["Plan"];
+            /**
+             * @description Problem definition — identical to `POST /v3/routing/solve`. Every task
+             *     of it that is not in `plan` is a task to place.
+             */
+            problem: components["schemas"]["ProblemInput"];
+        };
+        /**
+         * @description Response body for `POST /v3/routing/suggest`.
+         * @example {
+         *       "elapsed_ms": 8,
+         *       "suggestions": [
+         *         {
+         *           "insertions": [
+         *             {
+         *               "delta": {
+         *                 "cost": 12.4,
+         *                 "distance_m": 2400,
+         *                 "duration_s": 240
+         *               },
+         *               "placements": [
+         *                 {
+         *                   "arrival": "2026-07-01T09:30:00+02:00",
+         *                   "id": "job-2",
+         *                   "latest_arrival": "2026-07-01T10:15:00+02:00",
+         *                   "shift": "mon",
+         *                   "type": "job",
+         *                   "vehicle": "v1"
+         *                 }
+         *               ],
+         *               "routes": [
+         *                 {
+         *                   "shift": "mon",
+         *                   "stops": [
+         *                     {
+         *                       "id": "job-1",
+         *                       "type": "job"
+         *                     },
+         *                     {
+         *                       "id": "job-2",
+         *                       "type": "job"
+         *                     }
+         *                   ],
+         *                   "vehicle": "v1"
+         *                 }
+         *               ]
+         *             }
+         *           ],
+         *           "job_id": "job-2"
+         *         }
+         *       ],
+         *       "truncated": false
+         *     }
+         */
+        SuggestResponse: {
+            /**
+             * Format: int64
+             * @description Wall-clock time taken by the request, in milliseconds.
+             * @example 8
+             */
+            elapsed_ms: number;
+            /**
+             * @description One entry per unit of tasks outside `plan`, in problem order (jobs,
+             *     then shipments; a relation group sorts at its first-listed member).
+             */
+            suggestions: components["schemas"]["JobSuggestions"][];
+            /**
+             * @description `true` when `options.time_limit_s` cut the search short, or a
+             *     multi-member unit came back empty after the search had discarded
+             *     candidates (an inconclusive "not found"; its `reason_code` is
+             *     `candidates_exhausted`). Lists may then be incomplete or missing the
+             *     best insertion. A single visit's only level is never pruned, so its
+             *     empty list is proof of infeasibility unless the budget cut it, and its
+             *     `reason_code` is then `time_limit`.
+             */
+            truncated?: boolean;
+        };
+        /**
+         * @description The plan in numbers: its score, what it serves and what it takes.
+         * @example {
+         *       "distance_m": 8450,
+         *       "score": {
+         *         "components": {
+         *           "depot_visits": 0,
+         *           "distance": 1.69,
+         *           "drop_fees": 0,
+         *           "fixed": 0,
+         *           "grouping": 0,
+         *           "lateness": 0,
+         *           "other": 0,
+         *           "overtime": 0,
+         *           "tag_preference": 0,
+         *           "target": 0,
+         *           "time": 57.1536,
+         *           "waiting": 0,
+         *           "window_choice": 0
+         *         },
+         *         "cost": 58.8436,
+         *         "currency": "EUR",
+         *         "unserved_priority": 0,
+         *         "violations": 0
+         *       },
+         *       "shifts_used": 1,
+         *       "tasks": {
+         *         "served": 2,
+         *         "unserved": 0,
+         *         "unserved_required": 0
+         *       },
+         *       "time": {
+         *         "break_s": 0,
+         *         "depot_s": 0,
+         *         "overtime_s": 0,
+         *         "service_s": 900,
+         *         "span_s": 5880,
+         *         "travel_s": 1980,
+         *         "wait_s": 3000
+         *       },
+         *       "timings": {
+         *         "search_ms": 100,
+         *         "total_ms": 142
+         *       },
+         *       "vehicles_used": 1
+         *     }
+         */
+        Summary: {
+            /**
+             * Format: int64
+             * @description Sum of all route distances, in metres.
+             * @example 8450
+             */
+            distance_m: number;
+            /**
+             * @description How good the plan is. On `/solve`, `score.violations` is always 0; on
+             *     `/evaluate` it counts the constraints the given plan breaks.
+             */
+            score: components["schemas"]["Score"];
+            /**
+             * Format: int32
+             * @description Routes with at least one task stop: one per used shift.
+             * @example 1
+             */
+            shifts_used: number;
+            /** @description Tasks served and left out. */
+            tasks: components["schemas"]["TaskCounts"];
+            /** @description Where the fleet's time goes, summed over routes. */
+            time: components["schemas"]["TimeTotals"];
+            /** @description Where the request's time went. */
+            timings: components["schemas"]["Timings"];
+            /**
+             * @description `true` when Solvice Maps could not be reached and the plan was costed
+             *     on estimated travel: straight-line distance × a detour factor, at a
+             *     typical speed for the profile. No one-way streets or traffic, so it
+             *     can be tens of percent off: the plan, `unassigned[].reasons` and
+             *     `score.violations` hold only against it, and no `routes[].polyline` is
+             *     returned. Solve again once Maps is back if the plan must hold on the
+             *     road; `options.travel_fallback: "fail"` returns the error instead.
+             *     Absent when travel is road-routed.
+             */
+            travel_estimated?: boolean;
+            /**
+             * Format: int32
+             * @description Distinct vehicles with at least one route.
+             * @example 1
+             */
+            vehicles_used: number;
+        };
+        /**
+         * @description A soft tag preference, priced.
+         * @example {
+         *       "tag": "north",
+         *       "violation_cost": 25
+         *     }
+         */
+        TagPreference: {
+            /**
+             * @description Preferred tag.
+             * @example north
+             */
+            tag: string;
+            /**
+             * Format: double
+             * @description Cost, in the objective's currency, incurred when a task without this
+             *     tag is served.
+             * @example 25
+             */
+            violation_cost: number;
+        };
+        /**
+         * @description Soft target: reaching the task's `on` instant after `at` is allowed but
+         *     priced. Distinct from a hard time window — a target is a point, never
+         *     causes infeasibility, and (unlike a window's `from`) never forces the
+         *     vehicle to wait when it is early.
+         * @example {
+         *       "at": "2026-07-01T10:00:00+02:00",
+         *       "on": "arrival",
+         *       "per_late_hour": 60
+         *     }
+         */
+        Target: {
+            /**
+             * Format: date-time
+             * @description Target instant (RFC 3339, UTC offset required) the `on` instant is measured against.
+             * @example 2026-07-01T10:00:00+02:00
+             */
+            at: string;
+            /**
+             * @description Which instant of the task is compared to `at`: `arrival` (default) or
+             *     `end`. `start` is rejected with HTTP 400.
+             */
+            on?: null | components["schemas"]["StopInstant"];
+            /**
+             * Format: double
+             * @description Cost, in the objective's currency, per hour of `on` beyond `at`
+             *     (linear, prorated per second). Must be `> 0`; independent of
+             *     `objective.per_late_hour` (which prices *time-window* lateness,
+             *     not a target point).
+             * @example 60
+             */
+            per_late_hour: number;
+        };
+        /**
+         * @description How many tasks the plan serves. A job is one task; a shipment (pickup
+         *     plus delivery) is one task.
+         * @example {
+         *       "served": 2,
+         *       "unserved": 0,
+         *       "unserved_required": 0
+         *     }
+         */
+        TaskCounts: {
+            /**
+             * Format: int32
+             * @description Tasks on a route.
+             */
+            served: number;
+            /**
+             * Format: int32
+             * @description Tasks on no route: the length of `unassigned`.
+             */
+            unserved: number;
+            /**
+             * Format: int32
+             * @description The unserved tasks that carry no `drop_fee`: tasks the plan was
+             *     required to serve and did not.
+             */
+            unserved_required: number;
+        };
+        /**
+         * @description One end of a `time_lag` relation.
+         * @example {
+         *       "on": "end",
+         *       "stop": "job-1"
+         *     }
+         */
+        TimeLagEnd: {
+            /**
+             * @description Which instant of the job the bound is measured at: `start` (default) or
+             *     `end`. `arrival` is rejected with HTTP 400.
+             */
+            on?: null | components["schemas"]["StopInstant"];
+            /**
+             * @description A job id (shipment legs are not supported yet).
+             * @example job-1
+             */
+            stop: string;
+        };
+        /**
+         * @description Where a route's time goes, in seconds. On the summary: the sum over
+         *     routes.
+         *
+         *     `span_s` is the wall-clock span, from the start stop's `arrival` to the
+         *     end stop's `departure`; it is what `per_route_hour` is charged on. The
+         *     other fields break it down. They do not sum to `span_s` exactly: two
+         *     parts of the span have no field of their own, setup time
+         *     (`setup_duration_s`) and the idle before a windowed break's window opens
+         *     (`wait_s` is measured after that break). And a `fixed` break that begins
+         *     while the vehicle is driving overlaps that drive: the overlap is in both
+         *     `travel_s` and `break_s`, so on such a route the parts can exceed
+         *     `span_s`.
+         * @example {
+         *       "break_s": 0,
+         *       "depot_s": 0,
+         *       "overtime_s": 0,
+         *       "service_s": 900,
+         *       "span_s": 5880,
+         *       "travel_s": 1980,
+         *       "wait_s": 3000
+         *     }
+         */
+        TimeTotals: {
+            /**
+             * Format: int64
+             * @description Time on driver breaks.
+             */
+            break_s: number;
+            /**
+             * Format: int64
+             * @description Handling time at start, end and reload stops.
+             */
+            depot_s: number;
+            /**
+             * Format: int64
+             * @description The part of the span after the shift's `to` (possible only with
+             *     `max_overtime_s`).
+             */
+            overtime_s: number;
+            /**
+             * Format: int64
+             * @description On-site service time at job, pickup and delivery stops.
+             */
+            service_s: number;
+            /**
+             * Format: int64
+             * @description Wall-clock span: travel, service, setup, depot handling, waiting and
+             *     breaks.
+             */
+            span_s: number;
+            /**
+             * Format: int64
+             * @description Driving time: the sum of the stops' `travel_s`.
+             */
+            travel_s: number;
+            /**
+             * Format: int64
+             * @description Waiting before service, cross-route holds included.
+             */
+            wait_s: number;
+        };
+        /**
+         * @description A time window. Hard unless it (or `objective.per_late_hour`, for
+         *     every window) prices lateness.
+         * @example {
+         *       "cost": 15,
+         *       "from": "2026-07-01T09:00:00+02:00",
+         *       "to": "2026-07-01T12:00:00+02:00"
+         *     }
+         */
+        TimeWindow: {
+            /**
+             * Format: double
+             * @description Optional flat cost, in the objective's currency, added when this
+             *     job/stop is served within THIS window rather than a free/cheaper
+             *     alternative window on the same task. Absent = 0 (no charge). Every
+             *     window in the list remains individually hard — a job must still land
+             *     in *some* window — this only grades preference among the hard
+             *     alternatives; it does not soften time-window feasibility. Must be
+             *     finite and `>= 0`, and requires at least 2 windows on the task. Once
+             *     any window on the task carries a *nonzero* cost, that task's windows
+             *     must also be pairwise non-overlapping (a task whose costs are all
+             *     `0`/absent has its overlapping windows merged).
+             *
+             *     **Cannot be combined with `objective.per_late_hour > 0`** — a
+             *     nonzero window `cost` anywhere in the request alongside priced lateness
+             *     is rejected with HTTP 400 (the two read opposite ways about which
+             *     window was paid for). Choose one: priced alternative windows, or priced
+             *     lateness.
+             */
+            cost?: number | null;
+            /**
+             * Format: date-time
+             * @description Earliest allowed arrival (RFC 3339 instant, UTC offset required).
+             * @example 2026-07-01T09:00:00+02:00
+             */
+            from: string;
+            /**
+             * Format: double
+             * @description Makes this window soft on its late side: arriving after `to` is
+             *     allowed and priced at this rate, in the objective's currency per hour
+             *     late, in place of `objective.per_late_hour` (and whether or not
+             *     that is set, so hard and soft windows can share one request). Must be
+             *     `> 0`; omit it for a hard window. Only on a
+             *     task with exactly one window. Arriving early still waits for `from`.
+             * @example 60
+             */
+            per_late_hour?: number | null;
+            /**
+             * Format: date-time
+             * @description Latest allowed arrival (RFC 3339 instant, UTC offset required).
+             * @example 2026-07-01T12:00:00+02:00
+             */
+            to: string;
+        };
+        /**
+         * @description Where the request's wall-clock time went, in milliseconds.
+         * @example {
+         *       "search_ms": 100,
+         *       "total_ms": 142
+         *     }
+         */
+        Timings: {
+            /**
+             * Format: int64
+             * @description Time spent in the search. Absent on `/evaluate`, which runs none.
+             */
+            search_ms?: number | null;
+            /**
+             * Format: int64
+             * @description From the request's arrival to the end of the search (of the scoring,
+             *     on `/evaluate`): fetching travel times and waiting for capacity
+             *     included, building the response not.
+             */
+            total_ms: number;
+        };
+        /**
+         * @description Where travel times and distances come from.
+         *
+         *     Matrices are traffic-aware (historical-typical traffic); by default travel
+         *     times reflect traffic at the moment the request is processed. Set
+         *     `departure_time` to plan against another instant — e.g. tomorrow's 08:00
+         *     routes with morning-rush travel times, or a replay of a past run under its
+         *     original conditions.
+         * @example {
+         *       "departure_time": "2026-07-01T08:00:00+02:00",
+         *       "engine": "tomtom"
+         *     }
+         */
+        Travel: {
+            /**
+             * Format: date-time
+             * @description Departure time for the traffic lookup (RFC 3339 instant, any offset).
+             *     Omitted → traffic at solve time. An explicit departure time bypasses
+             *     the server-side matrix cache.
+             * @example 2026-07-01T08:00:00+02:00
+             */
+            departure_time?: string | null;
+            /**
+             * @description Road-network data behind travel times and distances. Omitted →
+             *     `tomtom`.
+             */
+            engine?: null | components["schemas"]["MatrixEngine"];
+        };
+        /**
+         * @description [`SolveOptions::travel_fallback`]: what a solve does when travel times
+         *     cannot be fetched.
+         * @example estimate
+         * @enum {string}
+         */
+        TravelFallback: "estimate" | "fail";
+        /**
+         * @description What a break trigger accumulates.
+         * @example drive
+         * @enum {string}
+         */
+        TriggerAfter: "drive" | "duty";
+        /**
+         * @description A job the solver could not assign to any vehicle.
+         * @example {
+         *       "category": "blocked",
+         *       "job_id": "job-2",
+         *       "reasons": [
+         *         {
+         *           "code": "TIME_WINDOW_VIOLATED",
+         *           "message": "No vehicle can reach this job within its time window."
+         *         }
+         *       ],
+         *       "relaxations": [
+         *         {
+         *           "amount": 900,
+         *           "field": "/jobs/job-2/time_windows",
+         *           "op": "extend_time_window",
+         *           "suggestion": "Extend a time window by 900s (~15 min).",
+         *           "unit": "s"
+         *         }
+         *       ]
+         *     }
+         */
+        Unassigned: {
+            /** @description Which kind of "unassigned" this is. */
+            category?: components["schemas"]["UnassignedCategory"];
+            /**
+             * @description The unassigned job id.
+             * @example job-2
+             */
+            job_id: string;
+            /** @description Structured reasons the job could not be served. */
+            reasons: components["schemas"]["UnassignedReason"][];
+            /**
+             * @description Best-effort, actionable relaxation suggestions. Empty when no simple
+             *     relaxation exists (e.g. a skills mismatch).
+             */
+            relaxations: components["schemas"]["Relaxation"][];
+        };
+        /**
+         * @description Which kind of "unassigned" a task is.
+         * @example priced_out
+         * @enum {string}
+         */
+        UnassignedCategory: "impossible" | "blocked" | "priced_out" | "search_limit";
+        /**
+         * @description A machine-readable reason a task could not be assigned.
+         * @example {
+         *       "code": "TIME_WINDOW_VIOLATED",
+         *       "message": "No vehicle can reach this job within its time window."
+         *     }
+         */
+        UnassignedReason: {
+            /**
+             * @description Stable machine code. Closed set of eleven values — exactly one of:
+             *     `SOLVER_LIMIT` (a feasible slot existed but the time budget ran out),
+             *     `CAPACITY_EXCEEDED`, `TIME_WINDOW_VIOLATED`, `CAPACITY_AND_TIME_WINDOW`,
+             *     `SKILLS_MISMATCH`, `TAG_RESTRICTED`, `COMMITMENT_BLOCKED`,
+             *     `VEHICLE_EXCLUDED`, `VEHICLE_RANGE_EXCEEDED`, `UNREACHABLE_LOCATION`,
+             *     or `ALL_ROUTES_BLOCKED` (a mix no single code describes).
+             *     `UNREACHABLE_LOCATION` outranks the others when it applies:
+             *     a coordinate the routing engine cannot reach is a fact about the input,
+             *     not about the fleet. Treat an unrecognised value as
+             *     `ALL_ROUTES_BLOCKED`.
+             * @example TIME_WINDOW_VIOLATED
+             */
+            code: string;
+            /**
+             * @description Human-readable explanation.
+             * @example No vehicle can reach this job within its time window.
+             */
+            message: string;
+        };
+        /**
+         * @description The 200 body of a `?validate_only=true` call: the request passed every
+         *     check a real call runs before the matrix fetch.
+         * @example {
+         *       "valid": true,
+         *       "warnings": []
+         *     }
+         */
+        ValidateOnlyResponse: {
+            /** @description Always `true`: an invalid request gets a 400 instead. */
+            valid: boolean;
+            /** @description Warnings a real call would return, in the error item shape. */
+            warnings: components["schemas"]["ErrorItem"][];
+        };
+        /**
+         * @description A vehicle type available to serve tasks.
+         * @example {
+         *       "capacity": {
+         *         "volume": 20,
+         *         "weight": 500
+         *       },
+         *       "id": "v1",
+         *       "profile": "car",
+         *       "shifts": [
+         *         {
+         *           "end": {
+         *             "location": [
+         *               3.7174,
+         *               51.0543
+         *             ]
+         *           },
+         *           "from": "2026-07-01T08:00:00+02:00",
+         *           "id": "mon",
+         *           "start": {
+         *             "location": [
+         *               3.7174,
+         *               51.0543
+         *             ]
+         *           },
+         *           "to": "2026-07-01T17:00:00+02:00"
+         *         }
+         *       ],
+         *       "skills": [
+         *         {
+         *           "name": "fridge"
+         *         }
+         *       ]
+         *     }
+         */
+        Vehicle: {
+            /** @description Named capacity dimensions. */
+            capacity?: null | components["schemas"]["BTreeMap"];
+            /**
+             * @description Vehicles this one may serve a `compatible_vehicles` relation's tasks
+             *     together with, by id. Absent: any vehicle. A list is a veto, so a
+             *     one-sided list still binds both vehicles: two vehicles may share a
+             *     relation only if neither's list excludes the other. A vehicle always
+             *     pairs with itself and all its shifts count as one vehicle; to pair a
+             *     vehicle with no other, list only its own id. An empty list is rejected
+             *     with HTTP 400 (it would read as "everyone" in a client that drops empty
+             *     arrays), and so is an id that names no vehicle. Inert unless a
+             *     `compatible_vehicles` relation names tasks.
+             * @example [
+             *       "v2",
+             *       "v3"
+             *     ]
+             */
+            compatible_with?: string[] | null;
+            /**
+             * @description This vehicle's costs. Each field set here replaces the same field of
+             *     `objective.costs` for this vehicle; fields not set keep the fleet
+             *     value. A shift's own `costs` replace these per field in turn.
+             */
+            costs?: null | components["schemas"]["Costs"];
+            /**
+             * @description Vehicle id: 1 to 128 characters, unique across `vehicles[]`; echoed as
+             *     `routes[].vehicle`.
+             * @example v1
+             */
+            id: string;
+            /** @description Hard operating limits. */
+            limits?: null | components["schemas"]["VehicleLimits"];
+            /**
+             * @description Soft tag preferences. Serving a task that does not
+             *     carry a preferred tag incurs that entry's `violation_cost`. Entries
+             *     apply independently: a task lacking several preferred tags incurs each
+             *     cost.
+             */
+            preferred_tags?: components["schemas"]["TagPreference"][] | null;
+            /**
+             * @description Routing profile: `car` (default), `truck` or `bike` — selects the road
+             *     network and speeds behind this vehicle's travel times and distances.
+             *     Any other value is rejected with HTTP 400.
+             */
+            profile?: null | components["schemas"]["Profile"];
+            /**
+             * Format: double
+             * @description Work-rate multiplier for service time at stops (1.0 = base rate).
+             *
+             *     Same direction as `speed_factor`: effective service time =
+             *     `service_duration_s / service_factor`, so values > 1.0 model a driver who
+             *     works FASTER and spends less time at each stop, and < 1.0 one who is
+             *     slower. Use it for crew size, equipment, or experience — how quickly the
+             *     work gets done, as distinct from how fast the vehicle drives.
+             *
+             *     Applies to job/stop `service_duration_s` only. Deliberately NOT applied
+             *     to `setup_duration_s` (fixed arrival overhead such as parking),
+             *     depot handling (`depots[].service_duration_s`,
+             *     `start`/`end.service_duration_s`), waiting time, or break durations.
+             *
+             *     Must be in `(0, 5]`. Default 1.0. A shift may override it for its own
+             *     day with `shifts[].service_factor`.
+             */
+            service_factor?: number | null;
+            /** @description One or more working shifts. */
+            shifts: components["schemas"]["Shift"][];
+            /**
+             * @description Capabilities the vehicle provides. A job's `skills` must all appear
+             *     here at a level of at least the job's `min_level`. Each entry is an
+             *     object `{ "name": ..., "level": N }` (`level` optional, default 1);
+             *     a bare string is rejected. A skill may appear once per list. Omitting
+             *     the field is the same as `[]`: the vehicle can only serve jobs that
+             *     require no skills.
+             */
+            skills?: components["schemas"]["VehicleSkill"][] | null;
+            /**
+             * Format: double
+             * @description Travel-speed multiplier (1.0 = base speed). Effective travel time =
+             *     `base travel time / speed_factor`, so values > 1.0 model a faster
+             *     vehicle and < 1.0 a slower one. Must be in `(0, 5]`. Default 1.0.
+             *
+             *     Covers driving only. Its companion `service_factor` scales the
+             *     work done at stops; the two are independent and share this direction and
+             *     range.
+             */
+            speed_factor?: number | null;
+        };
+        /**
+         * @description Vehicle distance/time limits.
+         * @example {
+         *       "max_distance_m": 200000,
+         *       "max_route_duration_s": 32400
+         *     }
+         */
+        VehicleLimits: {
+            /**
+             * Format: int64
+             * @description Hard maximum distance in metres.
+             * @example 200000
+             */
+            max_distance_m?: number | null;
+            /**
+             * Format: int64
+             * @description Hard cap in seconds on any single travel leg of this vehicle's routes:
+             *     the `travel_time_s` reported on each stop, start-to-first-task and
+             *     last-task-to-`end` included. Travel only: setup, service and wait do
+             *     not count, and `speed_factor` applies first. A leg made free by
+             *     `ignore_start_leg`/`ignore_end_leg`, or absent on an open start or
+             *     end, is exempt. Absent = no cap. Must be > 0: `0` would make every
+             *     leg too long rather than mean "no cap", so it is rejected with HTTP
+             *     400 `out_of_range`, as is a value that does not fit in 32 bits.
+             * @example 3600
+             */
+            max_leg_travel_time_s?: number | null;
+            /**
+             * Format: int64
+             * @description Hard maximum route duration in seconds: the whole-route span —
+             *     travel, service, and wait all count, depot load and unload included.
+             *     The same quantity as the response's `routes[].time.span_s`.
+             * @example 32400
+             */
+            max_route_duration_s?: number | null;
+            /**
+             * Format: int32
+             * @description Maximum stops served per shift: a job counts as one stop, a shipment
+             *     as two (pickup and delivery).
+             * @example 50
+             */
+            max_tasks?: number | null;
+            /**
+             * @description Hard caps on this vehicle's totals across all of its shifts in a day,
+             *     a week or an explicit window. Each shift counts toward the one
+             *     period that contains its `from`, read in that shift's own UTC offset.
+             *     A recurring period with none of the vehicle's shifts is skipped; an
+             *     explicit window with no shift start is a 400.
+             */
+            periods?: components["schemas"]["PeriodLimit"][];
+        };
+        /**
+         * @description A capability a vehicle or shift provides, at a proficiency level:
+         *     `{ "name": "gas", "level": 3 }`. Always an object; a bare string is
+         *     rejected at parse.
+         * @example {
+         *       "level": 3,
+         *       "name": "gas"
+         *     }
+         */
+        VehicleSkill: {
+            /**
+             * Format: int32
+             * @description Proficiency level, `>= 1`; absent = 1. Satisfies every job
+             *     requirement of this skill whose `min_level` is at most this value.
+             * @example 3
+             */
+            level?: number | null;
+            /**
+             * @description Skill name.
+             * @example gas
+             */
+            name: string;
+        };
+        /**
+         * @description A single constraint violation detected while evaluating an imported solution.
+         *
+         *     Reported on stops (`routes[].stops[].violations`) and on routes
+         *     (`routes[].violations`) in the `POST /v3/routing/evaluate` response.
+         * @example {
+         *       "message": "Cumulative load 30 exceeds vehicle capacity 15 (dimension weight)",
+         *       "type": "capacity"
+         *     }
+         */
+        Violation: {
+            /**
+             * @description Human-readable description of what was violated.
+             * @example Cumulative load 30 exceeds vehicle capacity 15 (dimension weight)
+             */
+            message: string;
+            /**
+             * @description Machine-readable violation type: `time_window`, `capacity`, `skills`,
+             *     `tags`, `first_job`, `unreachable`, `commitment`, `eligibility`,
+             *     `same_vehicle`, `same_day`, `same_route`, `synchronized`, `time_lag`,
+             *     `max_distance`, `max_duration`, `shift_end`, `sequence`, `max_tasks`,
+             *     `break`, `shipment`, `multi_trip`, `period_limit` (a `limits.periods`
+             *     cap, reported once per period on the route of its first used shift),
+             *     `quota` (a `quotas[]` cap, reported the same way), or `infeasible`
+             *     (the insertion check refused a stop without naming a constraint; not
+             *     expected in practice). `max_tasks`, `break`, `multi_trip`,
+             *     `period_limit` and `quota` are route-level; `sequence` and
+             *     `shipment` are on the stop.
+             *
+             *     Deliberately an open string rather than an enum: stop-level types come
+             *     from the active constraint set, so a new constraint can add one without
+             *     a breaking schema change. Match on the values you handle and treat
+             *     unknown ones as generic violations.
+             * @example capacity
+             */
+            type: string;
+        };
+        /**
+         * @description A single-stop visit: one location served once (the `jobs[]` entry type).
+         *     For a pickup bound to a delivery on the same vehicle, use `shipments[]`.
+         * @example {
+         *       "id": "job-1",
+         *       "location": [
+         *         3.725,
+         *         51.05
+         *       ],
+         *       "pickup": {
+         *         "weight": 20
+         *       },
+         *       "service_duration_s": 300,
+         *       "skills": [
+         *         {
+         *           "name": "fridge"
+         *         }
+         *       ],
+         *       "time_windows": [
+         *         {
+         *           "from": "2026-07-01T09:00:00+02:00",
+         *           "to": "2026-07-01T12:00:00+02:00"
+         *         }
+         *       ]
+         *     }
+         */
+        Visit: {
+            /**
+             * @description Absolute price of serving this task on a given vehicle, in the
+             *     objective's currency. Charged once, when that vehicle (on any of its
+             *     shifts) serves the task; unlisted vehicles cost nothing. Unlike
+             *     `preferences`, which charges the vehicles that did NOT get the task,
+             *     this prices the vehicle that did, so a task rated badly everywhere is
+             *     the first one dropped when capacity runs out. It lives in the cost tier,
+             *     below `priority`, and adds to `preferences`, `drop_fee` and travel.
+             *     Not applied by decomposition: a problem that sets it solves monolithically.
+             */
+            assignment_costs?: components["schemas"]["AssignmentCost"][] | null;
+            /**
+             * @description Whether a break may interrupt service here. Default `true`. `false`
+             *     is not supported yet and is rejected with HTTP 400.
+             * @example true
+             */
+            break_interruptible?: boolean | null;
+            /** @description Quantity delivered at this visit — comes off the truck here, having been loaded at a depot — as non-negative magnitudes. Direction is carried by the field name, never by sign. Absent or empty means no delivery at this visit. */
+            delivery?: {
+                [key: string]: number;
+            } | null;
+            /**
+             * Format: double
+             * @description Drop **price** — what leaving this task unserved costs you, in the same
+             *     currency as `objective.costs`, and the only way to make a task
+             *     droppable. Tasks without a `drop_fee` must be served.
+             *
+             *     This is money, not a priority: it enters the same cost the solver
+             *     minimises, so the task is served only while serving it costs less than
+             *     the fee. Fees the plan chose to pay are reported in
+             *     `score.components.drop_fees` and summed into `score.cost`.
+             *
+             *     On a shipment the fee applies to the pair, charged once.
+             * @example 25
+             */
+            drop_fee?: number | null;
+            /** @description Hard vehicle allow/exclude. */
+            eligible_vehicles?: null | components["schemas"]["Eligibility"];
+            /**
+             * @description Job id: 1 to 128 characters, unique across `jobs` + `shipments`.
+             * @example job-1
+             */
+            id: string;
+            /**
+             * @description Where this visit happens. Omit for a "virtual" (location-less) job:
+             *     it still has service duration, time windows, load, and skills, but
+             *     requires no travel — the vehicle's position doesn't change when it
+             *     serves one. Virtual and located jobs may be mixed freely in the same
+             *     request and route. A virtual job's stop in the solution response
+             *     reports the resolved location of its nearest real (located)
+             *     neighbor in the route — the predecessor when there is one, otherwise
+             *     the successor — so it is `null` only on a route that has no located
+             *     stop at all (an all-virtual route on an open-start/open-end shift).
+             *     A shipment's legs still require a `location`.
+             */
+            location?: null | components["schemas"]["Place"];
+            /**
+             * @description Hard-pin this job to one vehicle id — only that vehicle (any of its
+             *     shifts) may serve it, and once placed, re-optimization never removes it
+             *     or moves it to another vehicle. Stronger than `eligible_vehicles`
+             *     (which filters a set) and hard, unlike `preferences`.
+             *
+             *     A pin means "stays on this vehicle if placed", **not** "must be
+             *     served": the task can still end up unassigned (for example when it does
+             *     not fit), and with a `drop_fee` it then pays the fee. An id that
+             *     matches no vehicle is rejected with HTTP 400.
+             * @example vehicle-1
+             */
+            locked_vehicle?: string | null;
+            /**
+             * @description Quantity picked up at this visit: goes onto the vehicle here and stays
+             *     aboard until the route ends or reloads. Non-negative magnitudes per
+             *     named dimension. A swap that collects one quantity and drops off
+             *     another at the same address is one job with both `pickup` and
+             *     `delivery`.
+             */
+            pickup?: null | components["schemas"]["BTreeMap"];
+            /**
+             * @description Soft vehicle affinity preferences, priced. Each entry is independent:
+             *     a job listing several preferred vehicles it doesn't get pays each
+             *     one's `violation_cost` (compounding, the same rule as a vehicle's
+             *     `preferred_tags`).
+             */
+            preferences?: components["schemas"]["Preference"][] | null;
+            /**
+             * Format: date-time
+             * @description Soft preference for the calendar day this task is served on, in a
+             *     multi-day (multi-shift) problem.
+             *
+             *     An RFC 3339 datetime, UTC offset required, on the intended day. A day is the calendar date of
+             *     the value **in its own UTC offset**, the same rule that dates a shift
+             *     from its `from`, so passing the target shift's `from` verbatim is
+             *     always correct.
+             *
+             *     Soft, and priced by `objective.non_preferred_date_cost` — a flat charge
+             *     applied once to a task served on any other day. **With that cost unset or
+             *     zero this field has no effect.** The charge is part of `score.cost`,
+             *     which ranks below serving required tasks, so a task is never left
+             *     unassigned to honour its preferred date; `locked_vehicle` (hard) also
+             *     still wins.
+             *
+             *     Supported on shipments as well as jobs. Both legs of a shipment ride
+             *     the same route, so the preferred day is a property of the pair: set it
+             *     on the shipment itself, and `non_preferred_date_cost` is charged once
+             *     for the pair rather than once per leg.
+             * @example 2026-08-04T08:00:00+02:00
+             */
+            preferred_date?: string | null;
+            /**
+             * Format: int32
+             * @description Importance of a must-serve task when not all of them fit: the solver
+             *     maximises the summed `priority` of served tasks before any cost. `>= 1`,
+             *     default `1` (maximise the count). A rank, not money — it never makes a
+             *     task droppable; use `drop_fee` for that. Both set is a 400.
+             * @example 3
+             */
+            priority?: number | null;
+            /**
+             * Format: int32
+             * @description On-site service time paid per job (seconds).
+             *
+             *     This is the nominal figure. The serving vehicle's `service_factor`
+             *     scales it — the time actually scheduled is
+             *     `service_duration_s / service_factor` — so the solution's
+             *     `stops[].service_s` may differ from what you sent here.
+             * @example 300
+             */
+            service_duration_s?: number | null;
+            /**
+             * @description Per-vehicle work-rate overrides for this task's `service_duration_s`,
+             *     composed multiplicatively with the serving vehicle's or shift's
+             *     `service_factor`. On a shipment the override scales both legs. A
+             *     vehicle not listed works at its own rate.
+             */
+            service_factors?: components["schemas"]["ServiceFactor"][] | null;
+            /**
+             * Format: int32
+             * @description Setup time paid once on arrival at a new location (seconds),
+             *     distinct from `service_duration_s`. Skipped when the immediate real
+             *     predecessor in the route already sits at this location — co-located
+             *     stops share one setup.
+             *
+             *     Not scaled by the vehicle's `service_factor`: setup is fixed arrival
+             *     overhead (parking, walking to the door), not the work itself.
+             * @example 60
+             */
+            setup_duration_s?: number | null;
+            /**
+             * @description Hard skill requirements — the assigned vehicle must provide every one,
+             *     at or above each requirement's `min_level`.
+             */
+            skills?: components["schemas"]["SkillReq"][] | null;
+            /**
+             * @description Free-form task labels (zones/territories, grouping/relation labels).
+             *     Used for `tag`/relation resolution and, when a shift scopes itself via
+             *     `serves_tags` (hard ANY-overlap) or a vehicle prices them via
+             *     `preferred_tags` (soft), for tag matching. ANY-overlap — contrast with
+             *     `skills`, which requires ALL. Not capability matching on its own.
+             */
+            tags?: string[] | null;
+            /**
+             * @description Soft target for this task, measured at its arrival (default) or
+             *     departure. On a shipment it is measured on the **delivery** leg.
+             */
+            target?: null | components["schemas"]["Target"];
+            /** @description Time windows for this visit. */
+            time_windows?: components["schemas"]["TimeWindow"][] | null;
+        };
+    };
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+export type $defs = Record<string, never>;
+export interface operations {
+    evaluate: {
+        parameters: {
+            query?: {
+                /**
+                 * @description Check the request without fetching a matrix or searching. 200
+                 *     `{"valid": true, "warnings": []}`, or a 400 for the problem, options
+                 *     and caps; `plan` is checked only by the real call, after the fetch.
+                 */
+                validate_only?: boolean;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["EvaluateRequest"];
+            };
+        };
+        responses: {
+            /** @description Solution evaluated. With `?validate_only=true`: a `ValidateOnlyResponse`, `{"valid": true, "warnings": []}`, without a matrix fetch, not billed. */
+            200: {
+                headers: {
+                    /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
+                    "x-request-id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OrValidateOnly_SolveResponse"];
+                };
+            };
+            /** @description The request is invalid. `errors[]` lists what to fix, each entry with a `code` and a JSON pointer into the request body. */
+            400: {
+                headers: {
+                    /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
+                    "x-request-id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorBody"];
+                };
+            };
+            /** @description Missing or invalid API key. Returned by the API gateway before the request reaches the solver, so it does not use the `ErrorBody` shape and can have an empty body. Branch on the HTTP status. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description The request uses a feature this account does not have (`tomtom_real_time`) */
+            403: {
+                headers: {
+                    /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
+                    "x-request-id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "code": "feature_not_enabled",
+                     *       "message": "travel.engine: 'tomtom_real_time' is not enabled for this account; use engine 'tomtom'",
+                     *       "request_id": "req_7f3a2c90d1e4b5a6",
+                     *       "status": "FORBIDDEN"
+                     *     }
+                     */
+                    "application/json": components["schemas"]["ErrorBody"];
+                };
+            };
+            /** @description Request body larger than 10 MiB */
+            413: {
+                headers: {
+                    /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
+                    "x-request-id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "code": "payload_too_large",
+                     *       "message": "Request body exceeds 10485760 bytes",
+                     *       "request_id": "req_7f3a2c90d1e4b5a6",
+                     *       "status": "PAYLOAD_TOO_LARGE"
+                     *     }
+                     */
+                    "application/json": components["schemas"]["ErrorBody"];
+                };
+            };
+            /** @description Request `Content-Type` is not `application/json` */
+            415: {
+                headers: {
+                    /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
+                    "x-request-id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "code": "unsupported_media_type",
+                     *       "message": "Expected request with `Content-Type: application/json`",
+                     *       "request_id": "req_7f3a2c90d1e4b5a6",
+                     *       "status": "UNSUPPORTED_MEDIA_TYPE"
+                     *     }
+                     */
+                    "application/json": components["schemas"]["ErrorBody"];
+                };
+            };
+            /** @description Rate limited. Returned by the API gateway before the request reaches the solver, so it does not use the `ErrorBody` shape. Back off and retry. */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Server-side error (`code: internal`). */
+            500: {
+                headers: {
+                    /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
+                    "x-request-id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorBody"];
+                };
+            };
+            /** @description Travel times and distances could not be fetched (`code: matrix_provider_error`). The request can be retried. */
+            502: {
+                headers: {
+                    /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
+                    "x-request-id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorBody"];
+                };
+            };
+            /** @description No capacity right now (`code: overloaded`). Retry after the number of seconds in the `Retry-After` header. */
+            503: {
+                headers: {
+                    /** @description Seconds to wait before retrying. */
+                    "Retry-After"?: number;
+                    /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
+                    "x-request-id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "code": "overloaded",
+                     *       "message": "All solver slots are busy, try again later",
+                     *       "request_id": "req_7f3a2c90d1e4b5a6",
+                     *       "status": "SERVICE_UNAVAILABLE"
+                     *     }
+                     */
+                    "application/json": components["schemas"]["ErrorBody"];
+                };
+            };
+        };
+    };
+    solve: {
+        parameters: {
+            query?: {
+                /**
+                 * @description Check the request without fetching a matrix or searching. 200
+                 *     `{"valid": true, "warnings": []}`, or a 400 for the problem, options
+                 *     and caps; `plan` is checked only by the real call, after the fetch.
+                 */
+                validate_only?: boolean;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["SolveRequest"];
+            };
+        };
+        responses: {
+            /** @description Solution found. With `?validate_only=true`: a `ValidateOnlyResponse`, `{"valid": true, "warnings": []}`, without a matrix fetch or a search, not billed. */
+            200: {
+                headers: {
+                    /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
+                    "x-request-id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OrValidateOnly_SolveResponse"];
+                };
+            };
+            /** @description The request is invalid. `errors[]` lists what to fix, each entry with a `code` and a JSON pointer into the request body. */
+            400: {
+                headers: {
+                    /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
+                    "x-request-id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorBody"];
+                };
+            };
+            /** @description Missing or invalid API key. Returned by the API gateway before the request reaches the solver, so it does not use the `ErrorBody` shape and can have an empty body. Branch on the HTTP status. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description The request uses a feature this account does not have (`tomtom_real_time`) */
+            403: {
+                headers: {
+                    /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
+                    "x-request-id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "code": "feature_not_enabled",
+                     *       "message": "travel.engine: 'tomtom_real_time' is not enabled for this account; use engine 'tomtom'",
+                     *       "request_id": "req_7f3a2c90d1e4b5a6",
+                     *       "status": "FORBIDDEN"
+                     *     }
+                     */
+                    "application/json": components["schemas"]["ErrorBody"];
+                };
+            };
+            /** @description Request body larger than 10 MiB */
+            413: {
+                headers: {
+                    /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
+                    "x-request-id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "code": "payload_too_large",
+                     *       "message": "Request body exceeds 10485760 bytes",
+                     *       "request_id": "req_7f3a2c90d1e4b5a6",
+                     *       "status": "PAYLOAD_TOO_LARGE"
+                     *     }
+                     */
+                    "application/json": components["schemas"]["ErrorBody"];
+                };
+            };
+            /** @description Request `Content-Type` is not `application/json` */
+            415: {
+                headers: {
+                    /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
+                    "x-request-id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "code": "unsupported_media_type",
+                     *       "message": "Expected request with `Content-Type: application/json`",
+                     *       "request_id": "req_7f3a2c90d1e4b5a6",
+                     *       "status": "UNSUPPORTED_MEDIA_TYPE"
+                     *     }
+                     */
+                    "application/json": components["schemas"]["ErrorBody"];
+                };
+            };
+            /** @description Rate limited. Returned by the API gateway before the request reaches the solver, so it does not use the `ErrorBody` shape. Back off and retry. */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Server-side error (`code: internal`). */
+            500: {
+                headers: {
+                    /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
+                    "x-request-id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorBody"];
+                };
+            };
+            /** @description Travel times and distances could not be fetched (`code: matrix_provider_error`). The request can be retried. If Solvice Maps is only unreachable, this needs `options.travel_fallback: "fail"`; by default the plan is solved on estimated travel and `summary.travel_estimated` is set. */
+            502: {
+                headers: {
+                    /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
+                    "x-request-id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorBody"];
+                };
+            };
+            /** @description No capacity right now (`code: overloaded`). Retry after the number of seconds in the `Retry-After` header. */
+            503: {
+                headers: {
+                    /** @description Seconds to wait before retrying. */
+                    "Retry-After"?: number;
+                    /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
+                    "x-request-id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "code": "overloaded",
+                     *       "message": "All solver slots are busy, try again later",
+                     *       "request_id": "req_7f3a2c90d1e4b5a6",
+                     *       "status": "SERVICE_UNAVAILABLE"
+                     *     }
+                     */
+                    "application/json": components["schemas"]["ErrorBody"];
+                };
+            };
+        };
+    };
+    suggest: {
+        parameters: {
+            query?: {
+                /**
+                 * @description Check the request without fetching a matrix or searching. 200
+                 *     `{"valid": true, "warnings": []}`, or a 400 for the problem, options
+                 *     and caps; `plan` is checked only by the real call, after the fetch.
+                 */
+                validate_only?: boolean;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["SuggestRequest"];
+            };
+        };
+        responses: {
+            /** @description Suggestions computed. With `?validate_only=true`: a `ValidateOnlyResponse`, `{"valid": true, "warnings": []}`, without a matrix fetch or a search, not billed. */
+            200: {
+                headers: {
+                    /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
+                    "x-request-id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OrValidateOnly_SuggestResponse"];
+                };
+            };
+            /** @description The request is invalid. `errors[]` lists what to fix, each entry with a `code` and a JSON pointer into the request body. */
+            400: {
+                headers: {
+                    /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
+                    "x-request-id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorBody"];
+                };
+            };
+            /** @description Missing or invalid API key. Returned by the API gateway before the request reaches the solver, so it does not use the `ErrorBody` shape and can have an empty body. Branch on the HTTP status. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description The request uses a feature this account does not have (`tomtom_real_time`) */
+            403: {
+                headers: {
+                    /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
+                    "x-request-id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "code": "feature_not_enabled",
+                     *       "message": "travel.engine: 'tomtom_real_time' is not enabled for this account; use engine 'tomtom'",
+                     *       "request_id": "req_7f3a2c90d1e4b5a6",
+                     *       "status": "FORBIDDEN"
+                     *     }
+                     */
+                    "application/json": components["schemas"]["ErrorBody"];
+                };
+            };
+            /** @description Request body larger than 10 MiB */
+            413: {
+                headers: {
+                    /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
+                    "x-request-id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "code": "payload_too_large",
+                     *       "message": "Request body exceeds 10485760 bytes",
+                     *       "request_id": "req_7f3a2c90d1e4b5a6",
+                     *       "status": "PAYLOAD_TOO_LARGE"
+                     *     }
+                     */
+                    "application/json": components["schemas"]["ErrorBody"];
+                };
+            };
+            /** @description Request `Content-Type` is not `application/json` */
+            415: {
+                headers: {
+                    /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
+                    "x-request-id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "code": "unsupported_media_type",
+                     *       "message": "Expected request with `Content-Type: application/json`",
+                     *       "request_id": "req_7f3a2c90d1e4b5a6",
+                     *       "status": "UNSUPPORTED_MEDIA_TYPE"
+                     *     }
+                     */
+                    "application/json": components["schemas"]["ErrorBody"];
+                };
+            };
+            /** @description Rate limited. Returned by the API gateway before the request reaches the solver, so it does not use the `ErrorBody` shape. Back off and retry. */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Server-side error (`code: internal`). */
+            500: {
+                headers: {
+                    /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
+                    "x-request-id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorBody"];
+                };
+            };
+            /** @description Travel times and distances could not be fetched (`code: matrix_provider_error`). The request can be retried. */
+            502: {
+                headers: {
+                    /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
+                    "x-request-id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorBody"];
+                };
+            };
+            /** @description No capacity right now (`code: overloaded`). Retry after the number of seconds in the `Retry-After` header. */
+            503: {
+                headers: {
+                    /** @description Seconds to wait before retrying. */
+                    "Retry-After"?: number;
+                    /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
+                    "x-request-id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "code": "overloaded",
+                     *       "message": "All solver slots are busy, try again later",
+                     *       "request_id": "req_7f3a2c90d1e4b5a6",
+                     *       "status": "SERVICE_UNAVAILABLE"
+                     *     }
+                     */
+                    "application/json": components["schemas"]["ErrorBody"];
+                };
+            };
+        };
+    };
+}