@revenexx/node 0.1.0 → 0.1.1

package/dist/services/carts.d.ts

@@ -7,6 +7,15 @@ import '../query.js';
 import '../enums/address-type-row-tone.js';
 import '../enums/address-type-row-create-request-tone.js';
 import '../enums/address-type-row-update-request-tone.js';
+import '../enums/approval-rule-approver-type.js';
+import '../enums/approval-rule-condition.js';
+import '../enums/approval-rule-effect.js';
+import '../enums/approval-rule-create-request-approver-type.js';
+import '../enums/approval-rule-create-request-condition.js';
+import '../enums/approval-rule-create-request-effect.js';
+import '../enums/approval-rule-update-request-approver-type.js';
+import '../enums/approval-rule-update-request-condition.js';
+import '../enums/approval-rule-update-request-effect.js';
 import '../enums/assets-source.js';
 import '../enums/attribute-value-bucket.js';
 import '../enums/auth-mail-source.js';
@@ -118,6 +127,8 @@ import '../enums/payment-term-tone.js';
 import '../enums/payment-term-create-request-tone.js';
 import '../enums/payment-term-update-request-tone.js';
 import '../enums/payment-vocabulary-tone.js';
+import '../enums/pending-approval-approver-type.js';
+import '../enums/pending-approval-status.js';
 import '../enums/price-ending-rule.js';
 import '../enums/price-entries-adjust-response-rounding.js';
 import '../enums/price-entries-adjust-response-rounding-mode.js';
@@ -140,6 +151,11 @@ import '../enums/product-grid-column-source.js';
 import '../enums/product-label-source.js';
 import '../enums/product-label-attribute-source.js';
 import '../enums/products-kind.js';
+import '../enums/purchase-request-status.js';
+import '../enums/purchase-request-event-name.js';
+import '../enums/purchase-request-item-type.js';
+import '../enums/purchase-request-item-create-request-type.js';
+import '../enums/purchase-request-item-update-request-type.js';
 import '../enums/reorder-point-source.js';
 import '../enums/reservation-status.js';
 import '../enums/price-on-request-reason.js';
@@ -177,6 +193,8 @@ import '../enums/shipping-weight-unit-row-tone.js';
 import '../enums/shipping-weight-unit-update-request-tone.js';
 import '../enums/stock-movement-type.js';
 import '../enums/store-asset-request-visibility.js';
+import '../enums/submit-item-type.js';
+import '../enums/submit-result-outcome.js';
 import '../enums/validation-failed-response-status.js';
 import '../enums/vocabulary-default-tone.js';
 import '../enums/vocabulary-source.js';
@@ -250,7 +268,7 @@ declare class Carts {
      * @param {number} params.offset - Row offset for pagination (default 0).
      * @param {string} params.order - Sort by one column: 'column' | 'column.asc' | 'column.desc'. A bare column sorts ascending. Anything else is refused with 400.
      * @throws {RevenexxException}
-     * @returns {Promise<Models.Error>}
+     * @returns {Promise<{}>}
      */
     cartsList(params?: {
         id?: string;
@@ -272,7 +290,7 @@ declare class Carts {
         limit?: number;
         offset?: number;
         order?: string;
-    }): Promise<Models.Error>;
+    }): Promise<{}>;
     /**
      * The cart index, and the route a storefront resumes a session with: `?contact_id=…` for a customer's carts, `?session_key=…` for a guest's, and `?is_current=true` alongside one of those two for the single cart carts.activate last marked — this list is the ONLY place that flag can be read back, and on its own the filter selects every current cart in the tenant. Filters are exact equality and never a search, unknown keys are dropped rather than refused, and `filter` echoes what was understood. Each row carries its own stored totals — `item_count` is the sum of the line QUANTITIES, not the number of lines — but never its lines: those are one call per cart. With no filter at all this is every cart the tenant holds, paged, which is a report rather than a session lookup.
      *
@@ -296,10 +314,10 @@ declare class Carts {
      * @param {number} offset - Row offset for pagination (default 0).
      * @param {string} order - Sort by one column: 'column' | 'column.asc' | 'column.desc'. A bare column sorts ascending. Anything else is refused with 400.
      * @throws {RevenexxException}
-     * @returns {Promise<Models.Error>}
+     * @returns {Promise<{}>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    cartsList(id?: string, name?: string, status?: CartStatus, contactId?: string, sessionKey?: string, channelId?: string, currency?: string, isCurrent?: boolean, itemCount?: number, subtotal?: number, abandonedAt?: string, orderedAt?: string, orderRef?: string, mergedIntoCartId?: string, createdAt?: string, updatedAt?: string, limit?: number, offset?: number, order?: string): Promise<Models.Error>;
+    cartsList(id?: string, name?: string, status?: CartStatus, contactId?: string, sessionKey?: string, channelId?: string, currency?: string, isCurrent?: boolean, itemCount?: number, subtotal?: number, abandonedAt?: string, orderedAt?: string, orderRef?: string, mergedIntoCartId?: string, createdAt?: string, updatedAt?: string, limit?: number, offset?: number, order?: string): Promise<{}>;
     /**
      * Opens an empty cart. The one thing it requires is an OWNER — `contact_id` for a signed-in customer or `session_key` for a guest, never neither: that is a database check on the table, and this route refuses it first with a 400 so the caller gets a sentence rather than a constraint name. Everything else is defaulted: the name 'Cart', currency EUR, status 'active', both totals 0. No column of a cart is unique, so one owner may hold as many carts as they like — unless the tenant's `multi_cart_enabled` is off, in which case a second ACTIVE cart for the same owner answers 409 naming the cart that already exists, because a storefront that hit that wants to fill THAT cart. Send `is_current: true` to have the new cart made current in the same call, which clears the flag on every sibling of the same owner. Lines are added afterwards, one call each or one bulk replace.
      *
@@ -311,7 +329,7 @@ declare class Carts {
      * @param {string} params.name - What the buyer calls this cart (default 'Cart'). An empty string is legal and lands on the default.
      * @param {string} params.sessionKey - The guest session that owns this cart — the key the storefront already keeps in its own session or cookie. Any non-empty string is accepted; this app issues none and parses none, so the example shows a shape and not a format. Send this OR contact_id.
      * @throws {RevenexxException}
-     * @returns {Promise<Models.Error>}
+     * @returns {Promise<Models.Cart>}
      */
     cartsCreate(params?: {
         channelId?: string;
@@ -321,7 +339,7 @@ declare class Carts {
         metadata?: object;
         name?: string;
         sessionKey?: string;
-    }): Promise<Models.Error>;
+    }): Promise<Models.Cart>;
     /**
      * Opens an empty cart. The one thing it requires is an OWNER — `contact_id` for a signed-in customer or `session_key` for a guest, never neither: that is a database check on the table, and this route refuses it first with a 400 so the caller gets a sentence rather than a constraint name. Everything else is defaulted: the name 'Cart', currency EUR, status 'active', both totals 0. No column of a cart is unique, so one owner may hold as many carts as they like — unless the tenant's `multi_cart_enabled` is off, in which case a second ACTIVE cart for the same owner answers 409 naming the cart that already exists, because a storefront that hit that wants to fill THAT cart. Send `is_current: true` to have the new cart made current in the same call, which clears the flag on every sibling of the same owner. Lines are added afterwards, one call each or one bulk replace.
      *
@@ -333,10 +351,10 @@ declare class Carts {
      * @param {string} name - What the buyer calls this cart (default 'Cart'). An empty string is legal and lands on the default.
      * @param {string} sessionKey - The guest session that owns this cart — the key the storefront already keeps in its own session or cookie. Any non-empty string is accepted; this app issues none and parses none, so the example shows a shape and not a format. Send this OR contact_id.
      * @throws {RevenexxException}
-     * @returns {Promise<Models.Error>}
+     * @returns {Promise<Models.Cart>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    cartsCreate(channelId?: string, contactId?: string, currency?: string, isCurrent?: boolean, metadata?: object, name?: string, sessionKey?: string): Promise<Models.Error>;
+    cartsCreate(channelId?: string, contactId?: string, currency?: string, isCurrent?: boolean, metadata?: object, name?: string, sessionKey?: string): Promise<Models.Cart>;
     /**
      * The login call, and the one route that turns a guest into a customer: every ACTIVE cart of one session_key is handed to a contact_id, which is what a storefront fires the moment somebody signs in with a basket already filled. There are two ways it can land, and the body picks between them. Without a target_cart_id the session carts are ADOPTED as they stand — same carts, same lines, contact_id set and session_key cleared, nothing copied and nothing closed. With a target_cart_id they are instead folded into that cart, which survives while each session cart is closed as status merged; 'adopted' and 'merged' in the answer say which of the two happened to each one. With a target cart, cart_merge_strategy decides what happens to the target's OWN lines: 'merge' keeps them and folds the session lines in, 'replace' clears them first. 'strategy' overrides it for one call (merge | replace); the answer always echoes which one ran and how many lines a replace removed.
      *
@@ -345,14 +363,14 @@ declare class Carts {
      * @param {CartMergeStrategy} params.strategy - Override the tenant's cart_merge_strategy for this call: 'merge' keeps the target cart's own lines, 'replace' clears them first. Omit to use the setting.
      * @param {string} params.targetCartId - Merge the session carts into this cart instead of adopting them.
      * @throws {RevenexxException}
-     * @returns {Promise<Models.Error>}
+     * @returns {Promise<{}>}
      */
     cartsClaim(params: {
         contactId: string;
         sessionKey: string;
         strategy?: CartMergeStrategy;
         targetCartId?: string;
-    }): Promise<Models.Error>;
+    }): Promise<{}>;
     /**
      * The login call, and the one route that turns a guest into a customer: every ACTIVE cart of one session_key is handed to a contact_id, which is what a storefront fires the moment somebody signs in with a basket already filled. There are two ways it can land, and the body picks between them. Without a target_cart_id the session carts are ADOPTED as they stand — same carts, same lines, contact_id set and session_key cleared, nothing copied and nothing closed. With a target_cart_id they are instead folded into that cart, which survives while each session cart is closed as status merged; 'adopted' and 'merged' in the answer say which of the two happened to each one. With a target cart, cart_merge_strategy decides what happens to the target's OWN lines: 'merge' keeps them and folds the session lines in, 'replace' clears them first. 'strategy' overrides it for one call (merge | replace); the answer always echoes which one ran and how many lines a replace removed.
      *
@@ -361,10 +379,10 @@ declare class Carts {
      * @param {CartMergeStrategy} strategy - Override the tenant's cart_merge_strategy for this call: 'merge' keeps the target cart's own lines, 'replace' clears them first. Omit to use the setting.
      * @param {string} targetCartId - Merge the session carts into this cart instead of adopting them.
      * @throws {RevenexxException}
-     * @returns {Promise<Models.Error>}
+     * @returns {Promise<{}>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    cartsClaim(contactId: string, sessionKey: string, strategy?: CartMergeStrategy, targetCartId?: string): Promise<Models.Error>;
+    cartsClaim(contactId: string, sessionKey: string, strategy?: CartMergeStrategy, targetCartId?: string): Promise<{}>;
     /**
      * Two sweeps in one pass. abandon_after_minutes marks active carts that have sat untouched past the window as abandoned (stamping abandoned_at, which nothing else in the platform ever sets — without this the abandonment funnel is empty by construction, not empty because nobody abandons carts). cart_ttl_days / guest_cart_ttl_days then DELETE carts past their retention window, line items included; both default to 0 (never), and an 'ordered' cart is never touched at any setting because it is the source record of a sale. Send dry_run to get the same counts and cart ids while writing nothing. The platform runs this per installed tenant on the schedule; it is idempotent, so calling it by hand between ticks is safe.
      *
@@ -390,22 +408,22 @@ declare class Carts {
      * @param {string} params.sourceCartId - The cart being folded in. It must be active, and it does NOT survive as a workspace: its lines are copied into the target, it becomes status merged, and merged_into_cart_id points at the target. Its own lines stay on it as the record of what was moved.
      * @param {string} params.targetCartId - The cart that SURVIVES. Must be active; it gains the source's lines (identical product lines at the same price adding up) and its totals are recomputed.
      * @throws {RevenexxException}
-     * @returns {Promise<Models.Error>}
+     * @returns {Promise<Models.CartMergeResult>}
      */
     cartsMerge(params: {
         sourceCartId: string;
         targetCartId: string;
-    }): Promise<Models.Error>;
+    }): Promise<Models.CartMergeResult>;
     /**
      * Which of the two carts survives is the whole question, and the answer is the TARGET: the source's lines are COPIED into the target, the target keeps every line it already had, its totals are recomputed, and it is the cart the caller goes on using. Nothing is replaced and nothing is moved — the source keeps its own line rows and is closed with status 'merged' and `merged_into_cart_id` pointing at the target, so a merged cart stays readable as the record of what went where. On the way in, a plain product line with the same product/sku AND the same `unit_price` as a line already in the target adds its quantity to that line; configured and custom lines always land as new ones. Both carts must be active and must differ, and the tenant's line limits are enforced on the target as the copies land (422). Reach for carts.merge_into where the caller holds one cart id and not two.
      *
      * @param {string} sourceCartId - The cart being folded in. It must be active, and it does NOT survive as a workspace: its lines are copied into the target, it becomes status merged, and merged_into_cart_id points at the target. Its own lines stay on it as the record of what was moved.
      * @param {string} targetCartId - The cart that SURVIVES. Must be active; it gains the source's lines (identical product lines at the same price adding up) and its totals are recomputed.
      * @throws {RevenexxException}
-     * @returns {Promise<Models.Error>}
+     * @returns {Promise<Models.CartMergeResult>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    cartsMerge(sourceCartId: string, targetCartId: string): Promise<Models.Error>;
+    cartsMerge(sourceCartId: string, targetCartId: string): Promise<Models.CartMergeResult>;
     /**
      * Discovery for the vocabulary routes: every enum this app publishes, each as its name, its title and its description and nothing else. The VALUES are deliberately not here — this is the index a client builds a menu from, and one call per vocabulary fills it. Names: io-apply-modes, io-directions, io-entities, io-formats, item-types, statuses. Fetch one with GET /carts/vocabularies/{name}; a client holding the qualified pair 'carts.<name>' builds that URL from the pair alone.
      *
@@ -418,58 +436,58 @@ declare class Carts {
      *
      * @param {Name} params.name - The vocabulary name — the part after the dot in the qualified id.
      * @throws {RevenexxException}
-     * @returns {Promise<Models.Error>}
+     * @returns {Promise<Models.CartVocabulary>}
      */
     cartsVocabulariesGet(params: {
         name: Name;
-    }): Promise<Models.Error>;
+    }): Promise<Models.CartVocabulary>;
     /**
      * One vocabulary with its values filled in — every value permitted by the column behind it, each carrying the key the database stores, a human title, a description where one was written and the badge tone a UI should render it in, which is everything a select or a status chip needs from one call. The values are read out of the column's CHECK constraint, so the served set IS the enforced set and the two cannot drift — a value added to the constraint appears here even before anyone labels it, titled from its own key. Values come back in constraint order, which is the order a select should offer. 'closed' says the set is exhaustive, so a value outside it is stale data rather than a missing label. Names: io-apply-modes, io-directions, io-entities, io-formats, item-types, statuses.
      *
      * @param {Name} name - The vocabulary name — the part after the dot in the qualified id.
      * @throws {RevenexxException}
-     * @returns {Promise<Models.Error>}
+     * @returns {Promise<Models.CartVocabulary>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    cartsVocabulariesGet(name: Name): Promise<Models.Error>;
+    cartsVocabulariesGet(name: Name): Promise<Models.CartVocabulary>;
     /**
      * Removes the cart row and, through the `on delete cascade` on `cart_items.cart_id`, every line in it. There is no soft delete and no undo. One status is protected and it is protected permanently: an 'ordered' cart is the source record of a sale — the order carries its id in `cart_id` and the order.placed event records it — so this route refuses it with 400 and there is no flag, no force and no lifecycle route that makes it deletable. Do not go looking for one. 'active', 'abandoned' and 'merged' are all deletable, which is deliberate and is the same set the cart-maintenance sweep removes on a retention window: clearing out abandoned guest carts is the main thing anyone deletes a cart for, and a merged cart's lines were COPIED into the target, which still holds them. What the delete does NOT take with it is the trail: `merged_into_cart_id` is a plain uuid column and not a foreign key, so deleting a cart that other carts were merged INTO leaves those carts pointing at a row that no longer exists, and nothing refuses the delete or clears the pointer — the retention sweep does the same, so this is a property of the column and not of this route. For a cart a buyer simply walked away from, carts.abandon keeps the row and the funnel; for deleting on a retention window, the cart-maintenance sweep does it per market and can be asked first with `dry_run`.
      *
      * @param {string} params.id - The cart, by its id — the `id` every cart answer carries. A uuid: the data plane casts the segment, so a code or a slug is refused before the cart is looked up.
      * @throws {RevenexxException}
-     * @returns {Promise<Models.Error>}
+     * @returns {Promise<{}>}
      */
     cartsDelete(params: {
         id: string;
-    }): Promise<Models.Error>;
+    }): Promise<{}>;
     /**
      * Removes the cart row and, through the `on delete cascade` on `cart_items.cart_id`, every line in it. There is no soft delete and no undo. One status is protected and it is protected permanently: an 'ordered' cart is the source record of a sale — the order carries its id in `cart_id` and the order.placed event records it — so this route refuses it with 400 and there is no flag, no force and no lifecycle route that makes it deletable. Do not go looking for one. 'active', 'abandoned' and 'merged' are all deletable, which is deliberate and is the same set the cart-maintenance sweep removes on a retention window: clearing out abandoned guest carts is the main thing anyone deletes a cart for, and a merged cart's lines were COPIED into the target, which still holds them. What the delete does NOT take with it is the trail: `merged_into_cart_id` is a plain uuid column and not a foreign key, so deleting a cart that other carts were merged INTO leaves those carts pointing at a row that no longer exists, and nothing refuses the delete or clears the pointer — the retention sweep does the same, so this is a property of the column and not of this route. For a cart a buyer simply walked away from, carts.abandon keeps the row and the funnel; for deleting on a retention window, the cart-maintenance sweep does it per market and can be asked first with `dry_run`.
      *
      * @param {string} id - The cart, by its id — the `id` every cart answer carries. A uuid: the data plane casts the segment, so a code or a slug is refused before the cart is looked up.
      * @throws {RevenexxException}
-     * @returns {Promise<Models.Error>}
+     * @returns {Promise<{}>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    cartsDelete(id: string): Promise<Models.Error>;
+    cartsDelete(id: string): Promise<{}>;
     /**
      * One cart with its owner, its totals and its lifecycle stamps — and none of its lines: those are a separate call (`GET /carts/{cart_id}/items`), because a cart row is small and a filled cart is not. The two totals are derived and stored, never taken from a caller: `item_count` is the sum of the line QUANTITIES rather than the number of lines (two lines of five pieces answer 10, not 2) and `subtotal` the sum of the line totals, net of shipping and tax; both are recomputed after every line write. `status` says what may still be done — only an 'active' cart accepts a write of any kind, 'abandoned' is the one reversible ending, and a 'merged' cart carries `merged_into_cart_id`, which is the trail to the cart its lines were copied into.
      *
      * @param {string} params.id - The cart, by its id — the `id` every cart answer carries. A uuid: the data plane casts the segment, so a code or a slug is refused before the cart is looked up.
      * @throws {RevenexxException}
-     * @returns {Promise<Models.Error>}
+     * @returns {Promise<Models.Cart>}
      */
     cartsGet(params: {
         id: string;
-    }): Promise<Models.Error>;
+    }): Promise<Models.Cart>;
     /**
      * One cart with its owner, its totals and its lifecycle stamps — and none of its lines: those are a separate call (`GET /carts/{cart_id}/items`), because a cart row is small and a filled cart is not. The two totals are derived and stored, never taken from a caller: `item_count` is the sum of the line QUANTITIES rather than the number of lines (two lines of five pieces answer 10, not 2) and `subtotal` the sum of the line totals, net of shipping and tax; both are recomputed after every line write. `status` says what may still be done — only an 'active' cart accepts a write of any kind, 'abandoned' is the one reversible ending, and a 'merged' cart carries `merged_into_cart_id`, which is the trail to the cart its lines were copied into.
      *
      * @param {string} id - The cart, by its id — the `id` every cart answer carries. A uuid: the data plane casts the segment, so a code or a slug is refused before the cart is looked up.
      * @throws {RevenexxException}
-     * @returns {Promise<Models.Error>}
+     * @returns {Promise<Models.Cart>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    cartsGet(id: string): Promise<Models.Error>;
+    cartsGet(id: string): Promise<Models.Cart>;
     /**
      * The four columns a cart's own editing screen owns, and only those: `name`, `currency`, `channel_id` and `metadata`. Everything else about a cart is either derived or a lifecycle move, and both are deliberately out of reach here — `item_count` and `subtotal` are recomputed from the lines, `status` travels through the action routes (activate, abandon, reopen, order, merge) so that every transition is guarded, and `market_id` is the platform's scope on the row rather than a column this app writes. A payload carrying none of the four answers 400 rather than storing nothing quietly, so a caller never believes an ignored field was saved. The owner is not updatable either: a guest cart becomes a customer's through carts.claim.
      *
@@ -479,7 +497,7 @@ declare class Carts {
      * @param {object} params.metadata - Free-form data the storefront hangs on the cart. Stored and returned verbatim; no key in here is read by this app, and none is indexed.
      * @param {string} params.name - Rename the cart. Unlike on create, this is written verbatim — `null` and `''` are refused by the database.
      * @throws {RevenexxException}
-     * @returns {Promise<Models.Error>}
+     * @returns {Promise<Models.Cart>}
      */
     cartsUpdate(params: {
         id: string;
@@ -487,7 +505,7 @@ declare class Carts {
         currency?: string;
         metadata?: object;
         name?: string;
-    }): Promise<Models.Error>;
+    }): Promise<Models.Cart>;
     /**
      * The four columns a cart's own editing screen owns, and only those: `name`, `currency`, `channel_id` and `metadata`. Everything else about a cart is either derived or a lifecycle move, and both are deliberately out of reach here — `item_count` and `subtotal` are recomputed from the lines, `status` travels through the action routes (activate, abandon, reopen, order, merge) so that every transition is guarded, and `market_id` is the platform's scope on the row rather than a column this app writes. A payload carrying none of the four answers 400 rather than storing nothing quietly, so a caller never believes an ignored field was saved. The owner is not updatable either: a guest cart becomes a customer's through carts.claim.
      *
@@ -497,111 +515,111 @@ declare class Carts {
      * @param {object} metadata - Free-form data the storefront hangs on the cart. Stored and returned verbatim; no key in here is read by this app, and none is indexed.
      * @param {string} name - Rename the cart. Unlike on create, this is written verbatim — `null` and `''` are refused by the database.
      * @throws {RevenexxException}
-     * @returns {Promise<Models.Error>}
+     * @returns {Promise<Models.Cart>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    cartsUpdate(id: string, channelId?: string, currency?: string, metadata?: object, name?: string): Promise<Models.Error>;
+    cartsUpdate(id: string, channelId?: string, currency?: string, metadata?: object, name?: string): Promise<Models.Cart>;
     /**
      * The by-hand half of the abandonment funnel: an active cart becomes 'abandoned', `abandoned_at` is stamped, and `is_current` is cleared — so its owner is left with no current cart until another one is activated. Nothing else in the platform writes `abandoned_at`; the only other writer is the cart-maintenance sweep, which does exactly this once a cart has sat untouched past the market's `abandon_after_minutes`. This is the one reversible ending: the lines are untouched throughout and carts.reopen takes the cart back. Only an active cart can be abandoned — an ordered or merged cart is already finished and answers 400 naming the status it actually holds.
      *
      * @param {string} params.id - The cart, by its id — the `id` every cart answer carries. A uuid: the data plane casts the segment, so a code or a slug is refused before the cart is looked up.
      * @throws {RevenexxException}
-     * @returns {Promise<Models.Error>}
+     * @returns {Promise<Models.Cart>}
      */
     cartsAbandon(params: {
         id: string;
-    }): Promise<Models.Error>;
+    }): Promise<Models.Cart>;
     /**
      * The by-hand half of the abandonment funnel: an active cart becomes 'abandoned', `abandoned_at` is stamped, and `is_current` is cleared — so its owner is left with no current cart until another one is activated. Nothing else in the platform writes `abandoned_at`; the only other writer is the cart-maintenance sweep, which does exactly this once a cart has sat untouched past the market's `abandon_after_minutes`. This is the one reversible ending: the lines are untouched throughout and carts.reopen takes the cart back. Only an active cart can be abandoned — an ordered or merged cart is already finished and answers 400 naming the status it actually holds.
      *
      * @param {string} id - The cart, by its id — the `id` every cart answer carries. A uuid: the data plane casts the segment, so a code or a slug is refused before the cart is looked up.
      * @throws {RevenexxException}
-     * @returns {Promise<Models.Error>}
+     * @returns {Promise<Models.Cart>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    cartsAbandon(id: string): Promise<Models.Error>;
+    cartsAbandon(id: string): Promise<Models.Cart>;
     /**
      * Activate writes exactly one thing: `is_current` on this cart, cleared on every other cart of the same owner (the same contact_id, or the same session_key). It does NOT change the status — an active cart stays active, and only an active cart may be made current. Read it back with `GET /carts?is_current=true` plus the owner: that filter is the only way to see what this route wrote, and a storefront resuming a session is its main caller. The flag is cleared again by abandoning, ordering or merging the cart, so an owner can legitimately have no current cart at all.
      *
      * @param {string} params.id - The cart, by its id — the `id` every cart answer carries. A uuid: the data plane casts the segment, so a code or a slug is refused before the cart is looked up.
      * @throws {RevenexxException}
-     * @returns {Promise<Models.Error>}
+     * @returns {Promise<Models.Cart>}
      */
     cartsActivate(params: {
         id: string;
-    }): Promise<Models.Error>;
+    }): Promise<Models.Cart>;
     /**
      * Activate writes exactly one thing: `is_current` on this cart, cleared on every other cart of the same owner (the same contact_id, or the same session_key). It does NOT change the status — an active cart stays active, and only an active cart may be made current. Read it back with `GET /carts?is_current=true` plus the owner: that filter is the only way to see what this route wrote, and a storefront resuming a session is its main caller. The flag is cleared again by abandoning, ordering or merging the cart, so an owner can legitimately have no current cart at all.
      *
      * @param {string} id - The cart, by its id — the `id` every cart answer carries. A uuid: the data plane casts the segment, so a code or a slug is refused before the cart is looked up.
      * @throws {RevenexxException}
-     * @returns {Promise<Models.Error>}
+     * @returns {Promise<Models.Cart>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    cartsActivate(id: string): Promise<Models.Error>;
+    cartsActivate(id: string): Promise<Models.Cart>;
     /**
      * Identical to carts.merge, with the SOURCE taken from the path — which is what makes the merge reachable from anything holding one cart and only one: a Cockpit row action, a detail page, a storefront session. The cart in the path is therefore the one that ends: its lines are copied into the `target_cart_id` named in the body, that target keeps its own lines and survives, and the path cart is closed with status 'merged' and `merged_into_cart_id` pointing at it. Getting the two the wrong way round is the mistake this route exists to make hard, so read the path id as "the cart I am giving away". Both carts must be active and must differ.
      *
      * @param {string} params.id - The SOURCE cart — the one whose lines move and which becomes status merged.
      * @param {string} params.targetCartId - Receiving cart (must be active). The cart in the path is the source and becomes status merged.
      * @throws {RevenexxException}
-     * @returns {Promise<Models.Error>}
+     * @returns {Promise<Models.CartMergeResult>}
      */
     cartsMergeInto(params: {
         id: string;
         targetCartId: string;
-    }): Promise<Models.Error>;
+    }): Promise<Models.CartMergeResult>;
     /**
      * Identical to carts.merge, with the SOURCE taken from the path — which is what makes the merge reachable from anything holding one cart and only one: a Cockpit row action, a detail page, a storefront session. The cart in the path is therefore the one that ends: its lines are copied into the `target_cart_id` named in the body, that target keeps its own lines and survives, and the path cart is closed with status 'merged' and `merged_into_cart_id` pointing at it. Getting the two the wrong way round is the mistake this route exists to make hard, so read the path id as "the cart I am giving away". Both carts must be active and must differ.
      *
      * @param {string} id - The SOURCE cart — the one whose lines move and which becomes status merged.
      * @param {string} targetCartId - Receiving cart (must be active). The cart in the path is the source and becomes status merged.
      * @throws {RevenexxException}
-     * @returns {Promise<Models.Error>}
+     * @returns {Promise<Models.CartMergeResult>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    cartsMergeInto(id: string, targetCartId: string): Promise<Models.Error>;
+    cartsMergeInto(id: string, targetCartId: string): Promise<Models.CartMergeResult>;
     /**
      * The hand-over to order management, and the end of the cart as a workspace: an ACTIVE cart becomes 'ordered', ordered_at is stamped, and the order_ref the call carries — order management's own number for the order this cart became — is stored on the cart, which is what lets anyone filter their way from an order number back to the cart behind it. Nothing moves out of 'ordered' afterwards, and no route will delete it. The conversion applies the two tenant decisions a cart cannot make for itself. price_snapshot_mode (snapshot | live) settles which of a line's two prices is charged — the snapshot the buyer was shown, or the current unit_price — and the cart's subtotal is rewritten to match, so cart and order can never disagree; 'pricing' reports the mode, the lines it rewrote and the subtotal on both sides. convert_reserves_stock (never | request | require) decides whether inventories is asked to hold the lines; at 'require' a refusal answers 409 and the cart stays active and unchanged. The reservation is attempted BEFORE anything is written.
      *
      * @param {string} params.id - The cart, by its id — the `id` every cart answer carries. A uuid: the data plane casts the segment, so a code or a slug is refused before the cart is looked up.
      * @param {string} params.orderRef - The order number this cart becomes, in order management's own numbering. Stored on the cart — filtering on it is how anyone gets from an order back to the cart behind it — and it is also the reference the stock reservation is booked under. Omit it and the cart id is used for the reservation instead.
      * @throws {RevenexxException}
-     * @returns {Promise<Models.Error>}
+     * @returns {Promise<Models.CartConversion>}
      */
     cartsOrder(params: {
         id: string;
         orderRef?: string;
-    }): Promise<Models.Error>;
+    }): Promise<Models.CartConversion>;
     /**
      * The hand-over to order management, and the end of the cart as a workspace: an ACTIVE cart becomes 'ordered', ordered_at is stamped, and the order_ref the call carries — order management's own number for the order this cart became — is stored on the cart, which is what lets anyone filter their way from an order number back to the cart behind it. Nothing moves out of 'ordered' afterwards, and no route will delete it. The conversion applies the two tenant decisions a cart cannot make for itself. price_snapshot_mode (snapshot | live) settles which of a line's two prices is charged — the snapshot the buyer was shown, or the current unit_price — and the cart's subtotal is rewritten to match, so cart and order can never disagree; 'pricing' reports the mode, the lines it rewrote and the subtotal on both sides. convert_reserves_stock (never | request | require) decides whether inventories is asked to hold the lines; at 'require' a refusal answers 409 and the cart stays active and unchanged. The reservation is attempted BEFORE anything is written.
      *
      * @param {string} id - The cart, by its id — the `id` every cart answer carries. A uuid: the data plane casts the segment, so a code or a slug is refused before the cart is looked up.
      * @param {string} orderRef - The order number this cart becomes, in order management's own numbering. Stored on the cart — filtering on it is how anyone gets from an order back to the cart behind it — and it is also the reference the stock reservation is booked under. Omit it and the cart id is used for the reservation instead.
      * @throws {RevenexxException}
-     * @returns {Promise<Models.Error>}
+     * @returns {Promise<Models.CartConversion>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    cartsOrder(id: string, orderRef?: string): Promise<Models.Error>;
+    cartsOrder(id: string, orderRef?: string): Promise<Models.CartConversion>;
     /**
      * Takes an abandoned cart back to 'active' with its lines exactly as they were — what a storefront calls when a buyer follows a recovery mail, and the way out of the 400 a write gets on a cart the maintenance sweep closed while nobody was looking. It also CLEARS `abandoned_at`, so a cart that was abandoned and reopened leaves nothing behind in the funnel: the funnel counts carts that are still abandoned, not carts that ever were. It does not restore `is_current` — a reopened cart is active but not current until carts.activate says so. Only an abandoned cart may be reopened; 'ordered' and 'merged' are final and answer 400 naming the status the cart holds.
      *
      * @param {string} params.id - The cart, by its id — the `id` every cart answer carries. A uuid: the data plane casts the segment, so a code or a slug is refused before the cart is looked up.
      * @throws {RevenexxException}
-     * @returns {Promise<Models.Error>}
+     * @returns {Promise<Models.Cart>}
      */
     cartsReopen(params: {
         id: string;
-    }): Promise<Models.Error>;
+    }): Promise<Models.Cart>;
     /**
      * Takes an abandoned cart back to 'active' with its lines exactly as they were — what a storefront calls when a buyer follows a recovery mail, and the way out of the 400 a write gets on a cart the maintenance sweep closed while nobody was looking. It also CLEARS `abandoned_at`, so a cart that was abandoned and reopened leaves nothing behind in the funnel: the funnel counts carts that are still abandoned, not carts that ever were. It does not restore `is_current` — a reopened cart is active but not current until carts.activate says so. Only an abandoned cart may be reopened; 'ordered' and 'merged' are final and answer 400 naming the status the cart holds.
      *
      * @param {string} id - The cart, by its id — the `id` every cart answer carries. A uuid: the data plane casts the segment, so a code or a slug is refused before the cart is looked up.
      * @throws {RevenexxException}
-     * @returns {Promise<Models.Error>}
+     * @returns {Promise<Models.Cart>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    cartsReopen(id: string): Promise<Models.Error>;
+    cartsReopen(id: string): Promise<Models.Cart>;
 }
 
 export { Carts };