@solvice/routing 0.1.0-beta.0 → 0.16.1-beta.0

package/dist/v3.d.ts

@@ -14,7 +14,7 @@ export interface paths {
         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.
+         * @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.violation_count` 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;
@@ -34,7 +34,7 @@ export interface paths {
         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`.
+         * @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 150 ms plus 4 ms per task; maximum 60). 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;
@@ -54,7 +54,7 @@ export interface paths {
         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.
+         * @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` whose `code` is `time_limit`, `candidates_exhausted` or `infeasible` (an open set) and whose `message` says the same in English. The committed plan is never modified. Limitation: suggest never opens a new reload trip on a multi-trip vehicle.
          */
         post: operations["suggest"];
         delete?: never;
@@ -63,6 +63,66 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v3/routing/validate/evaluate": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Check an evaluate request without running it
+         * @description Checks a `POST /v3/routing/evaluate` request without scoring it. It runs the checks `POST /v3/routing/evaluate` runs before it fetches travel times, and stops there: no travel times are fetched, nothing is searched, no solver slot is taken, and the call is not billed. The body is the body of `POST /v3/routing/evaluate`. A valid request returns `{"valid": true, "warnings": []}`; an invalid one returns the 400 (or 403) the real call would. Not covered, because the real call makes these checks only after it fetches travel times: coordinates that span more than one Maps region (a 400 on the real call), and the `plan` (that its routes and stops name vehicles, shifts, tasks and depots of `problem`, and that it imports; see the plan errors in the errors guide).
+         */
+        post: operations["validate_evaluate"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v3/routing/validate/solve": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Check a solve request without running it
+         * @description Checks a `POST /v3/routing/solve` request without solving it. It runs the checks `POST /v3/routing/solve` runs before it fetches travel times, and stops there: no travel times are fetched, nothing is searched, no solver slot is taken, and the call is not billed. The body is the body of `POST /v3/routing/solve`. A valid request returns `{"valid": true, "warnings": []}`; an invalid one returns the 400 (or 403) the real call would. Not covered, because the real call makes these checks only after it fetches travel times: coordinates that span more than one Maps region (a 400 on the real call), and the warm-start `plan` (that its routes and stops name vehicles, shifts, tasks and depots of `problem`, and that it imports, its locked stops included; see the plan errors in the errors guide).
+         */
+        post: operations["validate_solve"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v3/routing/validate/suggest": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Check a suggest request without running it
+         * @description Checks a `POST /v3/routing/suggest` request without searching. It runs the checks `POST /v3/routing/suggest` runs before it fetches travel times, and stops there: no travel times are fetched, nothing is searched, no solver slot is taken, and the call is not billed. The body is the body of `POST /v3/routing/suggest`. A valid request returns `{"valid": true, "warnings": []}`; an invalid one returns the 400 (or 403) the real call would. Not covered, because the real call makes these checks only after it fetches travel times: coordinates that span more than one Maps region (a 400 on the real call), and the `plan` beyond suggest's own rule that it leaves a task to place, which does run here (that its routes and stops name vehicles, shifts, tasks and depots of `problem`, and that it imports; see the plan errors in the errors guide).
+         */
+        post: operations["validate_suggest"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
 }
 export type webhooks = Record<string, never>;
 export interface components {
@@ -84,21 +144,12 @@ export interface components {
             cost: number;
             /**
              * @description Vehicle id; applies to every shift of that vehicle. An id that matches
-             *     no vehicle is rejected with HTTP 400.
+             *     no vehicle, or a vehicle listed twice in one task's
+             *     `assignment_costs`, 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`:
          *
@@ -108,11 +159,13 @@ export interface components {
          *     - `fixed`: a hard off-duty interval from `from` to `to`.
          *
          *     Breaks are injected between stops and appear in the response as `break`
-         *     stops.
+         *     stops, carrying the break's `id` when it has one.
          *
-         *     **Not yet supported** — rejected with HTTP 400 `not_supported`: more than
-         *     one `windows` entry, a `location` on a `triggered` break, and
-         *     `resets_accumulator: false`.
+         *     A `triggered` break always resets its accumulator after a qualifying break
+         *     and is taken wherever the vehicle is: `resets_accumulator` and `location`
+         *     do not exist on it. A `windowed` break takes exactly one `time_window` and
+         *     is also taken wherever the vehicle is: a `location` on it is HTTP 400
+         *     `not_supported`.
          *
          *     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
@@ -124,59 +177,34 @@ export interface components {
          *       "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";
-        } | {
+        Break: components["schemas"]["BreakWindowed"] | components["schemas"]["BreakTriggered"] | components["schemas"]["BreakFixed"];
+        /**
+         * Fixed
+         * @description Mandatory off-duty interval at a fixed time. No service is scheduled
+         *     inside it, but a drive already under way at `from` continues through
+         *     it and counts in both `travel_s` and `break_s`.
+         */
+        BreakFixed: {
             /**
              * Format: date-time
              * @description Start of the break (RFC 3339 instant, UTC offset required).
              */
             from: string;
+            /**
+             * @description Optional break id: 1 to 128 characters, unique within the shift.
+             *     Echoed as `id` on the `break` stop that realises this break.
+             * @example lunch
+             */
+            id?: string | null;
             /**
              * Format: date-time
              * @description End of the break (RFC 3339 instant, UTC offset required).
              */
             to: string;
-            /** @enum {string} */
+            /**
+             * @description Discriminator: always `fixed`. (enum property replaced by openapi-typescript)
+             * @enum {string}
+             */
             type: "fixed";
         };
         /**
@@ -186,7 +214,7 @@ export interface components {
          *       "to": "2026-07-01T13:30:00+02:00"
          *     }
          */
-        BreakWindow: {
+        BreakTimeWindow: {
             /**
              * Format: date-time
              * @description Earliest break start (RFC 3339 instant, UTC offset required).
@@ -198,6 +226,80 @@ export interface components {
              */
             to: string;
         };
+        /**
+         * Triggered
+         * @description A break taken once drive or duty time passes a threshold.
+         */
+        BreakTriggered: {
+            /** @description What to accumulate: drive time or duty time. */
+            after: components["schemas"]["TriggerAfter"];
+            /**
+             * Format: int32
+             * @description Break duration in seconds. Must be `> 0`.
+             */
+            duration_s: number;
+            /**
+             * @description Optional break id: 1 to 128 characters, unique within the shift.
+             *     Echoed as `id` on the `break` stop that realises this break.
+             * @example lunch
+             */
+            id?: string | 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).
+             *     Must be `> 0` and fit in 32 bits.
+             * @example 14400
+             */
+            threshold_s: number;
+            /**
+             * @description Discriminator: always `triggered`. (enum property replaced by openapi-typescript)
+             * @enum {string}
+             */
+            type: "triggered";
+        };
+        /**
+         * Windowed
+         * @description A break that must start inside a time window.
+         */
+        BreakWindowed: {
+            /**
+             * Format: int32
+             * @description Break duration in seconds. Must be `> 0`.
+             */
+            duration_s: number;
+            /**
+             * @description Optional break id: 1 to 128 characters, unique within the shift.
+             *     Echoed as `id` on the `break` stop that realises this break.
+             * @example lunch
+             */
+            id?: string | null;
+            /**
+             * @description Not supported on V3: a windowed break is taken wherever the
+             *     vehicle is when it starts, so a `location` here is rejected with
+             *     HTTP 400 `not_supported`. Set only by the V2 compatibility mapper.
+             */
+            location?: null | components["schemas"]["Place"];
+            /** @description The window bounding the break's **start**. */
+            time_window: components["schemas"]["BreakTimeWindow"];
+            /**
+             * @description Discriminator: always `windowed`. (enum property replaced by openapi-typescript)
+             * @enum {string}
+             */
+            type: "windowed";
+        };
+        /**
+         * @description The constraint a violation breaks or a reason names: one vocabulary for
+         *     `routes[].violations[].code`, `routes[].stops[].violations[].code` and
+         *     `unassigned[].reasons[].constraint`.
+         *
+         *     New values may be added; clients must accept unknown values and handle
+         *     them generically, for example by showing `message`.
+         *
+         *     Known values: `unreachable`, `max_leg_travel`, `required_skills`, `serves_tags`, `capacity`, `time_window`, `eligible_vehicles`, `shift_end`, `max_distance`, `max_route_duration`, `max_stops`, `sequence`, `tag_order`, `shipment`, `break`, `multi_trip`, `same_vehicle`, `same_day`, `same_route`, `compatible_vehicles`, `synchronized`, `time_lag`, `all_or_none`, `period_limit`, `quota`, `unknown`. An open set: a later release may add values, so accept any string and handle the ones you know.
+         * @example capacity
+         */
+        ConstraintCode: string;
         /**
          * @description What running a vehicle costs, in the request's currency
          *     (`objective.currency` is only a label). The same type at three levels:
@@ -211,22 +313,17 @@ export interface components {
          *     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`.
+         *
+         *     Lateness is not priced here: `objective.per_late_hour` (or a window's own
+         *     `per_late_hour`) is the rate, because it softens a constraint rather than
+         *     pricing a resource.
          * @example {
-         *       "fixed": 50,
+         *       "per_route": 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
@@ -235,17 +332,28 @@ export interface components {
              * @example 0
              */
             per_overtime_hour?: number | null;
+            /**
+             * Format: double
+             * @description Flat charge for each used shift (a route with at least one task),
+             *     reported in `score.components.routes`. 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
+             */
+            per_route?: 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**.
+             *     and breaks), reported in `score.components.time`. Default **35** at objective
+             *     level; a vehicle or shift value inherits the fleet value.
              * @example 35
              */
             per_route_hour?: number | null;
             /**
              * Format: double
              * @description Per kilometre driven, reported in `score.components.distance`.
-             *     Default **0.20**.
+             *     Default **0.20** at objective level; a vehicle or shift value inherits the
+             *     fleet value.
              * @example 0.2
              */
             per_travel_km?: number | null;
@@ -253,7 +361,8 @@ export interface components {
              * 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`.
+             *     includes the wait). Idle before a windowed break's window opens is
+             *     reported in `wait_s` but not charged here. Default `0`.
              * @example 0
              */
             per_wait_hour?: number | null;
@@ -261,7 +370,7 @@ export interface components {
         /**
          * @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.
+         *     `shifts[].reloads`. Each depot keeps its own handling time and reload cost.
          * @example {
          *       "id": "gent",
          *       "location": [
@@ -272,12 +381,20 @@ export interface components {
          *     }
          */
         Depot: {
+            /**
+             * @description Depot id: 1 to 128 characters, unique across `depots[]`.
+             * @example gent
+             */
+            id: string;
+            /** @description Where the depot is. */
+            location: components["schemas"]["Place"];
             /**
              * 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.
+             *     Default 0; at most `1e9`. 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
+             *     Set this when a reload has a real per-reload 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
@@ -286,14 +403,7 @@ export interface components {
              *     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"];
+            per_reload?: number | null;
             /**
              * Format: int32
              * @description Handling time in seconds per visit: the load before a shift that starts
@@ -306,21 +416,6 @@ export interface components {
              */
             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.
          *
@@ -346,7 +441,7 @@ export interface components {
             /** @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"][];
+            errors?: components["schemas"]["RequestIssue"][];
             /**
              * @description Human-readable summary. With exactly one item it is that item's
              *     message; with several, `"{n} problems in request"` (at most 100 items
@@ -364,39 +459,17 @@ export interface components {
         };
         /**
          * @description The top-level `code` of an error body.
-         * @enum {string}
+         *
+         *     Known values: `invalid_request`, `feature_not_enabled`, `payload_too_large`, `unsupported_media_type`, `internal`, `travel_provider_error`, `overloaded`. An open set: a later release may add values, so accept any string and handle the ones you know.
          */
-        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;
-        };
+        ErrorCode: string;
         /**
          * @description The `code` of one `errors[]` item. Clients should accept values they do
          *     not know yet.
-         * @enum {string}
+         *
+         *     Known values: `invalid_json`, `invalid_type`, `unknown_field`, `missing_field`, `invalid_value`, `not_supported`, `out_of_range`, `duplicate_id`, `unknown_reference`, `conflicting_fields`, `limit_exceeded`. An open set: a later release may add values, so accept any string and handle the ones you know.
          */
-        ErrorItemCode: "invalid_json" | "invalid_type" | "unknown_field" | "missing_field" | "invalid_value" | "not_supported" | "out_of_range" | "duplicate_id" | "unknown_reference" | "conflicting_fields" | "limit_exceeded";
+        ErrorItemCode: string;
         /**
          * @description Request body for `POST /v3/routing/evaluate`.
          *
@@ -427,7 +500,7 @@ export interface components {
          *               3.725,
          *               51.05
          *             ],
-         *             "pickup": {
+         *             "pickup_load": {
          *               "weight": 10
          *             },
          *             "service_duration_s": 300
@@ -467,37 +540,45 @@ export interface components {
             /** @description The plan to score. */
             plan: components["schemas"]["Plan"];
             /** @description Problem definition — identical to `POST /v3/routing/solve`. */
-            problem: components["schemas"]["ProblemInput"];
+            problem: components["schemas"]["Problem"];
         };
         /**
          * @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.
+         *     each other. The solver adds `per_entry` to the objective each time a
+         *     route enters a group from a job outside it, the first entry included;
+         *     entering from the shift's start or from a reload is free. Keeping each
+         *     group in one visit minimises 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",
+         *       "distance_metric": "straight_line",
+         *       "per_entry": 0.5,
          *       "radius_m": 180
          *     }
          */
         Grouping: {
+            /**
+             * @description How neighbour distance is measured. Default `"straight_line"`.
+             * @default straight_line
+             */
+            distance_metric?: null | components["schemas"]["GroupingDistance"];
             /**
              * 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.
+             * @description Cost added to the objective on every entry into a group from a job
+             *     outside it (a job that is not within `radius_m` of the entered one),
+             *     the first entry included, in the objective's currency. Entry from the
+             *     shift's start or from a reload is free. 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"];
+            per_entry: number;
             /**
              * Format: int32
-             * @description Radius defining a group, in metres. Default `180`.
+             * @description Radius defining a group, in metres. Default `180`. Must be `> 0`.
+             * @default 180
              * @example 180
              */
             radius_m?: number | null;
@@ -516,14 +597,14 @@ export interface components {
          * @example {
          *       "cost": 12.4,
          *       "distance_m": 2400,
-         *       "duration_s": 240
+         *       "travel_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.
+             *     serving a task saves more `drop_cost` than it costs to route.
              * @example 12.4
              */
             cost: number;
@@ -539,7 +620,7 @@ export interface components {
              *     seconds.
              * @example 240
              */
-            duration_s: number;
+            travel_s: number;
         };
         /**
          * @description One feasible way to place the whole unit.
@@ -547,7 +628,7 @@ export interface components {
          *       "delta": {
          *         "cost": 12.4,
          *         "distance_m": 2400,
-         *         "duration_s": 240
+         *         "travel_s": 240
          *       },
          *       "placements": [
          *         {
@@ -598,67 +679,180 @@ export interface components {
             routes: components["schemas"]["PlanRoute"][];
         };
         /**
-         * @description Ranked insertion suggestions for a single unit.
+         * @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 {
-         *       "insertions": [
+         *       "id": "job-1",
+         *       "location": [
+         *         3.725,
+         *         51.05
+         *       ],
+         *       "pickup_load": {
+         *         "weight": 20
+         *       },
+         *       "required_skills": [
          *         {
-         *           "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"
-         *             }
-         *           ]
+         *           "name": "fridge"
          *         }
          *       ],
-         *       "job_id": "job-2"
+         *       "service_duration_s": 300,
+         *       "time_windows": [
+         *         {
+         *           "from": "2026-07-01T09:00:00+02:00",
+         *           "to": "2026-07-01T12:00:00+02:00"
+         *         }
+         *       ]
          *     }
          */
-        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"][];
+        Job: {
             /**
-             * @description The unit's lead: its first member in placement order (the visit, the
-             *     shipment, or the first relation member).
-             * @example job-2
+             * @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_cost` and travel.
+             *     Not applied by decomposition: a problem that sets it solves monolithically.
+             */
+            assignment_costs?: components["schemas"]["AssignmentCost"][] | null;
+            /**
+             * @description Quantity delivered at this visit: comes off the vehicle here, having
+             *     been loaded at a depot. Direction is carried by the field itself, never
+             *     by sign — `delivery_load` values are non-negative magnitudes, like `pickup_load`.
+             *
+             *     Unlike a shipment, nothing is picked up for it at another stop: the
+             *     goods are assumed already aboard from a depot, so the vehicle departs
+             *     its trip carrying the sum of the trip's `delivery_load` quantities.
+             *
+             *     Absent or empty means no delivery at this visit.
              */
-            job_id: string;
+            delivery_load?: null | components["schemas"]["Quantities"];
             /**
-             * @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
+             * 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_cost` 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
+             *     dropping it. Drop costs the plan chose to pay are reported in
+             *     `score.components.drop_costs` and summed into `score.cost`.
+             *
+             *     On a shipment the drop cost applies to the pair, charged once.
+             *
+             *     Must be finite, `>= 0` and at most `1e9`; combined with `priority` it
+             *     is rejected with HTTP 400 (`conflicting_fields`).
+             * @example 25
+             */
+            drop_cost?: number | null;
+            /**
+             * @description Hard vehicle allow/exclude. A request may use at most 256 distinct
+             *     permitted-vehicle sets (after resolving `allowed`/`excluded`) across
+             *     all jobs and shipments (HTTP 400 `limit_exceeded` beyond that).
+             */
+            eligible_vehicles?: null | components["schemas"]["VehicleEligibility"];
+            /**
+             * @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 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_load` and
+             *     `delivery_load`.
+             */
+            pickup_load?: null | components["schemas"]["Quantities"];
+            /**
+             * @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"]["VehiclePreference"][] | 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_cost` for that. Both set is a 400.
+             * @example 3
+             */
+            priority?: number | null;
+            /**
+             * @description Hard skill requirements — the assigned vehicle must provide every one,
+             *     at or above each requirement's `min_level`. A request may use at most
+             *     256 distinct `(name, min_level)` pairs across all jobs and shipments
+             *     (HTTP 400 `limit_exceeded` beyond that).
              */
-            reason?: string | null;
-            /** @description Why `insertions` is empty; absent otherwise. Branch on this. */
-            reason_code?: null | components["schemas"]["SuggestReasonCode"];
+            required_skills?: components["schemas"]["SkillRequirement"][] | 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. Default `0`;
+             *     a negative value is rejected with HTTP 400.
+             * @example 300
+             */
+            service_duration_s?: number | null;
+            /**
+             * @description Per-vehicle work-rate factors for this task's `service_duration_s`,
+             *     which is DIVIDED by the factor (above `1` = faster). Each multiplies
+             *     the serving vehicle's rate (the shift's `service_factor` if set, else
+             *     the vehicle's): effective service time = `service_duration_s /
+             *     (shift_or_vehicle_factor * factor)`. On a shipment the factor 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.
+             *     Default `0`; a negative value is rejected with HTTP 400.
+             * @example 60
+             */
+            setup_duration_s?: number | null;
+            /**
+             * @description Free-form task labels (zones/territories, 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
+             *     `required_skills`, which requires ALL. Not capability matching on its own.
+             *     A request may carry at most 256 distinct tags across all jobs and
+             *     shipments (HTTP 400 `limit_exceeded` beyond that); vehicle-side tag
+             *     lists do not count.
+             */
+            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;
         };
         /**
          * @description Which road-network data prices travel times and distances.
@@ -683,8 +877,8 @@ export interface components {
          *     (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`.
+         *     step: to use fewer vehicles, price them with `costs.per_route` or
+         *     `vehicles[].costs.per_route`.
          * @example {
          *       "costs": {
          *         "per_route_hour": 35,
@@ -708,21 +902,6 @@ export interface components {
             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
@@ -731,56 +910,14 @@ export interface components {
              *     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
+             *     Setting it `> 0` alongside a nonzero `time_windows[].choice_cost` anywhere in
              *     the request is rejected with HTTP 400.
              * @example 60
              */
             per_late_hour?: number | null;
+            /** @description Spreads work across vehicles. See the `WorkloadShare` schema. */
+            workload_share?: null | components["schemas"]["WorkloadShare"];
         };
-        /**
-         * @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}
@@ -791,8 +928,8 @@ export interface components {
          *     Set exactly one of `every`, or `from` and `to`; and at least one maximum.
          * @example {
          *       "every": "week",
-         *       "max_duration_s": 144000,
-         *       "max_tasks": 40
+         *       "max_route_duration_s": 144000,
+         *       "max_stops": 40
          *     }
          */
         PeriodLimit: {
@@ -808,33 +945,35 @@ export interface components {
             from?: string | null;
             /**
              * Format: int64
-             * @description Hard cap on the summed distance driven, in metres.
+             * @description Hard cap on the summed distance driven, in metres. Must be `>= 0`.
              * @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.
+             * @description Hard cap on the summed route span of the period's shifts, measured as a
+             *     shift's `max_route_duration_s` is, in seconds. An unused shift adds
+             *     nothing. Must be `>= 0`.
              * @example 144000
              */
-            max_duration_s?: number | null;
+            max_route_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).
+             * @description Hard cap on served stops across the period's shifts; a job counts as
+             *     one stop. Start, end, break and reload stops in `routes[].stops` do not
+             *     count; a shipment counts as two stops.
              * @example 40
              */
-            max_tasks?: number | null;
+            max_stops?: 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;
-        };
+        } & (unknown | unknown);
         /**
-         * @description A place: a coordinate `[longitude, latitude]` in GeoJSON order — exactly two numbers. Tasks at the same coordinate are treated as one location.
+         * @description A place: a coordinate `[longitude, latitude]` in GeoJSON order — exactly two numbers. Tasks at the same coordinate are treated as one location. Longitude must lie in `[-180, 180]` and latitude in `[-90, 90]` (HTTP 400 `out_of_range` otherwise), and `[0, 0]` is rejected with HTTP 400 `invalid_value` as a missing-GPS placeholder.
          * @example [
          *       3.725,
          *       51.05
@@ -930,44 +1069,77 @@ export interface components {
          *       "type": "pickup"
          *     }
          */
-        PlanStop: {
+        PlanStop: components["schemas"]["PlanStopJob"] | components["schemas"]["PlanStopPickup"] | components["schemas"]["PlanStopDelivery"] | components["schemas"]["PlanStopReload"];
+        /**
+         * PlanStopDelivery
+         * @description A shipment's delivery leg.
+         */
+        PlanStopDelivery: {
+            /**
+             * @description The leg's stop id: its own `id`, else `{shipment}:delivery`.
+             * @example parts-9:delivery
+             */
+            id: string;
+            /**
+             * @description Discriminator: always `delivery`. (enum property replaced by openapi-typescript)
+             * @enum {string}
+             */
+            type: "delivery";
+        };
+        /**
+         * PlanStopJob
+         * @description A job, by its id.
+         */
+        PlanStopJob: {
             /**
              * @description Job id.
              * @example boiler-17
              */
             id: string;
-            /** @enum {string} */
+            /**
+             * @description Discriminator: always `job`. (enum property replaced by openapi-typescript)
+             * @enum {string}
+             */
             type: "job";
-        } | {
+        };
+        /**
+         * PlanStopPickup
+         * @description A shipment's pickup leg.
+         */
+        PlanStopPickup: {
             /**
              * @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
+             * @description Discriminator: always `pickup`. (enum property replaced by openapi-typescript)
+             * @enum {string}
              */
-            id: string;
-            /** @enum {string} */
-            type: "delivery";
-        } | {
+            type: "pickup";
+        };
+        /**
+         * PlanStopReload
+         * @description A reload at a depot: the next trip starts there.
+         */
+        PlanStopReload: {
             /**
              * @description A depot id from the shift's `reloads`.
              * @example gent
              */
             depot: string;
-            /** @enum {string} */
+            /**
+             * @description Discriminator: always `reload`. (enum property replaced by openapi-typescript)
+             * @enum {string}
+             */
             type: "reload";
         };
         /**
          * @description The `type` of a plan stop.
-         * @enum {string}
+         *
+         *     Known values: `job`, `pickup`, `delivery`, `reload`. An open set: a later release may add values, so accept any string and handle the ones you know.
          */
-        PlanStopType: "job" | "pickup" | "delivery" | "reload";
+        PlanStopType: string;
         /**
          * @description How much road detail `routes[].polyline` carries.
          *
@@ -987,27 +1159,6 @@ export interface components {
          * @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 {
@@ -1027,7 +1178,7 @@ export interface components {
          *             3.725,
          *             51.05
          *           ],
-         *           "pickup": {
+         *           "pickup_load": {
          *             "weight": 20
          *           },
          *           "service_duration_s": 300
@@ -1056,22 +1207,28 @@ export interface components {
          *       ]
          *     }
          */
-        ProblemInput: {
+        Problem: {
             /** @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 Single-stop visits to serve. At most 10,000 tasks per request, `jobs`
+             *     and `shipments` combined (HTTP 400 `limit_exceeded` beyond that).
+             */
+            jobs?: components["schemas"]["Job"][];
             /** @description Objective configuration. */
             objective?: null | components["schemas"]["Objective"];
-            /** @description Stop caps shared by a set of vehicles. */
+            /** @description Stop caps shared by a set of vehicles. At most 65,535. */
             quotas?: components["schemas"]["Quota"][];
-            /** @description Ordering, grouping, and synchronization constraints. */
+            /** @description Ordering, co-assignment and synchronization constraints. */
             relations?: components["schemas"]["Relation"][] | null;
-            /** @description Bound pickup→delivery shipments to serve. */
+            /**
+             * @description Bound pickup→delivery shipments to serve. Counts toward the same
+             *     10,000-task cap as `jobs`.
+             */
             shipments?: components["schemas"]["Shipment"][];
             /** @description Where travel times and distances come from. */
             travel?: null | components["schemas"]["Travel"];
-            /** @description Available vehicles. */
+            /** @description Available vehicles: 1 to 2,000 (HTTP 400 otherwise). */
             vehicles: components["schemas"]["Vehicle"][];
         };
         /**
@@ -1081,21 +1238,39 @@ export interface components {
          */
         Profile: "car" | "truck" | "bike";
         /**
-         * @description A hard cap on how many stops of `job_ids` the `vehicles` serve together
+         * @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. In a request every value must be `>= 0` (a negative one is rejected with HTTP 400 `out_of_range`), and a request may use at most 4 distinct dimension names across jobs, shipments and vehicles (HTTP 400 `limit_exceeded` beyond that).
+         * @example {
+         *       "volume": 2,
+         *       "weight": 20
+         *     }
+         */
+        Quantities: {
+            [key: string]: number;
+        };
+        /**
+         * @description The unit of a violation's `excess` or a relaxation's `amount`.
+         *
+         *     Known values: `s`, `m`, `load`, `stops`. An open set: a later release may add values, so accept any string and handle the ones you know.
+         * @example s
+         */
+        QuantityUnit: string;
+        /**
+         * @description A hard cap on how many stops of `tasks` 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
+         *     (`arrival + wait_s` in the response when no windowed break is taken on
+         *     arrival there); without a window every stop counts.
+         *     Stops count as `max_stops` 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": [
+         *       "max_stops": 2,
+         *       "tasks": [
          *         "j1",
          *         "j2",
          *         "j3"
          *       ],
-         *       "max_tasks": 2,
          *       "vehicles": [
          *         "c0",
          *         "c1"
@@ -1105,7 +1280,9 @@ export interface components {
         Quota: {
             /**
              * Format: date-time
-             * @description Window start (RFC 3339, UTC offset required), with `to`.
+             * @description Window start (RFC 3339, UTC offset required), with `to`. The window
+             *     must overlap a shift of one of `vehicles` (counting its
+             *     `max_overtime_s`), else the request is rejected with HTTP 400.
              * @example 2026-10-05T00:00:00+02:00
              */
             from?: string | null;
@@ -1114,20 +1291,28 @@ export interface components {
              *     `/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.
+             * @description The cap on counted stops; a job counts as one stop.
+             *     Start, end, break and reload stops in `routes[].stops` do not count; a
+             *     shipment counts as two stops.
+             */
+            max_stops: number;
+            /**
+             * @description Job or shipment ids whose stops count, each at most once. At least
+             *     one; an id that names no job or shipment is rejected with HTTP 400.
              */
-            max_tasks: number;
+            tasks: string[];
             /**
              * 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. */
+            /**
+             * @description Vehicle ids that share the cap, each at most once. At least one; an id
+             *     that names no vehicle is rejected with HTTP 400.
+             */
             vehicles: string[];
         };
         /**
@@ -1137,17 +1322,22 @@ export interface components {
          *     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
+         *     Members are named by `stops` (job ids, or shipment-leg stop ids where
+         *     the type accepts them, see below). `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.
+         *     A shipment takes part through its legs: `sequence`, `same_vehicle`,
+         *     `same_day` and `same_route` accept a leg's stop id (`pickup.id` /
+         *     `delivery.id`, by default `"{shipment}:pickup"` / `":delivery"`) and bind
+         *     that leg like a job. A leg coupled to other tasks by a `synchronized` or
+         *     `time_lag` relation (directly, or through a `sequence` with a member that
+         *     is) is rejected with HTTP 400, as is a `sequence` putting a delivery before
+         *     its pickup. A shipment's own id in `stops`, or a shipment carrying the
+         *     `tag` of a `same_vehicle` or `same_day` relation, is rejected with HTTP 400
+         *     `not_supported`: relations never silently skip a member. `same_route`,
+         *     `time_lag`, `compatible_vehicles`, `all_or_none` and `tag_order` reject a
+         *     shipment with HTTP 400 as well.
          * @example {
          *       "stops": [
          *         "job-1",
@@ -1156,119 +1346,259 @@ export interface components {
          *       "type": "sequence"
          *     }
          */
-        Relation: {
+        Relation: components["schemas"]["RelationSequence"] | components["schemas"]["RelationTagOrder"] | components["schemas"]["RelationSameVehicle"] | components["schemas"]["RelationSameDay"] | components["schemas"]["RelationSameRoute"] | components["schemas"]["RelationSynchronized"] | components["schemas"]["RelationTimeLag"] | components["schemas"]["RelationCompatibleVehicles"] | components["schemas"]["RelationAllOrNone"];
+        /**
+         * All or none
+         * @description All or none: either every member in `stops` is served, or none is.
+         *     Sets no timing; combine with `synchronized` or `time_lag` for when.
+         *     Hard. Overlapping `all_or_none` relations chain: one on A and B plus
+         *     one on B and C serve all three together or none of them. A group with
+         *     a task in a vehicle's locked prefix (`plan.routes[].locked_count`) is
+         *     exempt.
+         *
+         *     Every task must also be named by a `synchronized` or `time_lag`
+         *     relation; a task named by neither is rejected with HTTP 400.
+         */
+        RelationAllOrNone: {
             /**
-             * @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).
+             * @description Job ids, at least two. A shipment's own id or a shipment-leg stop id
+             *     is rejected with HTTP 400.
+             * @example [
+             *       "job-1",
+             *       "job-2"
+             *     ]
              */
             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).
+             * @description Discriminator: always `all_or_none`. (enum property replaced by openapi-typescript)
+             * @enum {string}
              */
-            stops?: string[] | null;
-            /** @description Tag selecting the relation members (mutually exclusive with `stops`). */
-            tag?: string | null;
-            /** @enum {string} */
-            type: "same_vehicle";
-        } | {
+            type: "all_or_none";
+        };
+        /**
+         * Compatible vehicles
+         * @description Which vehicles may serve a set of tasks together. Every two distinct
+         *     vehicles serving `stops` must be compatible under
+         *     `vehicles[].compatible_with`; with no lists it restricts nothing.
+         *     Tasks left unassigned impose nothing, so a group may be served
+         *     partially. Hard.
+         *
+         *     Every task must also be named by a `synchronized` or `time_lag`
+         *     relation; a task named by neither is rejected with HTTP 400. At most
+         *     16 tasks per relation.
+         */
+        RelationCompatibleVehicles: {
+            /**
+             * @description Job ids, 2 to 16. A shipment's own id or a shipment-leg stop id
+             *     is rejected with HTTP 400.
+             * @example [
+             *       "job-1",
+             *       "job-2"
+             *     ]
+             */
+            stops: string[];
+            /**
+             * @description Discriminator: always `compatible_vehicles`. (enum property replaced by openapi-typescript)
+             * @enum {string}
+             */
+            type: "compatible_vehicles";
+        };
+        /**
+         * @description Which instant of a member a `synchronized` or `time_lag` relation is
+         *     measured at, named after the response stop field that reports it. There is
+         *     no `arrival`: a relation bounds when service happens, not when the vehicle
+         *     gets there.
+         * @enum {string}
+         */
+        RelationInstant: "service_start" | "departure";
+        /**
+         * Same day
+         * @description Same calendar day: every member that is served is served on the same
+         *     day. The day is the calendar date of the serving shift's `from`, read
+         *     in that value's own UTC offset, not the time of the stop. Like
+         *     `same_vehicle`, it constrains only the members that end up assigned.
+         */
+        RelationSameDay: {
             /**
-             * @description Job or shipment ids in the relation (mutually exclusive with
-             *     `tag`; stop-id members are not resolved yet).
+             * @description Job ids or shipment-leg stop ids in the relation (mutually
+             *     exclusive with `tag`). A shipment's own id is rejected with
+             *     HTTP 400 `not_supported`.
              */
             stops?: string[] | null;
             /** @description Tag selecting the relation members (mutually exclusive with `stops`). */
             tag?: string | null;
-            /** @enum {string} */
+            /**
+             * @description Discriminator: always `same_day`. (enum property replaced by openapi-typescript)
+             * @enum {string}
+             */
             type: "same_day";
-        } | {
+        } & (unknown | unknown);
+        /**
+         * Same route
+         * @description Same route: every member that ends up assigned is served by one
+         *     vehicle shift (one entry of `shifts`), stricter than
+         *     `same_vehicle` for vehicles with several `shifts`. Reloads within
+         *     the shift do not split a route. Hard-only, with `same_vehicle`'s
+         *     partial-service semantics.
+         */
+        RelationSameRoute: {
             /**
-             * @description Job or shipment ids in the relation (mutually exclusive with
-             *     `tag`; stop-id members are not resolved yet).
+             * @description Job ids or shipment-leg stop ids in the relation (mutually
+             *     exclusive with `tag`). A shipment's own id is rejected with HTTP
+             *     400.
              */
             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`.
+             * @description Discriminator: always `same_route`. (enum property replaced by openapi-typescript)
+             * @enum {string}
              */
-            max_wait_s: number;
+            type: "same_route";
+        } & (unknown | unknown);
+        /**
+         * Same vehicle
+         * @description Same vehicle: every member that is served is served by the same
+         *     vehicle, on any of its shifts.
+         */
+        RelationSameVehicle: {
             /**
-             * @description Which instant is synchronized: the service `start` (default) or
-             *     the service `end`. `arrival` is rejected with HTTP 400.
+             * @description Job ids or shipment-leg stop ids in the relation (mutually
+             *     exclusive with `tag`). A shipment's own id is rejected with
+             *     HTTP 400 `not_supported`.
              */
-            on?: null | components["schemas"]["StopInstant"];
+            stops?: string[] | null;
+            /** @description Tag selecting the relation members (mutually exclusive with `stops`). */
+            tag?: string | null;
             /**
-             * @description Participating job or shipment ids (stop-id members are not
-             *     resolved yet).
+             * @description Discriminator: always `same_vehicle`. (enum property replaced by openapi-typescript)
+             * @enum {string}
+             */
+            type: "same_vehicle";
+        } & (unknown | unknown);
+        /**
+         * Sequence
+         * @description Ordering (gaps allowed). Constrains members that end up on the **same
+         *     route** only: members on different vehicles are unordered relative to
+         *     each other.
+         */
+        RelationSequence: {
+            /**
+             * @description Job ids or shipment-leg stop ids (`pickup.id` / `delivery.id`, by
+             *     default `"{shipment}:pickup"` / `"{shipment}:delivery"`), in the
+             *     order they must be served. A shipment's own id is
+             *     rejected with HTTP 400 `not_supported`.
+             */
+            stops: string[];
+            /**
+             * @description Discriminator: always `sequence`. (enum property replaced by openapi-typescript)
+             * @enum {string}
+             */
+            type: "sequence";
+        };
+        /**
+         * Synchronized
+         * @description Synchronized starts (or ends) across vehicles: every member's
+         *     service start — or with `on: departure`, its service end — lies within
+         *     `max_spread_s` seconds of every other member's. Hard, checked across
+         *     routes; the returned schedule holds a member back where needed so
+         *     the bound is met (see `hold_s` on the stop). A hold waits inside the
+         *     regular shift only: a member is never held past its shift's `to`
+         *     into overtime (`max_overtime_s`); a group that could only meet the
+         *     bound that way is left unassigned instead.
+         */
+        RelationSynchronized: {
+            /**
+             * Format: int64
+             * @description Maximum spread between the synchronized instants in seconds
+             *     (`0` = exact simultaneity). Required. A negative value, or one that
+             *     does not fit in 32 bits, is rejected with HTTP 400 `out_of_range`.
+             */
+            max_spread_s: number;
+            /**
+             * @description Which instant is synchronized: `service_start` (default) or
+             *     `departure` (the service end), the stop fields of the same names.
+             * @default service_start
+             */
+            on?: null | components["schemas"]["RelationInstant"];
+            /**
+             * @description Participating job ids, at most 8 (HTTP 400 `limit_exceeded`
+             *     beyond that). A shipment-leg stop id is rejected with HTTP 400;
+             *     a shipment's own id with HTTP 400 `not_supported`.
              */
             stops: string[];
-            /** @enum {string} */
+            /**
+             * @description Discriminator: always `synchronized`. (enum property replaced by openapi-typescript)
+             * @enum {string}
+             */
             type: "synchronized";
-        } | {
+        };
+        /**
+         * Tag order
+         * @description Ordering between tags: on every route, every task carrying `tags[0]`
+         *     precedes every task carrying `tags[1]`, and so on. Tasks carry
+         *     membership via their own `tags`. At most one `tag_order` per request.
+         *
+         *     Jobs only: if a tag named here selects a **shipment**, the request is
+         *     rejected with HTTP 400 (a shipment's two legs already carry their own
+         *     hard precedence, which tag ordering cannot compose with yet). Drop the
+         *     tag from the shipment.
+         */
+        RelationTagOrder: {
+            /** @description Tag labels in precedence order. Requires at least 2 entries. */
+            tags: string[];
+            /**
+             * @description Discriminator: always `tag_order`. (enum property replaced by openapi-typescript)
+             * @enum {string}
+             */
+            type: "tag_order";
+        };
+        /**
+         * Time lag
+         * @description A directional time bound between two jobs on any vehicles:
+         *     `t(to) − t(from)` must lie in `[min_s, max_s]` seconds, each end
+         *     measured at the job's service start or end (`on`). "B starts at
+         *     least an hour after A ends" is `from: {stop: A, on: departure}, to: {stop: B},
+         *     min_s: 3600`; "A and B finish together" is both ends `on: departure` with
+         *     `min_s: 0, max_s: 0`. `min_s` defaults to `0`; an absent `max_s` is
+         *     unbounded; both may be negative. Hard, checked across routes like
+         *     `synchronized` (an unassigned end imposes nothing). A job may take
+         *     part in any number of `time_lag` relations; a chain is written as
+         *     one relation per consecutive pair. As with `synchronized`, a hold
+         *     never waits past the shift's regular end (`to`).
+         */
+        RelationTimeLag: {
             /** @description The reference end. */
-            from: components["schemas"]["TimeLagEnd"];
+            from: components["schemas"]["TimeLagMember"];
             /**
              * Format: int64
              * @description Upper bound on `t(to) − t(from)` in seconds. Absent = unbounded.
+             *     Must fit in 32 bits and be `>= min_s` (HTTP 400 otherwise).
              */
             max_s?: number | null;
             /**
              * Format: int64
-             * @description Lower bound on `t(to) − t(from)` in seconds. Default `0`.
+             * @description Lower bound on `t(to) − t(from)` in seconds. Default `0`. Must fit
+             *     in 32 bits.
+             * @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";
-        } | {
+            to: components["schemas"]["TimeLagMember"];
             /**
-             * @description Job ids, at least two.
-             * @example [
-             *       "job-1",
-             *       "job-2"
-             *     ]
+             * @description Discriminator: always `time_lag`. (enum property replaced by openapi-typescript)
+             * @enum {string}
              */
-            stops: string[];
-            /** @enum {string} */
-            type: "all_or_none";
+            type: "time_lag";
         };
         /**
          * @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",
+         *       "message": "Extend a time window by 900s (~15 min).",
          *       "op": "extend_time_window",
-         *       "suggestion": "Extend a time window by 900s (~15 min).",
+         *       "pointer": "/problem/jobs/1/time_windows",
          *       "unit": "s"
          *     }
          */
@@ -1279,37 +1609,60 @@ export interface components {
              * @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;
+            message: string;
+            /** @description The kind of change suggested. */
+            op: components["schemas"]["RelaxationOp"];
             /**
-             * @description Unit of `amount`: `"s"` (seconds, for `extend_time_window`) or
-             *     `"load"` (demand units, for `reduce_demand`).
-             * @example s
+             * @description [RFC 6901] JSON Pointer to the request field to change, like
+             *     `warnings[].pointer`. For a job: `/problem/jobs/{i}/pickup_load`
+             *     (`/problem/jobs/{i}/delivery_load` for a job with only a
+             *     `delivery_load`) or `/problem/jobs/{i}/time_windows`. For a shipment:
+             *     `/problem/shipments/{i}/load` or `/problem/shipments/{i}/pickup/time_windows`
+             *     (either leg's window may be the one to extend). It may name a field the
+             *     request omits (a JSON Patch `add` target); its task prefix always resolves.
+             *
+             *     [RFC 6901]: https://www.rfc-editor.org/rfc/rfc6901
+             * @example /problem/jobs/1/time_windows
              */
-            unit: string;
+            pointer: string;
+            /** @description Unit of `amount`: `s` for `extend_time_window`, `load` for `reduce_load`. */
+            unit: components["schemas"]["QuantityUnit"];
         };
         /**
          * @description The kind of change a relaxation suggests.
+         *
+         *     Known values: `reduce_load`, `extend_time_window`. An open set: a later release may add values, so accept any string and handle the ones you know.
          * @example extend_time_window
-         * @enum {string}
          */
-        RelaxationOp: "reduce_demand" | "extend_time_window";
+        RelaxationOp: string;
+        /** @description One problem in a request. */
+        RequestIssue: {
+            /**
+             * 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 A single vehicle's route.
          * @example {
@@ -1347,6 +1700,7 @@ export interface components {
          *             51.05
          *           ],
          *           "service_s": 300,
+         *           "service_start": "2026-07-01T09:00:00+02:00",
          *           "travel_s": 600,
          *           "type": "job",
          *           "wait_s": 3000
@@ -1365,6 +1719,7 @@ export interface components {
          *             51.06
          *           ],
          *           "service_s": 600,
+         *           "service_start": "2026-07-01T09:13:00+02:00",
          *           "travel_s": 480,
          *           "type": "job",
          *           "wait_s": 0
@@ -1383,7 +1738,8 @@ export interface components {
          *           ],
          *           "service_s": 0,
          *           "travel_s": 900,
-         *           "type": "end"
+         *           "type": "end",
+         *           "wait_s": 0
          *         }
          *       ],
          *       "time": {
@@ -1406,11 +1762,11 @@ export interface components {
              */
             distance_m: number;
             /** @description Peak load reached on the route, by named dimension. */
-            load_peak?: null | components["schemas"]["BTreeMap"];
+            load_peak?: null | components["schemas"]["Quantities"];
             /**
              * @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
+             *     `options.polyline` 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
@@ -1427,8 +1783,14 @@ export interface components {
              * @example mon
              */
             shift: string;
-            /** @description Ordered stops, including depot bookends. */
-            stops: components["schemas"]["StopOutput"][];
+            /**
+             * @description Stops in time order (by `departure`), including depot bookends. A
+             *     windowed break taken while the vehicle is at a stop is listed just
+             *     before that stop and lies within that stop's `arrival` to `departure`
+             *     (the end stop included); drive, duty and unavailability breaks end
+             *     before the next stop's `arrival`.
+             */
+            stops: components["schemas"]["RouteStop"][];
             /**
              * @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
@@ -1438,7 +1800,7 @@ export interface components {
             /** @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`,
+             * @description Route-level constraint violations (e.g. `max_distance`, `max_route_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.
@@ -1446,28 +1808,223 @@ export interface components {
             violations?: components["schemas"]["Violation"][];
         };
         /**
-         * @description How good a plan is. Plans compare in order: fewer `violations` first,
-         *     then less `unserved_priority`, then less `cost`.
+         * @description A single stop within a route.
+         *
+         *     One flat object for every stop `type`. `type`, `arrival` and `departure`
+         *     are present on every stop; every other field is present only on the stop
+         *     types its description names, and absent (not `null`) elsewhere:
+         *
+         *     | `type` | fields beyond `type`, `arrival`, `departure` |
+         *     | --- | --- |
+         *     | `job`, `pickup`, `delivery` | `id`, `location`, `service_start`, `wait_s`, `service_s`, `travel_s`, `distance_m`, `lateness_s`; `hold_s`, `target_lateness_s`, `violations` when they apply |
+         *     | `start` | `depot`, `location`, `service_s` (absent on an open start) |
+         *     | `end` | `depot`, `location`, `wait_s`, `service_s` (absent on an open end), `travel_s`, `distance_m` |
+         *     | `reload` | `depot`, `location`, `service_start`, `wait_s`, `service_s`, `travel_s`, `distance_m` |
+         *     | `break` | `id` (when the request break names one), `service_s` |
+         *
+         *     `load_after` is on every stop when the problem declares a capacity
+         *     dimension, and `snapped_location` wherever there is a `location` and the
+         *     routing graph snapped it.
+         *
+         *     Every stop time is RFC 3339, 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 {
+         *       "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,
+         *       "service_start": "2026-07-01T09:00:00+02:00",
+         *       "travel_s": 600,
+         *       "type": "job",
+         *       "wait_s": 3000
+         *     }
+         */
+        RouteStop: {
+            /**
+             * Format: date-time
+             * @description Physical arrival, before any waiting. On `start` when the route
+             *     begins; on `break` when the break starts.
+             * @example 2026-07-01T08:10:00+02:00
+             */
+            arrival: string;
+            /**
+             * Format: date-time
+             * @description Departure. On `end` when the route finishes, after any depot
+             *     handling time; on `break` when the break ends (`arrival + service_s`).
+             * @example 2026-07-01T09:05:00+02:00
+             */
+            departure: string;
+            /**
+             * @description The `depots[].id` of this stop: on every `reload` stop, and on a
+             *     `start`/`end` stop whose shift end names a depot. 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. On task, `reload`
+             *     and `end` stops.
+             * @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. On task stops, only when non-zero.
+             * @example 0
+             */
+            hold_s?: number | null;
+            /**
+             * @description On a `job` stop the job id; on `pickup`/`delivery` the leg's stop id
+             *     (its own `id`, else `{shipment}:pickup` / `{shipment}:delivery`); on a
+             *     `break` stop the `id` of the request break (`shifts[].breaks[].id`)
+             *     it realises, absent when that break named none. Absent on `start`,
+             *     `end` and `reload`.
+             * @example job-1
+             */
+            id?: string | null;
+            /**
+             * Format: int32
+             * @description Seconds late beyond the latest allowed arrival (`0` when on time), on
+             *     task stops, measured from the arrival plus any `windowed` break taken
+             *     on arrival at this stop (idle until that break's window opens
+             *     included). Measures the hard time window only; a soft target is
+             *     reported in `target_lateness_s`.
+             * @example 0
+             */
+            lateness_s?: number | null;
+            /**
+             * @description Load on board after this stop, by named dimension: on `start` when
+             *     the vehicle leaves, on `reload` the next trip's departure stock, on
+             *     `break` the load after the previous stop. Absent when the problem
+             *     declares no capacity dimension.
+             */
+            load_after?: null | components["schemas"]["Quantities"];
+            /**
+             * @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 end (no configured
+             *     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 Time spent at this stop, in seconds.
+             *
+             *     On task stops, the **effective** on-site service time, not the
+             *     nominal `service_duration_s` from the request: it already has the
+             *     serving vehicle's `service_factor` applied. `departure -
+             *     service_start - service_s` is the stop's setup time: the request's
+             *     `setup_duration_s` (unscaled) for the first stop of a run at the same
+             *     location (setup is charged when the previous stop is elsewhere), and 0
+             *     for a co-located successor.
+             *
+             *     On `reload`, the depot's handling time (`departure - service_start
+             *     == service_s`). On `start`/`end`, the depot handling time applied
+             *     there (0 on a free-travel end), so `departure - arrival == service_s`
+             *     on a start and `departure - arrival - wait_s - Σ windowed break
+             *     service_s == service_s` on an end; absent on an open start or end. On `break`, the
+             *     break length (`departure - arrival`). `service_factor` never scales
+             *     depot, reload or break time.
+             * @example 300
+             */
+            service_s?: number | null;
+            /**
+             * Format: date-time
+             * @description When service starts: `arrival + wait_s` plus the duration of any
+             *     windowed break taken on arrival here. On task and `reload` stops only.
+             * @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
+             *     (plus any `windowed` break taken on arrival there, idle before it
+             *     included) 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. On task, `reload`
+             *     and `end` stops.
+             * @example 600
+             */
+            travel_s?: number | null;
+            /** @description What kind of stop this is. */
+            type: components["schemas"]["StopType"];
+            /**
+             * @description Constraint violations detected at this task 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, counted in `time.wait_s`. On task stops:
+             *     before service, for the time window to open and for any cross-route
+             *     hold (`hold_s`, included in this figure). On `reload`: before the
+             *     reload. On both, also the idle before a windowed break taken on
+             *     arrival here whose window had not opened yet, so `service_start ==
+             *     arrival + wait_s + Σ` those breaks' `service_s`. On `end`: idle time
+             *     at the end, `departure - arrival - service_s` less the `service_s` of
+             *     break stops taken there, clamped to be never negative. Idle before a
+             *     break is not charged by `per_wait_hour`. Absent on `start` (a start
+             *     never waits) and `break`.
+             * @example 3000
+             */
+            wait_s?: number | null;
+        };
+        /**
+         * @description How good a plan is. Plans compare in order: fewer `violation_count`
+         *     first, then less `unassigned_priority`, then less `cost`.
          * @example {
          *       "components": {
-         *         "depot_visits": 0,
+         *         "assignment": 0,
          *         "distance": 1.69,
-         *         "drop_fees": 0,
-         *         "fixed": 0,
+         *         "drop_costs": 0,
          *         "grouping": 0,
          *         "lateness": 0,
-         *         "other": 0,
          *         "overtime": 0,
+         *         "preferences": 0,
+         *         "reloads": 0,
+         *         "routes": 0,
          *         "tag_preference": 0,
          *         "target": 0,
          *         "time": 57.1536,
          *         "waiting": 0,
-         *         "window_choice": 0
+         *         "window_choice": 0,
+         *         "workload_share": 0
          *       },
          *       "cost": 58.8436,
          *       "currency": "EUR",
-         *       "unserved_priority": 0,
-         *       "violations": 0
+         *       "unassigned_priority": 0,
+         *       "violation_count": 0
          *     }
          */
         Score: {
@@ -1487,43 +2044,47 @@ export interface components {
             /**
              * Format: int64
              * @description Summed `priority` of the required tasks left unassigned (a task that
-             *     priced a `drop_fee` counts in `components.drop_fees` instead).
+             *     priced a `drop_cost` counts in `components.drop_costs` instead).
              * @example 0
              */
-            unserved_priority: number;
+            unassigned_priority: number;
             /**
              * Format: int32
-             * @description Hard-constraint violations. Always `0` on a solve result.
+             * @description How many hard-constraint violations the plan has (the `violations`
+             *     arrays on routes and stops list them). Always `0` on a solve result.
              * @example 0
              */
-            violations: number;
+            violation_count: 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,
+         *       "assignment": 0,
          *       "distance": 1.69,
-         *       "drop_fees": 0,
-         *       "fixed": 0,
+         *       "drop_costs": 0,
          *       "grouping": 0,
          *       "lateness": 0,
-         *       "other": 0,
          *       "overtime": 0,
+         *       "preferences": 0,
+         *       "reloads": 0,
+         *       "routes": 0,
          *       "tag_preference": 0,
          *       "target": 0,
          *       "time": 57.1536,
          *       "waiting": 0,
-         *       "window_choice": 0
+         *       "window_choice": 0,
+         *       "workload_share": 0
          *     }
          */
         ScoreComponents: {
             /**
              * Format: double
-             * @description Cost of reload visits, in currency units (`depots[].cost_per_visit`).
+             * @description Cost of the serving vehicle's `assignment_costs[].cost` (or the task's
+             *     default assignment cost), in currency units.
              */
-            depot_visits: number;
+            assignment: number;
             /**
              * Format: double
              * @description Distance cost, in currency units: each route's distance priced at
@@ -1532,15 +2093,9 @@ export interface components {
             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.
+             * @description The summed `drop_cost` of the tasks left unassigned, in currency units.
              */
-            fixed: number;
+            drop_costs: number;
             /**
              * Format: double
              * @description Cost of splitting close tasks across routes, in currency units
@@ -1553,19 +2108,30 @@ export interface components {
              *     (`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 `preferences[].violation_cost`, in currency units: paid for
+             *     each listed vehicle that did not serve the task. Tag preferences are
+             *     `tag_preference`.
+             */
+            preferences: number;
+            /**
+             * Format: double
+             * @description Cost of reload visits, in currency units (`depots[].per_reload`).
+             */
+            reloads: number;
+            /**
+             * Format: double
+             * @description Vehicle cost, in currency units: `costs.per_route` once per used shift,
+             *     at the shift's, vehicle's or fleet's rate.
+             */
+            routes: number;
             /**
              * Format: double
              * @description Cost of serving tasks outside a vehicle's `preferred_tags`, in
@@ -1587,7 +2153,8 @@ export interface components {
             /**
              * 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`.
+             *     route's wait priced at its `costs.per_wait_hour`. Idle before a
+             *     windowed break opens is in `time.wait_s` but not priced here.
              */
             waiting: number;
             /**
@@ -1596,7 +2163,31 @@ export interface components {
              *     units (`time_windows[].cost`).
              */
             window_choice: number;
+            /**
+             * Format: double
+             * @description Workload outside the equal-share band, in currency units
+             *     (`objective.workload_share`).
+             */
+            workload_share: number;
+        };
+        /** @description How the search behind a plan ended. */
+        SearchInfo: {
+            /**
+             * Format: int64
+             * @description Search iterations performed. `0` when nothing was searched.
+             * @example 48210
+             */
+            iterations: number;
+            /** @description How the search ended. */
+            termination: components["schemas"]["SearchTermination"];
         };
+        /**
+         * @description How the search ended. New values may be added; clients must accept
+         *     unknown values.
+         *
+         *     Known values: `time_limit`, `no_improvement`, `not_searched`. An open set: a later release may add values, so accept any string and handle the ones you know.
+         */
+        SearchTermination: string;
         /**
          * @description Per-vehicle work-rate override for one task's `service_duration_s`.
          * @example {
@@ -1607,9 +2198,14 @@ export interface components {
         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.
+             * @description Work-rate factor of `vehicle` on this task. Service time is DIVIDED by
+             *     it: above `1` the vehicle works faster here, below `1` slower; `1.0` is a
+             *     no-op. It multiplies the vehicle's own rate (the shift's
+             *     `service_factor` if set, else the vehicle's): effective service time =
+             *     `service_duration_s / (shift_or_vehicle_factor * factor)`. Same
+             *     direction and `[0.001, 5]` range as `vehicles[].service_factor`. V2's
+             *     `proficiency.durationModifier` multiplied duration instead; the V2
+             *     compatibility layer sends its inverse (`1 / durationModifier`) here.
              * @example 1.25
              */
             factor: number;
@@ -1651,7 +2247,7 @@ export interface components {
              *     vehicle's value for that dimension; dimensions not named keep the
              *     vehicle's `capacity`.
              */
-            capacity?: null | components["schemas"]["BTreeMap"];
+            capacity?: null | components["schemas"]["Quantities"];
             /**
              * @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,
@@ -1659,7 +2255,23 @@ export interface components {
              */
             costs?: null | components["schemas"]["Costs"];
             /** @description Where the shift ends. Absent = open end. */
-            end?: null | components["schemas"]["ShiftEnd"];
+            end?: null | components["schemas"]["ShiftPlace"];
+            /**
+             * @description Symmetric to `free_start_travel` for travel from the last task to
+             *     `end`; `true` without `end` is a 400.
+             * @example false
+             */
+            free_end_travel?: boolean | null;
+            /**
+             * @description When `true`, travel from `start` to the first task is free: it takes
+             *     no time and costs nothing, and is left out of the route's distance
+             *     and duration. The depot is still reported (a real stop, snapped
+             *     coordinate, departure time). Distinct from omitting `start` (an open
+             *     route, which drops the depot entirely). `true` without `start` is
+             *     rejected with HTTP 400 `conflicting_fields`. Default `false`.
+             * @example false
+             */
+            free_start_travel?: boolean | null;
             /**
              * Format: date-time
              * @description Shift start (RFC 3339 instant, UTC offset required).
@@ -1671,22 +2283,6 @@ export interface components {
              * @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
@@ -1698,7 +2294,7 @@ export interface components {
              *     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"];
+            initial_load?: null | components["schemas"]["Quantities"];
             /**
              * @description Limits for this shift only. Each field set here replaces the
              *     vehicle's `limits` value; fields not set keep it.
@@ -1708,7 +2304,7 @@ export interface components {
              * 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`.
+             *     hold stops at `to`. Default: none (`to` is hard). Must be `>= 0`.
              * @example 1800
              */
             max_overtime_s?: number | null;
@@ -1719,17 +2315,18 @@ export interface components {
              *     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`;
+             *     revisited up to 8 times per shift 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.
+             *     one reload depot to raise the practical ceiling. `0` is rejected with
+             *     HTTP 400 (the first trip already counts as trip 1).
              * @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
+             *     depot's `service_duration_s` and `per_reload`. Cap trips with
              *     `max_trips`.
              */
             reloads?: string[] | null;
@@ -1741,12 +2338,14 @@ export interface components {
             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).
+             * @description Work-rate factor for this shift only. It REPLACES
+             *     `vehicles[].service_factor` for the shift when set (absent = inherit the
+             *     vehicle's value, which itself defaults to 1.0); a task's
+             *     `service_factors[].factor` for this vehicle multiplies it.
              *
-             *     Same meaning, direction, and `(0, 5]` range as the vehicle-level field:
-             *     effective service time = `service_duration_s / service_factor`. Use it
+             *     Same meaning, direction, and `[0.001, 5]` range as the vehicle-level
+             *     field: service time is DIVIDED by it, effective service time =
+             *     `service_duration_s / service_factor`, so above `1` is faster. 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.
@@ -1761,14 +2360,14 @@ export interface components {
              * @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
+             *     job's `required_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"];
+            start?: null | components["schemas"]["ShiftPlace"];
             /**
              * Format: date-time
              * @description Shift end (RFC 3339 instant, UTC offset required; hard unless `max_overtime_s` set). The
@@ -1778,62 +2377,65 @@ export interface components {
             to: string;
         };
         /**
-         * @description Where a shift starts or ends: exactly one of `location` or `depot`.
+         * @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 {
-         *       "depot": "gent"
+         *       "max_stops": 12
          *     }
          */
-        ShiftEnd: {
+        ShiftLimits: {
             /**
-             * @description A `depots[].id`. Excludes `location`.
-             * @example gent
+             * Format: int64
+             * @description Hard cap on this shift's route distance, in metres. `0` to
+             *     `2147483647`, as on the vehicle.
+             * @example 200000
              */
-            depot?: string | null;
-            /** @description An inline place. Excludes `depot`. */
-            location?: null | components["schemas"]["Place"];
+            max_distance_m?: number | null;
+            /**
+             * Format: int64
+             * @description Hard cap on this shift's route span, in seconds. `0` to
+             *     `2147483647`, as on the vehicle.
+             * @example 32400
+             */
+            max_route_duration_s?: number | null;
             /**
              * 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
+             * @description Maximum stops served in this shift; a job counts as one stop.
+             *     Start, end, break and reload stops in `routes[].stops` do not count; a
+             *     shipment counts as two stops.
+             * @example 50
              */
-            service_duration_s?: number | null;
+            max_stops?: 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.
+         * @description Where a shift starts or ends: exactly one of `location` or `depot`.
          * @example {
-         *       "max_tasks": 12
+         *       "depot": "gent"
          *     }
          */
-        ShiftLimits: {
-            /**
-             * Format: int64
-             * @description Hard cap on this shift's route distance, in metres.
-             * @example 200000
-             */
-            max_distance_m?: number | null;
+        ShiftPlace: {
             /**
-             * Format: int64
-             * @description Hard cap on this shift's route span, in seconds.
-             * @example 32400
+             * @description A `depots[].id`. Excludes `location`.
+             * @example gent
              */
-            max_route_duration_s?: number | null;
+            depot?: string | null;
+            /** @description An inline place. Excludes `depot`. */
+            location?: null | components["schemas"]["Place"];
             /**
              * Format: int32
-             * @description Maximum stops served in this shift: a job counts as one stop, a
-             *     shipment as two (pickup and delivery).
-             * @example 50
+             * @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
+             *     free travel (`free_start_travel`/`free_end_travel`). 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
              */
-            max_tasks?: number | null;
-        };
+            service_duration_s?: number | null;
+        } & (unknown | unknown);
         /**
          * @description A vehicle and one of its shifts: the key of a plan route.
          * @example {
@@ -1853,7 +2455,7 @@ export interface components {
          *     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
+         *     `drop_cost` 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.
@@ -1886,29 +2488,36 @@ export interface components {
              *     `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.
+             *     below `priority`, and adds to `preferences`, `drop_cost` 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"];
+            delivery: components["schemas"]["ShipmentStop"];
             /**
              * 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.
+             *     droppable. Tasks without a `drop_cost` 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`.
+             *     dropping it. Drop costs the plan chose to pay are reported in
+             *     `score.components.drop_costs` and summed into `score.cost`.
              *
-             *     On a shipment the fee applies to the pair, charged once.
+             *     On a shipment the drop cost applies to the pair, charged once.
+             *
+             *     Must be finite, `>= 0` and at most `1e9`; combined with `priority` it
+             *     is rejected with HTTP 400 (`conflicting_fields`).
              * @example 25
              */
-            drop_fee?: number | null;
-            /** @description Hard vehicle allow/exclude. */
-            eligible_vehicles?: null | components["schemas"]["Eligibility"];
+            drop_cost?: number | null;
+            /**
+             * @description Hard vehicle allow/exclude. A request may use at most 256 distinct
+             *     permitted-vehicle sets (after resolving `allowed`/`excluded`) across
+             *     all jobs and shipments (HTTP 400 `limit_exceeded` beyond that).
+             */
+            eligible_vehicles?: null | components["schemas"]["VehicleEligibility"];
             /**
              * @description Shipment id: 1 to 128 characters, unique across `jobs` + `shipments`.
              * @example ship-1
@@ -1919,80 +2528,50 @@ export interface components {
              *     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;
+            load?: null | components["schemas"]["Quantities"];
             /** @description Pickup leg (load on). */
-            pickup: components["schemas"]["Stop"];
+            pickup: components["schemas"]["ShipmentStop"];
             /**
              * @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;
+            preferences?: components["schemas"]["VehiclePreference"][] | 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.
+             *     task droppable; use `drop_cost` 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.
+             * @description Hard skill requirements — the assigned vehicle must provide every one,
+             *     at or above each requirement's `min_level`. A request may use at most
+             *     256 distinct `(name, min_level)` pairs across all jobs and shipments
+             *     (HTTP 400 `limit_exceeded` beyond that).
              */
-            service_factors?: components["schemas"]["ServiceFactor"][] | null;
+            required_skills?: components["schemas"]["SkillRequirement"][] | null;
             /**
-             * @description Hard skill requirements — the assigned vehicle must provide every one,
-             *     at or above each requirement's `min_level`.
+             * @description Per-vehicle work-rate factors for this task's `service_duration_s`,
+             *     which is DIVIDED by the factor (above `1` = faster). Each multiplies
+             *     the serving vehicle's rate (the shift's `service_factor` if set, else
+             *     the vehicle's): effective service time = `service_duration_s /
+             *     (shift_or_vehicle_factor * factor)`. On a shipment the factor scales
+             *     both legs. A vehicle not listed works at its own rate.
              */
-            skills?: components["schemas"]["SkillReq"][] | null;
+            service_factors?: components["schemas"]["ServiceFactor"][] | null;
             /**
-             * @description Free-form task labels (zones/territories, grouping/relation labels).
+             * @description Free-form task labels (zones/territories, 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.
+             *     `required_skills`, which requires ALL. Not capability matching on its own.
+             *     A request may carry at most 256 distinct tags across all jobs and
+             *     shipments (HTTP 400 `limit_exceeded` beyond that); vehicle-side tag
+             *     lists do not count.
              */
             tags?: string[] | null;
             /**
@@ -2001,13 +2580,70 @@ export interface components {
              */
             target?: null | components["schemas"]["Target"];
         };
+        /**
+         * @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"
+         *         }
+         *       ]
+         *     }
+         */
+        ShipmentStop: {
+            /**
+             * @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. Default `0`;
+             *     a negative value is rejected with HTTP 400.
+             * @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.
+             *     Default `0`; a negative value is rejected with HTTP 400.
+             * @example 60
+             */
+            setup_duration_s?: number | null;
+            /** @description Time windows for this stop. */
+            time_windows?: components["schemas"]["TimeWindow"][] | null;
+        };
         /**
          * @description A hard skill requirement — the assigned vehicle must provide it.
          * @example {
          *       "name": "fridge"
          *     }
          */
-        SkillReq: {
+        SkillRequirement: {
             /**
              * Format: int32
              * @description Minimum level the serving vehicle must hold for this skill (`>= 1`).
@@ -2024,7 +2660,7 @@ export interface components {
         /**
          * @description Solve options.
          * @example {
-         *       "polylines": "full",
+         *       "polyline": "full",
          *       "seed": 42,
          *       "time_limit_s": 5
          *     }
@@ -2032,25 +2668,28 @@ export interface components {
         SolveOptions: {
             /**
              * @description Return road geometry for each route as `routes[].polyline`:
-             *     `simplified` or `full`. Omitted → no geometry (the default).
+             *     `simplified` or `full`. Omitted → no geometry (the default). One value
+             *     for the whole request, named like the response field it fills.
              */
-            polylines?: null | components["schemas"]["PolylineDetail"];
+            polyline?: 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.
+             * @default 42
              * @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.
+             * @description Search time budget in seconds, fractions allowed. Default when omitted:
+             *     150 ms plus 4 ms per task (jobs and shipments combined), so 100 tasks
+             *     search for 0.55 s. Maximum 60: 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;
@@ -2059,6 +2698,7 @@ export interface components {
              *     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.
+             * @default estimate
              */
             travel_fallback?: null | components["schemas"]["TravelFallback"];
         };
@@ -2086,15 +2726,15 @@ export interface components {
          *               3.725,
          *               51.05
          *             ],
-         *             "pickup": {
+         *             "pickup_load": {
          *               "weight": 20
          *             },
-         *             "service_duration_s": 300,
-         *             "skills": [
+         *             "required_skills": [
          *               {
          *                 "name": "fridge"
          *               }
          *             ],
+         *             "service_duration_s": 300,
          *             "time_windows": [
          *               {
          *                 "from": "2026-07-01T09:00:00+02:00",
@@ -2108,7 +2748,7 @@ export interface components {
          *               3.71,
          *               51.06
          *             ],
-         *             "pickup": {
+         *             "pickup_load": {
          *               "weight": 35
          *             },
          *             "service_duration_s": 600
@@ -2167,7 +2807,7 @@ export interface components {
              */
             plan?: null | components["schemas"]["Plan"];
             /** @description The problem: tasks, fleet, depots, relations, objective, travel. */
-            problem: components["schemas"]["ProblemInput"];
+            problem: components["schemas"]["Problem"];
         };
         /**
          * @description The result of `POST /v3/routing/solve` and `POST /v3/routing/evaluate`:
@@ -2227,6 +2867,7 @@ export interface components {
          *                 51.05
          *               ],
          *               "service_s": 300,
+         *               "service_start": "2026-07-01T09:00:00+02:00",
          *               "travel_s": 600,
          *               "type": "job",
          *               "wait_s": 3000
@@ -2245,6 +2886,7 @@ export interface components {
          *                 51.06
          *               ],
          *               "service_s": 600,
+         *               "service_start": "2026-07-01T09:13:00+02:00",
          *               "travel_s": 480,
          *               "type": "job",
          *               "wait_s": 0
@@ -2263,7 +2905,8 @@ export interface components {
          *               ],
          *               "service_s": 0,
          *               "travel_s": 900,
-         *               "type": "end"
+         *               "type": "end",
+         *               "wait_s": 0
          *             }
          *           ],
          *           "time": {
@@ -2282,30 +2925,36 @@ export interface components {
          *         "distance_m": 8450,
          *         "score": {
          *           "components": {
-         *             "depot_visits": 0,
+         *             "assignment": 0,
          *             "distance": 1.69,
-         *             "drop_fees": 0,
-         *             "fixed": 0,
+         *             "drop_costs": 0,
          *             "grouping": 0,
          *             "lateness": 0,
-         *             "other": 0,
          *             "overtime": 0,
+         *             "preferences": 0,
+         *             "reloads": 0,
+         *             "routes": 0,
          *             "tag_preference": 0,
          *             "target": 0,
          *             "time": 57.1536,
          *             "waiting": 0,
-         *             "window_choice": 0
+         *             "window_choice": 0,
+         *             "workload_share": 0
          *           },
          *           "cost": 58.8436,
          *           "currency": "EUR",
-         *           "unserved_priority": 0,
-         *           "violations": 0
+         *           "unassigned_priority": 0,
+         *           "violation_count": 0
+         *         },
+         *         "search": {
+         *           "iterations": 48210,
+         *           "termination": "time_limit"
          *         },
          *         "shifts_used": 1,
          *         "tasks": {
          *           "served": 2,
-         *           "unserved": 0,
-         *           "unserved_required": 0
+         *           "unassigned": 0,
+         *           "unassigned_required": 0
          *         },
          *         "time": {
          *           "break_s": 0,
@@ -2322,7 +2971,8 @@ export interface components {
          *         },
          *         "vehicles_used": 1
          *       },
-         *       "unassigned": []
+         *       "unassigned": [],
+         *       "warnings": []
          *     }
          */
         SolveResponse: {
@@ -2336,273 +2986,88 @@ export interface components {
             /** @description Aggregate statistics for the solve run. */
             summary: components["schemas"]["Summary"];
             /** @description Tasks that could not be feasibly assigned. */
-            unassigned: components["schemas"]["Unassigned"][];
+            unassigned: components["schemas"]["UnassignedTask"][];
+            /**
+             * @description Inputs the request carried that changed nothing. Always present,
+             *     empty when there are none (no input produces one today); at most 100
+             *     are returned. Each item has a `code`, a `pointer` to the field and a
+             *     `message`. Accept codes you do not know.
+             */
+            warnings: components["schemas"]["RequestIssue"][];
         };
         /**
-         * @description One leg of a shipment (pickup or delivery).
+         * @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`.
+         *
+         *     Known values: `start`, `job`, `pickup`, `delivery`, `break`, `reload`, `end`. An open set: a later release may add values, so accept any string and handle the ones you know.
+         * @example job
+         */
+        StopType: string;
+        /**
+         * @description Suggest options.
          * @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"
-         *         }
-         *       ]
+         *       "max_insertions": 5,
+         *       "time_limit_s": 2
          *     }
          */
-        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"];
+        SuggestOptions: {
             /**
              * 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
+             * @description Max ranked `insertions` in each `suggestions[]` entry, `1` to `10`;
+             *     default 5. It caps the insertions per entry, not the number of
+             *     entries: every task outside `plan` still gets its entry. Values outside
+             *     the range are a 400, never clamped. It also sets the search's beam
+             *     width, `max(8, 4 × max_insertions)`: for a unit of several stops, which
+             *     is never searched exhaustively, each stop after the unit's first keeps
+             *     at most that many partial placements. A single-stop task has every
+             *     feasible position considered unless `time_limit_s` runs out first.
+             * @default 5
+             * @example 5
              */
-            service_duration_s?: number | null;
+            max_insertions?: 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
+             * Format: double
+             * @description Search budget in seconds, fractions allowed (default 1; minimum 0.1 —
+             *     smaller values are raised to it; maximum 60). 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.
+             * @default 1
+             * @example 2.5
              */
-            setup_duration_s?: number | null;
-            /** @description Time windows for this stop. */
-            time_windows?: components["schemas"]["TimeWindow"][] | null;
+            time_limit_s?: number | 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.
+         * @description Why a unit came back with no insertions.
          * @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
+         *       "code": "infeasible",
+         *       "message": "No feasible insertion position found"
          *     }
          */
-        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;
+        SuggestReason: {
+            /** @description Branch on this. Open set; see [`SuggestReasonCode`]. */
+            code: components["schemas"]["SuggestReasonCode"];
             /**
-             * 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
+             * @description `code` as an English sentence, for people and logs. Do not parse it.
+             * @example No feasible insertion position found
              */
-            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;
+            message: string;
         };
         /**
          * @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`.
+         *     and handle them generically, for example by showing `reason.message`.
+         *
+         *     Known values: `time_limit`, `candidates_exhausted`, `infeasible`. An open set: a later release may add values, so accept any string and handle the ones you know.
          * @example infeasible
-         * @enum {string}
          */
-        SuggestReasonCode: "time_limit" | "candidates_exhausted" | "infeasible";
+        SuggestReasonCode: string;
         /**
          * @description Request body for `POST /v3/routing/suggest`.
          *
@@ -2615,7 +3080,7 @@ export interface components {
          *     committed plan; the plan is never modified.
          * @example {
          *       "options": {
-         *         "max_suggestions": 5
+         *         "max_insertions": 5
          *       },
          *       "plan": {
          *         "routes": [
@@ -2639,7 +3104,7 @@ export interface components {
          *               3.725,
          *               51.05
          *             ],
-         *             "pickup": {
+         *             "pickup_load": {
          *               "weight": 10
          *             },
          *             "service_duration_s": 300
@@ -2650,7 +3115,7 @@ export interface components {
          *               3.71,
          *               51.06
          *             ],
-         *             "pickup": {
+         *             "pickup_load": {
          *               "weight": 10
          *             },
          *             "service_duration_s": 300
@@ -2698,12 +3163,11 @@ export interface components {
              * @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"];
+            problem: components["schemas"]["Problem"];
         };
         /**
          * @description Response body for `POST /v3/routing/suggest`.
          * @example {
-         *       "elapsed_ms": 8,
          *       "suggestions": [
          *         {
          *           "insertions": [
@@ -2711,7 +3175,7 @@ export interface components {
          *               "delta": {
          *                 "cost": 12.4,
          *                 "distance_m": 2400,
-         *                 "duration_s": 240
+         *                 "travel_s": 240
          *               },
          *               "placements": [
          *                 {
@@ -2741,34 +3205,43 @@ export interface components {
          *               ]
          *             }
          *           ],
-         *           "job_id": "job-2"
+         *           "task": "job-2"
          *         }
          *       ],
-         *       "truncated": false
+         *       "timings": {
+         *         "total_ms": 8
+         *       },
+         *       "truncated": false,
+         *       "warnings": []
          *     }
          */
         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"][];
+            suggestions: components["schemas"]["TaskSuggestions"][];
+            /**
+             * @description Where the request's wall-clock time went. Only `total_ms` is set:
+             *     suggest has no separate search figure.
+             */
+            timings: components["schemas"]["Timings"];
             /**
              * @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 (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`.
+             *     `reason.code` is then `time_limit`.
+             */
+            truncated: boolean;
+            /**
+             * @description Inputs the request carried that changed nothing, as on a solve
+             *     response. Always present, empty when there are none; at most 100 are
+             *     returned.
              */
-            truncated?: boolean;
+            warnings: components["schemas"]["RequestIssue"][];
         };
         /**
          * @description The plan in numbers: its score, what it serves and what it takes.
@@ -2776,30 +3249,36 @@ export interface components {
          *       "distance_m": 8450,
          *       "score": {
          *         "components": {
-         *           "depot_visits": 0,
+         *           "assignment": 0,
          *           "distance": 1.69,
-         *           "drop_fees": 0,
-         *           "fixed": 0,
+         *           "drop_costs": 0,
          *           "grouping": 0,
          *           "lateness": 0,
-         *           "other": 0,
          *           "overtime": 0,
+         *           "preferences": 0,
+         *           "reloads": 0,
+         *           "routes": 0,
          *           "tag_preference": 0,
          *           "target": 0,
          *           "time": 57.1536,
          *           "waiting": 0,
-         *           "window_choice": 0
+         *           "window_choice": 0,
+         *           "workload_share": 0
          *         },
          *         "cost": 58.8436,
          *         "currency": "EUR",
-         *         "unserved_priority": 0,
-         *         "violations": 0
+         *         "unassigned_priority": 0,
+         *         "violation_count": 0
+         *       },
+         *       "search": {
+         *         "iterations": 48210,
+         *         "termination": "time_limit"
          *       },
          *       "shifts_used": 1,
          *       "tasks": {
          *         "served": 2,
-         *         "unserved": 0,
-         *         "unserved_required": 0
+         *         "unassigned": 0,
+         *         "unassigned_required": 0
          *       },
          *       "time": {
          *         "break_s": 0,
@@ -2825,10 +3304,12 @@ export interface components {
              */
             distance_m: number;
             /**
-             * @description How good the plan is. On `/solve`, `score.violations` is always 0; on
+             * @description How good the plan is. On `/solve`, `score.violation_count` is always 0; on
              *     `/evaluate` it counts the constraints the given plan breaks.
              */
             score: components["schemas"]["Score"];
+            /** @description How the search ended. */
+            search: components["schemas"]["SearchInfo"];
             /**
              * Format: int32
              * @description Routes with at least one task stop: one per used shift.
@@ -2846,10 +3327,11 @@ export interface components {
              *     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
+             *     `score.violation_count` 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.
+             *     Absent when travel is road-routed, and always absent on `/evaluate`,
+             *     which returns the error rather than estimate.
              */
             travel_estimated?: boolean;
             /**
@@ -2875,7 +3357,7 @@ export interface components {
             /**
              * Format: double
              * @description Cost, in the objective's currency, incurred when a task without this
-             *     tag is served.
+             *     tag is served. Must be finite and `>= 0`.
              * @example 25
              */
             violation_cost: number;
@@ -2900,9 +3382,10 @@ export interface components {
             at: string;
             /**
              * @description Which instant of the task is compared to `at`: `arrival` (default) or
-             *     `end`. `start` is rejected with HTTP 400.
+             *     `departure`, the stop fields of the same names.
+             * @default arrival
              */
-            on?: null | components["schemas"]["StopInstant"];
+            on?: null | components["schemas"]["TargetInstant"];
             /**
              * Format: double
              * @description Cost, in the objective's currency, per hour of `on` beyond `at`
@@ -2913,13 +3396,19 @@ export interface components {
              */
             per_late_hour: number;
         };
+        /**
+         * @description Which instant of a task a `target` is measured at, named after the
+         *     response stop field that reports it.
+         * @enum {string}
+         */
+        TargetInstant: "arrival" | "departure";
         /**
          * @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
+         *       "unassigned": 0,
+         *       "unassigned_required": 0
          *     }
          */
         TaskCounts: {
@@ -2932,29 +3421,90 @@ export interface components {
              * Format: int32
              * @description Tasks on no route: the length of `unassigned`.
              */
-            unserved: number;
+            unassigned: number;
             /**
              * Format: int32
-             * @description The unserved tasks that carry no `drop_fee`: tasks the plan was
+             * @description The unassigned tasks that carry no `drop_cost`: tasks the plan was
              *     required to serve and did not.
              */
-            unserved_required: number;
+            unassigned_required: number;
+        };
+        /**
+         * @description Ranked insertion suggestions for a single unit.
+         * @example {
+         *       "insertions": [
+         *         {
+         *           "delta": {
+         *             "cost": 12.4,
+         *             "distance_m": 2400,
+         *             "travel_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"
+         *             }
+         *           ]
+         *         }
+         *       ],
+         *       "task": "job-2"
+         *     }
+         */
+        TaskSuggestions: {
+            /**
+             * @description Ranked feasible insertions, lowest `delta.cost` first. Empty if none
+             *     was found; `reason` then says why. Known limitation: suggest never
+             *     opens a **new reload trip** on a multi-trip vehicle.
+             */
+            insertions: components["schemas"]["InsertionOption"][];
+            /** @description Why `insertions` is empty; absent otherwise. */
+            reason?: null | components["schemas"]["SuggestReason"];
+            /**
+             * @description The unit's lead: its first member in placement order. That is the
+             *     visit, the shipment, the first stop of a `sequence` chain in the
+             *     unit, or else the member that comes first in problem order (`jobs`,
+             *     then `shipments`).
+             * @example job-2
+             */
+            task: string;
         };
         /**
          * @description One end of a `time_lag` relation.
          * @example {
-         *       "on": "end",
+         *       "on": "departure",
          *       "stop": "job-1"
          *     }
          */
-        TimeLagEnd: {
+        TimeLagMember: {
             /**
-             * @description Which instant of the job the bound is measured at: `start` (default) or
-             *     `end`. `arrival` is rejected with HTTP 400.
+             * @description Which instant of the job the bound is measured at: `service_start`
+             *     (default) or `departure`, the stop fields of the same names.
+             * @default service_start
              */
-            on?: null | components["schemas"]["StopInstant"];
+            on?: null | components["schemas"]["RelationInstant"];
             /**
-             * @description A job id (shipment legs are not supported yet).
+             * @description The stop: a job id. A shipment's own id or a shipment-leg stop id is
+             *     rejected with HTTP 400.
              * @example job-1
              */
             stop: string;
@@ -2965,13 +3515,11 @@ export interface components {
          *
          *     `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`.
+         *     other fields break it down and sum to `span_s`, with two exceptions:
+         *     setup time (`setup_duration_s`) is inside the span with no field of its
+         *     own, 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,
@@ -3017,7 +3565,11 @@ export interface components {
             travel_s: number;
             /**
              * Format: int64
-             * @description Waiting before service, cross-route holds included.
+             * @description Waiting before service, cross-route holds included, plus the idle
+             *     before a windowed break's window opens, at any stop. It is the sum of
+             *     the stops' `wait_s`, so it can exceed `score.components.waiting` and
+             *     what `per_wait_hour` charges for: that idle is priced only through
+             *     the span.
              */
             wait_s: number;
         };
@@ -3025,7 +3577,7 @@ export interface components {
          * @description A time window. Hard unless it (or `objective.per_late_hour`, for
          *     every window) prices lateness.
          * @example {
-         *       "cost": 15,
+         *       "choice_cost": 15,
          *       "from": "2026-07-01T09:00:00+02:00",
          *       "to": "2026-07-01T12:00:00+02:00"
          *     }
@@ -3041,19 +3593,21 @@ export interface components {
              *     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
+             *     must also be pairwise non-overlapping, and windows that only touch
+             *     count as 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
+             *     nonzero `choice_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;
+            choice_cost?: number | null;
             /**
              * Format: date-time
-             * @description Earliest allowed arrival (RFC 3339 instant, UTC offset required).
+             * @description Earliest allowed start of service (RFC 3339 instant, UTC offset
+             *     required). A vehicle that arrives earlier waits.
              * @example 2026-07-01T09:00:00+02:00
              */
             from: string;
@@ -3070,7 +3624,9 @@ export interface components {
             per_late_hour?: number | null;
             /**
              * Format: date-time
-             * @description Latest allowed arrival (RFC 3339 instant, UTC offset required).
+             * @description Latest allowed start of service (RFC 3339 instant, UTC offset
+             *     required), measured from arrival plus any windowed break taken first
+             *     (#1750 D1). Hard unless `per_late_hour` prices lateness.
              * @example 2026-07-01T12:00:00+02:00
              */
             to: string;
@@ -3085,14 +3641,16 @@ export interface components {
         Timings: {
             /**
              * Format: int64
-             * @description Time spent in the search. Absent on `/evaluate`, which runs none.
+             * @description Time spent in the search. Absent on `/evaluate`, which runs none, and
+             *     on `/suggest`, which has no separate search figure.
              */
             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.
+             *     on `/evaluate`; of the suggestion search, on `/suggest`): fetching
+             *     travel times and waiting for capacity included, building the response
+             *     not.
              */
             total_ms: number;
         };
@@ -3125,103 +3683,107 @@ export interface components {
             engine?: null | components["schemas"]["MatrixEngine"];
         };
         /**
-         * @description [`SolveOptions::travel_fallback`]: what a solve does when travel times
-         *     cannot be fetched.
+         * @description `options.travel_fallback`: what a solve does when travel times cannot be
+         *     fetched. `/evaluate` and `/suggest` never estimate: they fail instead.
          * @example estimate
          * @enum {string}
          */
         TravelFallback: "estimate" | "fail";
         /**
-         * @description What a break trigger accumulates.
+         * @description What a break trigger accumulates since the last break: `drive` counts
+         *     driving time only; `duty` counts travel, service and setup time, but not
+         *     waiting (for a time window to open or for a coupled task).
          * @example drive
          * @enum {string}
          */
         TriggerAfter: "drive" | "duty";
         /**
-         * @description A job the solver could not assign to any vehicle.
+         * @description Which kind of "unassigned" a task is.
+         *
+         *     Known values: `impossible`, `blocked`, `priced_out`, `time_limit`. An open set: a later release may add values, so accept any string and handle the ones you know.
+         * @example priced_out
+         */
+        UnassignedCategory: string;
+        /**
+         * @description A machine-readable reason a task could not be assigned: the
+         *     `constraint` to blame, when one is, and a sentence.
+         * @example {
+         *       "constraint": "time_window",
+         *       "message": "A route cannot reach this task within its time window"
+         *     }
+         */
+        UnassignedReason: {
+            /**
+             * @description The constraint that refused the task on at least one vehicle, in the
+             *     vocabulary of the evaluate violations' `code`. A task lists one reason
+             *     per constraint, once each, in [`ConstraintCode`] order. Absent on the
+             *     single reason of a `time_limit` or `priced_out` task, which names no
+             *     constraint.
+             */
+            constraint?: null | components["schemas"]["ConstraintCode"];
+            /**
+             * @description Human-readable explanation.
+             * @example A route cannot reach this task within its time window
+             */
+            message: string;
+        };
+        /**
+         * @description A task the plan leaves unassigned.
          * @example {
          *       "category": "blocked",
-         *       "job_id": "job-2",
          *       "reasons": [
          *         {
-         *           "code": "TIME_WINDOW_VIOLATED",
-         *           "message": "No vehicle can reach this job within its time window."
+         *           "constraint": "time_window",
+         *           "message": "A route cannot reach this task within its time window"
          *         }
          *       ],
          *       "relaxations": [
          *         {
          *           "amount": 900,
-         *           "field": "/jobs/job-2/time_windows",
+         *           "message": "Extend a time window by 900s (~15 min).",
          *           "op": "extend_time_window",
-         *           "suggestion": "Extend a time window by 900s (~15 min).",
+         *           "pointer": "/problem/jobs/1/time_windows",
          *           "unit": "s"
          *         }
-         *       ]
+         *       ],
+         *       "task": "job-2"
          *     }
          */
-        Unassigned: {
+        UnassignedTask: {
             /** @description Which kind of "unassigned" this is. */
-            category?: components["schemas"]["UnassignedCategory"];
+            category: components["schemas"]["UnassignedCategory"];
             /**
-             * @description The unassigned job id.
-             * @example job-2
+             * @description Never empty. When `category` is `impossible` or `blocked` there is
+             *     one reason per constraint that refused the task on at least one
+             *     vehicle, named in `constraint`, once each, `unreachable` first
+             *     (`unknown` when no constraint was recorded). Otherwise there is one
+             *     reason with no `constraint`.
              */
-            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.
+             * @description The unassigned task: a job id or a shipment id.
+             * @example job-2
              */
-            message: string;
+            task: string;
         };
         /**
-         * @description The 200 body of a `?validate_only=true` call: the request passed every
-         *     check a real call runs before the matrix fetch.
+         * @description The 200 body of `POST /v3/routing/validate/{solve,evaluate,suggest}`: the
+         *     request passed every check a real call runs before the matrix fetch.
          * @example {
          *       "valid": true,
          *       "warnings": []
          *     }
          */
-        ValidateOnlyResponse: {
+        ValidateResponse: {
             /** @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 May contain warnings about the request; none are produced today. */
+            warnings: components["schemas"]["RequestIssue"][];
         };
         /**
          * @description A vehicle type available to serve tasks.
@@ -3260,7 +3822,7 @@ export interface components {
          */
         Vehicle: {
             /** @description Named capacity dimensions. */
-            capacity?: null | components["schemas"]["BTreeMap"];
+            capacity?: null | components["schemas"]["Quantities"];
             /**
              * @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
@@ -3319,14 +3881,24 @@ export interface components {
              *     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`.
+             *     Must be in `[0.001, 5]`. Default 1.0. A shift's own `service_factor`
+             *     replaces it for that shift; a task's `service_factors[].factor` for
+             *     this vehicle multiplies whichever applies: effective service time =
+             *     `service_duration_s / (shift_or_vehicle_factor * task_factor)`.
+             *
+             *     V2's `durationModifier` went the other way (it MULTIPLIED duration,
+             *     `0.8` = 20% faster); the V2 compatibility layer inverts it and sends it
+             *     as the task's `service_factors[].factor = 1 / durationModifier`.
+             * @default 1
              */
             service_factor?: number | null;
-            /** @description One or more working shifts. */
+            /**
+             * @description One or more working shifts. A vehicle without shifts is rejected with
+             *     HTTP 400.
+             */
             shifts: components["schemas"]["Shift"][];
             /**
-             * @description Capabilities the vehicle provides. A job's `skills` must all appear
+             * @description Capabilities the vehicle provides. A job's `required_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
@@ -3338,13 +3910,45 @@ export interface components {
              * 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.
+             *     vehicle and < 1.0 a slower one. Must be in `[0.001, 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.
+             * @default 1
              */
             speed_factor?: number | null;
+            /**
+             * Format: double
+             * @description Share of the work this vehicle carries under `objective.workload_share`,
+             *     relative to the other vehicles. Default `1`; `0.5` carries half as much;
+             *     `0` leaves the vehicle out of the balancing. `0` to `1000000`
+             *     (HTTP 400 `out_of_range` outside that). Ignored when
+             *     `objective.workload_share` is not set.
+             * @example 0.5
+             */
+            workload_weight?: number | null;
+        };
+        /**
+         * @description Hard vehicle eligibility: whitelist or blacklist (mutually exclusive).
+         * @example {
+         *       "allowed": [
+         *         "v1",
+         *         "v2"
+         *       ]
+         *     }
+         */
+        VehicleEligibility: {
+            /**
+             * @description Hard whitelist of vehicle ids. Omit = all vehicles allowed. An empty
+             *     list, or an id that names no vehicle, is rejected with HTTP 400.
+             */
+            allowed?: string[] | null;
+            /**
+             * @description Hard blacklist of vehicle ids. Mutually exclusive with `allowed`. An
+             *     id that names no vehicle is rejected with HTTP 400.
+             */
+            excluded?: string[] | null;
         };
         /**
          * @description Vehicle distance/time limits.
@@ -3356,38 +3960,43 @@ export interface components {
         VehicleLimits: {
             /**
              * Format: int64
-             * @description Hard maximum distance in metres.
+             * @description Hard maximum distance in metres. `0` to `2147483647`; a value
+             *     outside that range is rejected with HTTP 400 `out_of_range`.
              * @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
+             *     the `travel_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
+             *     `free_start_travel`/`free_end_travel`, 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.
+             *     400 `out_of_range`, as is a value that does not fit in 32 bits. A
+             *     breach is reported as `max_leg_travel`.
              * @example 3600
              */
-            max_leg_travel_time_s?: number | null;
+            max_leg_travel_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`.
+             *     The same quantity as the response's `routes[].time.span_s`. `0` to
+             *     `2147483647`; a value outside that range is rejected with HTTP 400
+             *     `out_of_range`.
              * @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).
+             * @description Maximum stops served per shift; a job counts as one stop.
+             *     Start, end, break and reload stops in `routes[].stops` do not count; a
+             *     shipment counts as two stops.
              * @example 50
              */
-            max_tasks?: number | null;
+            max_stops?: 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
@@ -3397,6 +4006,28 @@ export interface components {
              */
             periods?: components["schemas"]["PeriodLimit"][];
         };
+        /**
+         * @description A soft vehicle affinity preference, priced.
+         * @example {
+         *       "vehicle": "v1",
+         *       "violation_cost": 50
+         *     }
+         */
+        VehiclePreference: {
+            /**
+             * @description Preferred vehicle id. An id that names no vehicle, or a vehicle listed
+             *     twice in one task's `preferences`, is rejected with HTTP 400.
+             * @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 A capability a vehicle or shift provides, at a proficiency level:
          *     `{ "name": "gas", "level": 3 }`. Always an object; a bare string is
@@ -3426,262 +4057,258 @@ export interface components {
          *     Reported on stops (`routes[].stops[].violations`) and on routes
          *     (`routes[].violations`) in the `POST /v3/routing/evaluate` response.
          * @example {
+         *       "code": "capacity",
+         *       "dimension": "weight",
+         *       "excess": 15,
          *       "message": "Cumulative load 30 exceeds vehicle capacity 15 (dimension weight)",
-         *       "type": "capacity"
+         *       "unit": "load"
          *     }
          */
         Violation: {
             /**
-             * @description Human-readable description of what was violated.
-             * @example Cumulative load 30 exceeds vehicle capacity 15 (dimension weight)
+             * @description The constraint broken. `max_stops`, `break`, `multi_trip`,
+             *     `period_limit` and `quota` are route-level; `sequence` and `shipment`
+             *     are on the stop; `unreachable`, `max_leg_travel` and `capacity` can be
+             *     either. `unknown`
+             *     means the insertion check refused a stop without naming a constraint
+             *     (not expected in practice).
              */
-            message: string;
+            code: components["schemas"]["ConstraintCode"];
             /**
-             * @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
+             * @description The capacity dimension over its limit. Only on `capacity`.
+             * @example weight
              */
-            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: {
+            dimension?: string | null;
             /**
-             * @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.
+             * Format: int64
+             * @description How far over the limit, in `unit`. On `capacity`, `time_window` (the
+             *     seconds late), `shift_end`, `max_distance`, `max_route_duration` and
+             *     `quota`.
+             * @example 15
              */
-            assignment_costs?: components["schemas"]["AssignmentCost"][] | null;
+            excess?: number | null;
             /**
-             * @description Whether a break may interrupt service here. Default `true`. `false`
-             *     is not supported yet and is rejected with HTTP 400.
-             * @example true
+             * @description Human-readable description of what was violated.
+             * @example Cumulative load 30 exceeds vehicle capacity 15 (dimension weight)
              */
-            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;
+            message: string;
+            /** @description Unit of `excess`; present exactly when `excess` is. */
+            unit?: null | components["schemas"]["QuantityUnit"];
+        };
+        /**
+         * @description Spreads work across vehicles: each vehicle's scheduled service time is
+         *     compared with its share of all the work, and the part outside a tolerance
+         *     band is charged.
+         *
+         *     The balanced quantity is **service time only**: every served task's
+         *     `service_duration_s`, scaled by the vehicle's `service_factor`. Travel,
+         *     `setup_duration_s`, waiting and breaks are not counted, and a task-level
+         *     `service_factors` entry scales the measure but not the target. Shares are
+         *     fixed when the request is read: every task counts towards the total,
+         *     served or not, so with many unassigned tasks every vehicle sits under its
+         *     share and the term pulls work in without ordering the routes between them;
+         *     balancing pressure appears once routes enter their band. A vehicle with
+         *     several shifts has its share split across them by the work each shift can
+         *     reach (the service time of the tasks whose windows overlap it), weighted
+         *     by shift length, so a day with no tasks carries none of the share; each
+         *     shift is charged on its own part. An empty, non-exempt shift pays for its whole share, so pair the
+         *     term with `costs.fixed` or `per_vehicle` only when both are meant.
+         *     See `vehicles[].workload_weight` to give a part-time vehicle a smaller
+         *     share. A problem that sets the term solves without decomposition, like
+         *     `assignment_costs`.
+         */
+        WorkloadShare: {
             /**
              * 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.
+             * @description Money per hour a vehicle's service time is outside the band, in the
+             *     request's currency. Greater than 0 and at least 0.036 (the internal
+             *     resolution); omit `workload_share` to switch the term off.
+             * @example 35
              */
-            tags?: string[] | null;
+            per_imbalance_hour: number;
             /**
-             * @description Soft target for this task, measured at its arrival (default) or
-             *     departure. On a shipment it is measured on the **delivery** leg.
+             * Format: double
+             * @description Half-width of the band as a fraction of the vehicle's share, `0` up to
+             *     but not including `1`. Default `0.1`: a vehicle within 10% of its share
+             *     is not charged. The charge grows from the band edge.
+             * @example 0.1
              */
-            target?: null | components["schemas"]["Target"];
-            /** @description Time windows for this visit. */
-            time_windows?: components["schemas"]["TimeWindow"][] | null;
+            tolerance?: number | null;
+        };
+    };
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+export type $defs = Record<string, never>;
+export interface operations {
+    evaluate: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["EvaluateRequest"];
+            };
+        };
+        responses: {
+            /** @description Solution evaluated. */
+            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"]["SolveResponse"];
+                };
+            };
+            /** @description The request is invalid. `errors[]` lists what to fix, each entry with a `code` and, when the problem is in the body, a JSON `pointer` to it. */
+            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 (10,485,760 bytes), counted after gzip decompression */
+            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 missing or not JSON (`application/json` or `application/*+json`), or the body has a `Content-Encoding` other than `gzip` (the message says which) */
+            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: travel_provider_error`). The request can be retried. This endpoint never falls back to estimated travel. */
+            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 Solvice Maps is temporarily refused after repeated failures (`code: overloaded`), so travel times cannot be fetched. Evaluate takes no solver slot, so this is its only 503. 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": "Circuit breaker is open — Solvice Maps temporarily unavailable",
+                     *       "request_id": "req_7f3a2c90d1e4b5a6",
+                     *       "status": "SERVICE_UNAVAILABLE"
+                     *     }
+                     */
+                    "application/json": components["schemas"]["ErrorBody"];
+                };
+            };
         };
     };
-    responses: never;
-    parameters: never;
-    requestBodies: never;
-    headers: never;
-    pathItems: never;
-}
-export type $defs = Record<string, never>;
-export interface operations {
-    evaluate: {
+    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;
-            };
+            query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["EvaluateRequest"];
+                "application/json": components["schemas"]["SolveRequest"];
             };
         };
         responses: {
-            /** @description Solution evaluated. With `?validate_only=true`: a `ValidateOnlyResponse`, `{"valid": true, "warnings": []}`, without a matrix fetch, not billed. */
+            /** @description Solution found. */
             200: {
                 headers: {
                     /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
@@ -3689,10 +4316,10 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["OrValidateOnly_SolveResponse"];
+                    "application/json": components["schemas"]["SolveResponse"];
                 };
             };
-            /** @description The request is invalid. `errors[]` lists what to fix, each entry with a `code` and a JSON pointer into the request body. */
+            /** @description The request is invalid. `errors[]` lists what to fix, each entry with a `code` and, when the problem is in the body, a JSON `pointer` to it. */
             400: {
                 headers: {
                     /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
@@ -3729,7 +4356,7 @@ export interface operations {
                     "application/json": components["schemas"]["ErrorBody"];
                 };
             };
-            /** @description Request body larger than 10 MiB */
+            /** @description Request body larger than 10 MiB (10,485,760 bytes), counted after gzip decompression */
             413: {
                 headers: {
                     /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
@@ -3748,7 +4375,7 @@ export interface operations {
                     "application/json": components["schemas"]["ErrorBody"];
                 };
             };
-            /** @description Request `Content-Type` is not `application/json` */
+            /** @description Request `Content-Type` is missing or not JSON (`application/json` or `application/*+json`), or the body has a `Content-Encoding` other than `gzip` (the message says which) */
             415: {
                 headers: {
                     /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
@@ -3785,7 +4412,7 @@ export interface operations {
                     "application/json": components["schemas"]["ErrorBody"];
                 };
             };
-            /** @description Travel times and distances could not be fetched (`code: matrix_provider_error`). The request can be retried. */
+            /** @description Travel times and distances could not be fetched (`code: travel_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. */
@@ -3796,7 +4423,7 @@ export interface operations {
                     "application/json": components["schemas"]["ErrorBody"];
                 };
             };
-            /** @description No capacity right now (`code: overloaded`). Retry after the number of seconds in the `Retry-After` header. */
+            /** @description No capacity right now (`code: overloaded`): every solver slot is busy, or the wait for one timed out. With `options.travel_fallback: "fail"`, also returned while Solvice Maps is temporarily refused after repeated failures. Retry after the number of seconds in the `Retry-After` header. */
             503: {
                 headers: {
                     /** @description Seconds to wait before retrying. */
@@ -3819,27 +4446,20 @@ export interface operations {
             };
         };
     };
-    solve: {
+    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;
-            };
+            query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["SolveRequest"];
+                "application/json": components["schemas"]["SuggestRequest"];
             };
         };
         responses: {
-            /** @description Solution found. With `?validate_only=true`: a `ValidateOnlyResponse`, `{"valid": true, "warnings": []}`, without a matrix fetch or a search, not billed. */
+            /** @description Suggestions computed. */
             200: {
                 headers: {
                     /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
@@ -3847,10 +4467,10 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["OrValidateOnly_SolveResponse"];
+                    "application/json": components["schemas"]["SuggestResponse"];
                 };
             };
-            /** @description The request is invalid. `errors[]` lists what to fix, each entry with a `code` and a JSON pointer into the request body. */
+            /** @description The request is invalid. `errors[]` lists what to fix, each entry with a `code` and, when the problem is in the body, a JSON `pointer` to it. */
             400: {
                 headers: {
                     /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
@@ -3887,7 +4507,7 @@ export interface operations {
                     "application/json": components["schemas"]["ErrorBody"];
                 };
             };
-            /** @description Request body larger than 10 MiB */
+            /** @description Request body larger than 10 MiB (10,485,760 bytes), counted after gzip decompression */
             413: {
                 headers: {
                     /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
@@ -3906,7 +4526,7 @@ export interface operations {
                     "application/json": components["schemas"]["ErrorBody"];
                 };
             };
-            /** @description Request `Content-Type` is not `application/json` */
+            /** @description Request `Content-Type` is missing or not JSON (`application/json` or `application/*+json`), or the body has a `Content-Encoding` other than `gzip` (the message says which) */
             415: {
                 headers: {
                     /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
@@ -3943,7 +4563,7 @@ export interface operations {
                     "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. */
+            /** @description Travel times and distances could not be fetched (`code: travel_provider_error`). The request can be retried. This endpoint never falls back to estimated travel. */
             502: {
                 headers: {
                     /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
@@ -3954,7 +4574,7 @@ export interface operations {
                     "application/json": components["schemas"]["ErrorBody"];
                 };
             };
-            /** @description No capacity right now (`code: overloaded`). Retry after the number of seconds in the `Retry-After` header. */
+            /** @description No capacity right now (`code: overloaded`): every solver slot is busy, the wait for one timed out, or Solvice Maps is temporarily refused after repeated failures. Retry after the number of seconds in the `Retry-After` header. */
             503: {
                 headers: {
                     /** @description Seconds to wait before retrying. */
@@ -3977,27 +4597,139 @@ export interface operations {
             };
         };
     };
-    suggest: {
+    validate_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;
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["EvaluateRequest"];
+            };
+        };
+        responses: {
+            /** @description The request passed every check made before travel times are fetched. `warnings` may contain warnings; none are produced today. */
+            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"]["ValidateResponse"];
+                };
+            };
+            /** @description The request is invalid. `errors[]` lists what to fix, each entry with a `code` and, when the problem is in the body, a JSON `pointer` to it. */
+            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 (10,485,760 bytes), counted after gzip decompression */
+            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 missing or not JSON (`application/json` or `application/*+json`), or the body has a `Content-Encoding` other than `gzip` (the message says which) */
+            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"];
+                };
             };
+        };
+    };
+    validate_solve: {
+        parameters: {
+            query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["SuggestRequest"];
+                "application/json": components["schemas"]["SolveRequest"];
             };
         };
         responses: {
-            /** @description Suggestions computed. With `?validate_only=true`: a `ValidateOnlyResponse`, `{"valid": true, "warnings": []}`, without a matrix fetch or a search, not billed. */
+            /** @description The request passed every check made before travel times are fetched. `warnings` may contain warnings; none are produced today. */
             200: {
                 headers: {
                     /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
@@ -4005,10 +4737,10 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["OrValidateOnly_SuggestResponse"];
+                    "application/json": components["schemas"]["ValidateResponse"];
                 };
             };
-            /** @description The request is invalid. `errors[]` lists what to fix, each entry with a `code` and a JSON pointer into the request body. */
+            /** @description The request is invalid. `errors[]` lists what to fix, each entry with a `code` and, when the problem is in the body, a JSON `pointer` to it. */
             400: {
                 headers: {
                     /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
@@ -4045,7 +4777,7 @@ export interface operations {
                     "application/json": components["schemas"]["ErrorBody"];
                 };
             };
-            /** @description Request body larger than 10 MiB */
+            /** @description Request body larger than 10 MiB (10,485,760 bytes), counted after gzip decompression */
             413: {
                 headers: {
                     /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
@@ -4064,7 +4796,7 @@ export interface operations {
                     "application/json": components["schemas"]["ErrorBody"];
                 };
             };
-            /** @description Request `Content-Type` is not `application/json` */
+            /** @description Request `Content-Type` is missing or not JSON (`application/json` or `application/*+json`), or the body has a `Content-Encoding` other than `gzip` (the message says which) */
             415: {
                 headers: {
                     /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
@@ -4101,8 +4833,34 @@ export interface operations {
                     "application/json": components["schemas"]["ErrorBody"];
                 };
             };
-            /** @description Travel times and distances could not be fetched (`code: matrix_provider_error`). The request can be retried. */
-            502: {
+        };
+    };
+    validate_suggest: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["SuggestRequest"];
+            };
+        };
+        responses: {
+            /** @description The request passed every check made before travel times are fetched. `warnings` may contain warnings; none are produced today. */
+            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"]["ValidateResponse"];
+                };
+            };
+            /** @description The request is invalid. `errors[]` lists what to fix, each entry with a `code` and, when the problem is in the body, a JSON `pointer` to it. */
+            400: {
                 headers: {
                     /** @description The request's `X-Request-Id`, echoed, or a generated `req_…` id. */
                     "x-request-id"?: string;
@@ -4112,11 +4870,16 @@ export interface operations {
                     "application/json": components["schemas"]["ErrorBody"];
                 };
             };
-            /** @description No capacity right now (`code: overloaded`). Retry after the number of seconds in the `Retry-After` header. */
-            503: {
+            /** @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 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;
@@ -4124,15 +4887,71 @@ export interface operations {
                 content: {
                     /**
                      * @example {
-                     *       "code": "overloaded",
-                     *       "message": "All solver slots are busy, try again later",
+                     *       "code": "feature_not_enabled",
+                     *       "message": "travel.engine: 'tomtom_real_time' is not enabled for this account; use engine 'tomtom'",
                      *       "request_id": "req_7f3a2c90d1e4b5a6",
-                     *       "status": "SERVICE_UNAVAILABLE"
+                     *       "status": "FORBIDDEN"
+                     *     }
+                     */
+                    "application/json": components["schemas"]["ErrorBody"];
+                };
+            };
+            /** @description Request body larger than 10 MiB (10,485,760 bytes), counted after gzip decompression */
+            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 missing or not JSON (`application/json` or `application/*+json`), or the body has a `Content-Encoding` other than `gzip` (the message says which) */
+            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"];
+                };
+            };
         };
     };
 }