@revenexx/node 0.0.1 → 0.1.0

package/dist/services/inventories-stock.d.ts

@@ -0,0 +1,681 @@
+import { Client } from '../client.js';
+import { Models } from '../models.js';
+import { InventoriesMovementsListType } from '../enums/inventories-movements-list-type.js';
+import { InventoriesVocabulariesGetName } from '../enums/inventories-vocabularies-get-name.js';
+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/assets-source.js';
+import '../enums/attribute-value-bucket.js';
+import '../enums/auth-mail-source.js';
+import '../enums/recovery-mail-source.js';
+import '../enums/registration-status.js';
+import '../enums/budget-change-reason.js';
+import '../enums/budget-movement-result-status.js';
+import '../enums/cart-status.js';
+import '../enums/cart-merge-strategy.js';
+import '../enums/cart-price-snapshot-mode.js';
+import '../enums/cart-io-format.js';
+import '../enums/cart-export-format.js';
+import '../enums/cart-item-type.js';
+import '../enums/cart-vocabulary-tone.js';
+import '../enums/cart-vocabulary-name.js';
+import '../enums/cart-vocabulary-source.js';
+import '../enums/cart-vocabulary-ref-name.js';
+import '../enums/categories-rule-match.js';
+import '../enums/category-rule-operator.js';
+import '../enums/category-rule-match.js';
+import '../enums/channel-status.js';
+import '../enums/channel-unassigned-visibility.js';
+import '../enums/channel-unresolved-reason.js';
+import '../enums/channel-context-source.js';
+import '../enums/channel-inactive-behavior.js';
+import '../enums/channel-policy-source.js';
+import '../enums/channel-policy-tenant-default.js';
+import '../enums/channel-unassigned-policy.js';
+import '../enums/channel-type-tone.js';
+import '../enums/channel-visibility-reason.js';
+import '../enums/channel-vocabulary-tone.js';
+import '../enums/channel-vocabulary-name.js';
+import '../enums/channel-vocabulary-source.js';
+import '../enums/channel-vocabulary-ref-name.js';
+import '../enums/contact-registration-status.js';
+import '../enums/contact-status.js';
+import '../enums/contact-activity-kind.js';
+import '../enums/contact-create-request-registration-status.js';
+import '../enums/contact-event-kind-tone.js';
+import '../enums/contact-event-kind-create-request-tone.js';
+import '../enums/contact-event-kind-update-request-tone.js';
+import '../enums/contact-update-request-registration-status.js';
+import '../enums/cost-center-budget-type.js';
+import '../enums/cost-center-restriction-type.js';
+import '../enums/cost-center-restriction-create-request-type.js';
+import '../enums/cost-center-restriction-update-request-type.js';
+import '../enums/payment-fee-type.js';
+import '../enums/payment-method-kind.js';
+import '../enums/form-status.js';
+import '../enums/form-submission-status.js';
+import '../enums/form-notify-source.js';
+import '../enums/form-submission-prune-request-status.js';
+import '../enums/forms-vocabulary-tone.js';
+import '../enums/forms-vocabulary-name.js';
+import '../enums/forms-vocabulary-summary-name.js';
+import '../enums/inventory-vocabulary-default-tone.js';
+import '../enums/inventory-vocabulary-source.js';
+import '../enums/cart-io-apply-mode.js';
+import '../enums/cart-io-direction.js';
+import '../enums/cart-io-entity.js';
+import '../enums/io-profile-resource-apply-mode.js';
+import '../enums/io-profile-resource-direction.js';
+import '../enums/lifecycle-stage-tone.js';
+import '../enums/lifecycle-stage-create-request-tone.js';
+import '../enums/lifecycle-stage-update-request-tone.js';
+import '../enums/location-type.js';
+import '../enums/market-status.js';
+import '../enums/market-default-locale-source.js';
+import '../enums/market-locale-fallback.js';
+import '../enums/market-locale-granularity.js';
+import '../enums/market-pricing-source.js';
+import '../enums/market-tax-basis.js';
+import '../enums/market-readiness-check-id.js';
+import '../enums/market-readiness-severity.js';
+import '../enums/markets-vocabulary-tone.js';
+import '../enums/markets-vocabulary-name.js';
+import '../enums/markets-vocabulary-source.js';
+import '../enums/markets-vocabulary-summary-name.js';
+import '../enums/order-fulfillment-status.js';
+import '../enums/order-payment-status.js';
+import '../enums/order-status.js';
+import '../enums/order-cancellation-scope.js';
+import '../enums/order-comment-visibility.js';
+import '../enums/order-item-type.js';
+import '../enums/order-list-kind-tone.js';
+import '../enums/order-list-kind-row-tone.js';
+import '../enums/order-list-cart-mode.js';
+import '../enums/order-list-vocabulary-default-tone.js';
+import '../enums/order-list-vocabulary-name.js';
+import '../enums/order-list-vocabulary-source.js';
+import '../enums/order-list-vocabulary-tone.js';
+import '../enums/order-return-status.js';
+import '../enums/order-return-settlement.js';
+import '../enums/order-return-refusal.js';
+import '../enums/order-vocabulary-tone.js';
+import '../enums/order-vocabulary-name.js';
+import '../enums/order-vocabulary-source.js';
+import '../enums/order-vocabulary-summary-name.js';
+import '../enums/order-resolution-stage.js';
+import '../enums/organization-status.js';
+import '../enums/page-status.js';
+import '../enums/pages-vocabulary-app.js';
+import '../enums/pages-vocabulary-tone.js';
+import '../enums/pages-vocabulary-name.js';
+import '../enums/pages-vocabulary-source.js';
+import '../enums/pages-vocabulary-index-app.js';
+import '../enums/payment-dunning-stage.js';
+import '../enums/payment-failure-code.js';
+import '../enums/payment-status.js';
+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/price-ending-rule.js';
+import '../enums/price-entries-adjust-response-rounding.js';
+import '../enums/price-entries-adjust-response-rounding-mode.js';
+import '../enums/price-entries-bulk-mode.js';
+import '../enums/price-rounding-mode.js';
+import '../enums/price-entry-type.js';
+import '../enums/price-list-status.js';
+import '../enums/price-list-tax-basis.js';
+import '../enums/price-currency-source.js';
+import '../enums/price-list-tiebreak.js';
+import '../enums/price-tax-inclusive-default.js';
+import '../enums/price-tax-unresolved-reason.js';
+import '../enums/price-tax-market-source.js';
+import '../enums/price-vocabulary-tone.js';
+import '../enums/price-vocabulary-name.js';
+import '../enums/price-vocabulary-source.js';
+import '../enums/price-vocabulary-ref-name.js';
+import '../enums/product-categories-source.js';
+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/reorder-point-source.js';
+import '../enums/reservation-status.js';
+import '../enums/price-on-request-reason.js';
+import '../enums/price-tax-basis.js';
+import '../enums/price-tax-basis-source.js';
+import '../enums/role-catalog-response-source.js';
+import '../enums/segment-rule-match.js';
+import '../enums/segment-member-source.js';
+import '../enums/segment-rule-operator.js';
+import '../enums/segment-rule-preview-request-rule-match.js';
+import '../enums/segment-rule-preview-request-target.js';
+import '../enums/segment-rule-preview-response-rule-match.js';
+import '../enums/segment-rule-preview-response-target.js';
+import '../enums/segment-rules-target.js';
+import '../enums/shipping-carrier-status.js';
+import '../enums/shipping-method-matrix-basis.js';
+import '../enums/shipping-method-pricing-type.js';
+import '../enums/shipping-carrier-source.js';
+import '../enums/shipping-rate-pricing-type.js';
+import '../enums/shipping-tax-source.js';
+import '../enums/shipping-free-above-basis.js';
+import '../enums/shipping-rates-basis-matrix-basis-default.js';
+import '../enums/shipping-service-level-create-request-tone.js';
+import '../enums/shipping-service-level-row-tone.js';
+import '../enums/shipping-service-level-update-request-tone.js';
+import '../enums/shipping-tax-unresolved-reason.js';
+import '../enums/shipping-tax-market-source.js';
+import '../enums/shipping-tax-context-via.js';
+import '../enums/shipping-tracking-carrier-status.js';
+import '../enums/shipping-vocabulary-default-tone.js';
+import '../enums/shipping-vocabulary-source.js';
+import '../enums/shipping-vocabulary-tone.js';
+import '../enums/shipping-weight-unit-create-request-tone.js';
+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/validation-failed-response-status.js';
+import '../enums/vocabulary-default-tone.js';
+import '../enums/vocabulary-source.js';
+import '../enums/vocabulary-tone.js';
+import '../enums/attribute-boolean-status.js';
+import '../enums/attribute-datetime-status.js';
+import '../enums/attribute-email-status.js';
+import '../enums/attribute-enum-status.js';
+import '../enums/attribute-float-status.js';
+import '../enums/attribute-integer-status.js';
+import '../enums/attribute-ip-status.js';
+import '../enums/attribute-line-status.js';
+import '../enums/attribute-longtext-status.js';
+import '../enums/attribute-mediumtext-status.js';
+import '../enums/attribute-point-status.js';
+import '../enums/attribute-polygon-status.js';
+import '../enums/attribute-relationship-status.js';
+import '../enums/attribute-string-status.js';
+import '../enums/attribute-text-status.js';
+import '../enums/attribute-url-status.js';
+import '../enums/attribute-varchar-status.js';
+import '../enums/column-boolean-status.js';
+import '../enums/column-datetime-status.js';
+import '../enums/column-email-status.js';
+import '../enums/column-enum-status.js';
+import '../enums/column-float-status.js';
+import '../enums/column-integer-status.js';
+import '../enums/column-ip-status.js';
+import '../enums/column-line-status.js';
+import '../enums/column-longtext-status.js';
+import '../enums/column-mediumtext-status.js';
+import '../enums/column-point-status.js';
+import '../enums/column-polygon-status.js';
+import '../enums/column-relationship-status.js';
+import '../enums/column-string-status.js';
+import '../enums/column-text-status.js';
+import '../enums/column-url-status.js';
+import '../enums/column-varchar-status.js';
+import '../enums/database-type.js';
+import '../enums/deployment-status.js';
+import '../enums/execution-status.js';
+import '../enums/execution-trigger.js';
+import '../enums/health-antivirus-status.js';
+import '../enums/health-status-status.js';
+import '../enums/index-status.js';
+import '../enums/message-2-status.js';
+
+declare class InventoriesStock {
+    client: Client;
+    constructor(client: Client);
+    /**
+     * The batch correction route — a stocktake, breakage, shrinkage — and the manual way `on_hand` is ever put right. Quantities are SIGNED: a positive one adds to the balance, a negative one takes it away, and neither is written onto the row directly. Each item is booked into the movements ledger as an `adjustment` and the balance follows, so a correction leaves a record of who changed what and why instead of a number that silently differs from yesterday's. A reason is mandatory unless movement_reason_required is 'none'.
+     *
+     * @param {Models.InventoryAdjustItem[]} params.items - The corrections, at most 200 in one call — a stocktake, breakage, shrinkage. Quantities are SIGNED deltas, not new balances.
+     * @param {string} params.locationCode - Which location is being corrected. Omitted, the `default_location_code` setting decides. A correction is per location: the same SKU in two warehouses is two corrections.
+     * @param {string} params.productId - Inline single-item form: the product to move, instead of a one-entry `items` array. The two forms are equivalent — nothing downstream knows which arrived.
+     * @param {number} params.quantity - Inline single-item form: the SIGNED correction (negative writes stock off, positive finds it). Non-zero.
+     * @param {string} params.reason - Why the stock is being corrected — this is the audit trail a stocktake leaves behind. Owed unless `movement_reason_required` is 'none' (its default, 'adjustments', asks for one exactly here); missing where it is owed, the call is 400.
+     * @param {string} params.sku - Inline single-item form: the article number to move (instead of `product_id`).
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     */
+    inventoriesAdjust(params?: {
+        items?: Models.InventoryAdjustItem[];
+        locationCode?: string;
+        productId?: string;
+        quantity?: number;
+        reason?: string;
+        sku?: string;
+    }): Promise<Models.Error>;
+    /**
+     * The batch correction route — a stocktake, breakage, shrinkage — and the manual way `on_hand` is ever put right. Quantities are SIGNED: a positive one adds to the balance, a negative one takes it away, and neither is written onto the row directly. Each item is booked into the movements ledger as an `adjustment` and the balance follows, so a correction leaves a record of who changed what and why instead of a number that silently differs from yesterday's. A reason is mandatory unless movement_reason_required is 'none'.
+     *
+     * @param {Models.InventoryAdjustItem[]} items - The corrections, at most 200 in one call — a stocktake, breakage, shrinkage. Quantities are SIGNED deltas, not new balances.
+     * @param {string} locationCode - Which location is being corrected. Omitted, the `default_location_code` setting decides. A correction is per location: the same SKU in two warehouses is two corrections.
+     * @param {string} productId - Inline single-item form: the product to move, instead of a one-entry `items` array. The two forms are equivalent — nothing downstream knows which arrived.
+     * @param {number} quantity - Inline single-item form: the SIGNED correction (negative writes stock off, positive finds it). Non-zero.
+     * @param {string} reason - Why the stock is being corrected — this is the audit trail a stocktake leaves behind. Owed unless `movement_reason_required` is 'none' (its default, 'adjustments', asks for one exactly here); missing where it is owed, the call is 400.
+     * @param {string} sku - Inline single-item form: the article number to move (instead of `product_id`).
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    inventoriesAdjust(items?: Models.InventoryAdjustItem[], locationCode?: string, productId?: string, quantity?: number, reason?: string, sku?: string): Promise<Models.Error>;
+    /**
+     * THE stock call of this app, and a batch one: name any number of items and each comes back with `on_hand`, `reserved` and the derived `available` (their difference, computed on read and stored nowhere), summed across the locations in scope and broken down per location, plus `orderable` — whether this much of it can be promised at this moment. An item this app has never seen is NOT an error: it comes back tracked:false, and the storefront decides whether an untracked item sells freely. It is also the most customised surface this product has in the field. A tenant whose stock really lives in an ERP — SAP live stock is the ordinary case, not the exotic one — replaces exactly this one capability, 1:1, with a custom app through the gateway's capability override, while every other route here keeps doing the stock-keeping CRUD unchanged. That is why the request and response shapes below read as a contract to be implemented rather than as an implementation detail: whatever ends up answering this path has to answer in these terms.
+     *
+     * @param {Models.InventoryAvailabilityItem[]} params.items - The items to check, at most 200 in one call. A cart, a category page, a feed row — one call answers them all, which is why this route is the batch one.
+     * @param {string} params.locationCode - Restrict the check to ONE location, by its code — the stock a click-and-collect store can promise today. Omitted, every ENABLED location is summed; a disabled one is never counted either way.
+     * @param {string} params.productId - Inline single-item form: the product to move, instead of a one-entry `items` array. The two forms are equivalent — nothing downstream knows which arrived.
+     * @param {number} params.quantity - Inline single-item form: how many are wanted (default 1). It decides `orderable` and nothing else.
+     * @param {string} params.sku - Inline single-item form: the article number to move (instead of `product_id`).
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     */
+    inventoriesAvailability(params?: {
+        items?: Models.InventoryAvailabilityItem[];
+        locationCode?: string;
+        productId?: string;
+        quantity?: number;
+        sku?: string;
+    }): Promise<Models.Error>;
+    /**
+     * THE stock call of this app, and a batch one: name any number of items and each comes back with `on_hand`, `reserved` and the derived `available` (their difference, computed on read and stored nowhere), summed across the locations in scope and broken down per location, plus `orderable` — whether this much of it can be promised at this moment. An item this app has never seen is NOT an error: it comes back tracked:false, and the storefront decides whether an untracked item sells freely. It is also the most customised surface this product has in the field. A tenant whose stock really lives in an ERP — SAP live stock is the ordinary case, not the exotic one — replaces exactly this one capability, 1:1, with a custom app through the gateway's capability override, while every other route here keeps doing the stock-keeping CRUD unchanged. That is why the request and response shapes below read as a contract to be implemented rather than as an implementation detail: whatever ends up answering this path has to answer in these terms.
+     *
+     * @param {Models.InventoryAvailabilityItem[]} items - The items to check, at most 200 in one call. A cart, a category page, a feed row — one call answers them all, which is why this route is the batch one.
+     * @param {string} locationCode - Restrict the check to ONE location, by its code — the stock a click-and-collect store can promise today. Omitted, every ENABLED location is summed; a disabled one is never counted either way.
+     * @param {string} productId - Inline single-item form: the product to move, instead of a one-entry `items` array. The two forms are equivalent — nothing downstream knows which arrived.
+     * @param {number} quantity - Inline single-item form: how many are wanted (default 1). It decides `orderable` and nothing else.
+     * @param {string} sku - Inline single-item form: the article number to move (instead of `product_id`).
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    inventoriesAvailability(items?: Models.InventoryAvailabilityItem[], locationCode?: string, productId?: string, quantity?: number, sku?: string): Promise<Models.Error>;
+    /**
+     * The movements ledger, read end to end. Every stock change this app has ever made is a booking row in it — a receipt, a correction, a hold, a release, a shipment, a return — which is what lets one list be an audit trail and an event feed at the same time: these are the rows the `stock_movement.created` event carries, so a consumer that missed an event catches up by paging here. Append-only: the ledger has no update and no delete, because a correction is another booking. `order=created_at.desc` is the feed order.
+     *
+     * @param {number} params.limit - Page size (default 50, max 200). A larger value is clamped rather than refused.
+     * @param {number} params.offset - Row offset for pagination (default 0). Page with `page.total` and `page.hasMore`.
+     * @param {string} params.order - Sort by one column: 'column' | 'column.asc' | 'column.desc' — a bare column sorts ascending. The column has to be one this entity has; anything else is refused with 400.
+     * @param {string} params.id - Exact-match filter on `id`. The row's own id, generated by the database.
+     * @param {string} params.locationId - Exact-match filter on `location_id`. Every booking at one location.
+     * @param {string} params.productId - Exact-match filter on `product_id`. The product this booking is for, copied from the call.
+     * @param {string} params.sku - Exact-match filter on `sku`. Every booking for one SKU.
+     * @param {InventoriesMovementsListType} params.type - Exact-match filter on `type`. What the booking records. The permitted set is the CHECK constraint — GET /inventories/vocabularies/movement-types has the words for it.
+     * @param {number} params.quantity - Exact-match filter on `quantity`. Exact signed quantity, which is a needle-in-a-haystack filter rather than a range: `?quantity=-5` finds the bookings that moved exactly five out.
+     * @param {string} params.orderRef - Exact-match filter on `order_ref`. One order's whole stock history: its reserve, release, shipment and restock bookings.
+     * @param {string} params.reason - Exact-match filter on `reason`. Why the booking happened, in a person's words — a delivery note number, 'stocktake 2026-03', 'damaged in transit'.
+     * @param {string} params.metadata - Exact-match filter on `metadata`. Free-form, and two keys this app writes itself: `backordered` — on a `reserve` booking, how much of the hold was not covered by stock on hand; `shortfall` — on a `shipment` booking, how much was committed that was not physically there (`on_hand` floors at 0, so the difference is recorded here instead of vanishing). The WHOLE jsonb document is compared, serialized as JSON — this is equality, not a key lookup or a containment query, and a value that does not parse is answered 400.
+     * @param {string} params.createdAt - Exact-match filter on `created_at`. Exact timestamp. There is no range filter on the ledger — page it with `?order=created_at.desc` instead.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     */
+    inventoriesMovementsList(params?: {
+        limit?: number;
+        offset?: number;
+        order?: string;
+        id?: string;
+        locationId?: string;
+        productId?: string;
+        sku?: string;
+        type?: InventoriesMovementsListType;
+        quantity?: number;
+        orderRef?: string;
+        reason?: string;
+        metadata?: string;
+        createdAt?: string;
+    }): Promise<Models.Error>;
+    /**
+     * The movements ledger, read end to end. Every stock change this app has ever made is a booking row in it — a receipt, a correction, a hold, a release, a shipment, a return — which is what lets one list be an audit trail and an event feed at the same time: these are the rows the `stock_movement.created` event carries, so a consumer that missed an event catches up by paging here. Append-only: the ledger has no update and no delete, because a correction is another booking. `order=created_at.desc` is the feed order.
+     *
+     * @param {number} limit - Page size (default 50, max 200). A larger value is clamped rather than refused.
+     * @param {number} offset - Row offset for pagination (default 0). Page with `page.total` and `page.hasMore`.
+     * @param {string} order - Sort by one column: 'column' | 'column.asc' | 'column.desc' — a bare column sorts ascending. The column has to be one this entity has; anything else is refused with 400.
+     * @param {string} id - Exact-match filter on `id`. The row's own id, generated by the database.
+     * @param {string} locationId - Exact-match filter on `location_id`. Every booking at one location.
+     * @param {string} productId - Exact-match filter on `product_id`. The product this booking is for, copied from the call.
+     * @param {string} sku - Exact-match filter on `sku`. Every booking for one SKU.
+     * @param {InventoriesMovementsListType} type - Exact-match filter on `type`. What the booking records. The permitted set is the CHECK constraint — GET /inventories/vocabularies/movement-types has the words for it.
+     * @param {number} quantity - Exact-match filter on `quantity`. Exact signed quantity, which is a needle-in-a-haystack filter rather than a range: `?quantity=-5` finds the bookings that moved exactly five out.
+     * @param {string} orderRef - Exact-match filter on `order_ref`. One order's whole stock history: its reserve, release, shipment and restock bookings.
+     * @param {string} reason - Exact-match filter on `reason`. Why the booking happened, in a person's words — a delivery note number, 'stocktake 2026-03', 'damaged in transit'.
+     * @param {string} metadata - Exact-match filter on `metadata`. Free-form, and two keys this app writes itself: `backordered` — on a `reserve` booking, how much of the hold was not covered by stock on hand; `shortfall` — on a `shipment` booking, how much was committed that was not physically there (`on_hand` floors at 0, so the difference is recorded here instead of vanishing). The WHOLE jsonb document is compared, serialized as JSON — this is equality, not a key lookup or a containment query, and a value that does not parse is answered 400.
+     * @param {string} createdAt - Exact-match filter on `created_at`. Exact timestamp. There is no range filter on the ledger — page it with `?order=created_at.desc` instead.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    inventoriesMovementsList(limit?: number, offset?: number, order?: string, id?: string, locationId?: string, productId?: string, sku?: string, type?: InventoriesMovementsListType, quantity?: number, orderRef?: string, reason?: string, metadata?: string, createdAt?: string): Promise<Models.Error>;
+    /**
+     * A movement is one booking row in the ledger, and the ledger is append-only: there is no update and no delete, because a correction is another booking. `quantity` is SIGNED and its sign follows the `type` — a receipt books +5 and the reserve that promises those goods books −5, even though the reservation it created carries +5 as a positive hold. GET /inventories/vocabularies/movement-types is the list of types with the words for them. A booking says what changed, not what the balance became: it carries no running total, so the row's story is read by listing the ledger for that location and item rather than by fetching one id. `location_id` is a plain uuid and not a foreign key, so a booking outlives the location it was made at and this route will happily hand back one whose location no longer resolves — that is the audit trail doing its job, not a broken row. Fixing a wrong booking is another booking (POST /inventories/adjust); nothing here can be edited or removed.
+     *
+     * @param {string} params.id - The ledger booking.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     */
+    inventoriesMovementsGet(params: {
+        id: string;
+    }): Promise<Models.Error>;
+    /**
+     * A movement is one booking row in the ledger, and the ledger is append-only: there is no update and no delete, because a correction is another booking. `quantity` is SIGNED and its sign follows the `type` — a receipt books +5 and the reserve that promises those goods books −5, even though the reservation it created carries +5 as a positive hold. GET /inventories/vocabularies/movement-types is the list of types with the words for them. A booking says what changed, not what the balance became: it carries no running total, so the row's story is read by listing the ledger for that location and item rather than by fetching one id. `location_id` is a plain uuid and not a foreign key, so a booking outlives the location it was made at and this route will happily hand back one whose location no longer resolves — that is the audit trail doing its job, not a broken row. Fixing a wrong booking is another booking (POST /inventories/adjust); nothing here can be edited or removed.
+     *
+     * @param {string} id - The ledger booking.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    inventoriesMovementsGet(id: string): Promise<Models.Error>;
+    /**
+     * Books a delivery into the receiving location (the caller's location_code, else the default_location_code setting), creating the stock row if the item is new. A reason is optional unless movement_reason_required is 'all'. Takes a batch or one item inline.
+     *
+     * @param {Models.InventoryStockItem[]} params.items - The goods that arrived, at most 200 in one call — a delivery, a production batch, an opening balance.
+     * @param {string} params.locationCode - Which location took the delivery. Omitted, the `default_location_code` setting decides; a code no location carries is answered 400 rather than booked somewhere else.
+     * @param {string} params.productId - Inline single-item form: the product to move, instead of a one-entry `items` array. The two forms are equivalent — nothing downstream knows which arrived.
+     * @param {number} params.quantity - Inline single-item form: how many arrived. Positive.
+     * @param {string} params.reason - What the ledger should record about this receipt — a delivery note number, a production order. Owed only when `movement_reason_required` is 'all'; the contract does not require it, because whether it is owed is the tenant's setting and not this route's rule.
+     * @param {string} params.sku - Inline single-item form: the article number to move (instead of `product_id`).
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     */
+    inventoriesReceive(params?: {
+        items?: Models.InventoryStockItem[];
+        locationCode?: string;
+        productId?: string;
+        quantity?: number;
+        reason?: string;
+        sku?: string;
+    }): Promise<Models.Error>;
+    /**
+     * Books a delivery into the receiving location (the caller's location_code, else the default_location_code setting), creating the stock row if the item is new. A reason is optional unless movement_reason_required is 'all'. Takes a batch or one item inline.
+     *
+     * @param {Models.InventoryStockItem[]} items - The goods that arrived, at most 200 in one call — a delivery, a production batch, an opening balance.
+     * @param {string} locationCode - Which location took the delivery. Omitted, the `default_location_code` setting decides; a code no location carries is answered 400 rather than booked somewhere else.
+     * @param {string} productId - Inline single-item form: the product to move, instead of a one-entry `items` array. The two forms are equivalent — nothing downstream knows which arrived.
+     * @param {number} quantity - Inline single-item form: how many arrived. Positive.
+     * @param {string} reason - What the ledger should record about this receipt — a delivery note number, a production order. Owed only when `movement_reason_required` is 'all'; the contract does not require it, because whether it is owed is the tenant's setting and not this route's rule.
+     * @param {string} sku - Inline single-item form: the article number to move (instead of `product_id`).
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    inventoriesReceive(items?: Models.InventoryStockItem[], locationCode?: string, productId?: string, quantity?: number, reason?: string, sku?: string): Promise<Models.Error>;
+    /**
+     * The replenishment worklist: the stock rows that have run down far enough that somebody has to order more, in one list rather than as a query a caller has to build. Computed on read, so it is never stale: a row alerts when available (on_hand − reserved) has fallen to or below its own reorder_point, or the reorder_point_default setting when it carries none. A point of 0 never alerts. Answers enabled:false with an empty list when reorder_alert_enabled is off — a tenant replenishing from an ERP should not be told twice.
+     *
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.ReorderAlerts>}
+     */
+    inventoriesReorderAlerts(): Promise<Models.ReorderAlerts>;
+    /**
+     * Publishes `stock_level.low` on the event bus for every row GET /inventories/reorder-alerts currently lists, so replenishment can be driven by a subscriber instead of by somebody refreshing that page. Also runs hourly as the `reorder-scan` schedule; this route is for driving it on demand. The event id is derived from the stock row and the day, so a re-run — a second click, a retried cron tick — publishes nothing new and returns the ids the first run produced. Nothing is written to the app's own data: this reads the same figures the alerts list computes and hands them to the bus. Answers enabled:false without publishing when reorder_alert_enabled is off.
+     *
+     * @param {object} params.data - Request body
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.ReorderScan>}
+     */
+    inventoriesReorderScan(params: {
+        data: object;
+    }): Promise<Models.ReorderScan>;
+    /**
+     * Publishes `stock_level.low` on the event bus for every row GET /inventories/reorder-alerts currently lists, so replenishment can be driven by a subscriber instead of by somebody refreshing that page. Also runs hourly as the `reorder-scan` schedule; this route is for driving it on demand. The event id is derived from the stock row and the day, so a re-run — a second click, a retried cron tick — publishes nothing new and returns the ids the first run produced. Nothing is written to the app's own data: this reads the same figures the alerts list computes and hands them to the bus. Answers enabled:false without publishing when reorder_alert_enabled is off.
+     *
+     * @param {object} data - Request body
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.ReorderScan>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    inventoriesReorderScan(data: object): Promise<Models.ReorderScan>;
+    /**
+     * Whether a return rejoins sellable stock follows restock_on_return_default, overridable per call with 'restock'. When the answer is no the response says restocked:false and nothing moves — there is no movement to book, because no stock moved. That branch is why this route answers 200 and its sibling `receive` answers 201: a restock may legitimately create nothing.
+     *
+     * @param {Models.InventoryStockItem[]} params.items - The goods that came back, at most 200 in one call. Whether they rejoin sellable stock is `restock`, not this list.
+     * @param {string} params.locationCode - Where the goods came back to — a returns warehouse is a location like any other. Omitted, the `default_location_code` setting decides.
+     * @param {string} params.orderRef - The order the goods came back from. It is written onto the ledger booking, so the return shows up in that order's stock history next to its reserve and shipment — no reservation is touched by it.
+     * @param {string} params.productId - Inline single-item form: the product to move, instead of a one-entry `items` array. The two forms are equivalent — nothing downstream knows which arrived.
+     * @param {number} params.quantity - Inline single-item form: how many came back. Positive.
+     * @param {string} params.reason - Why the goods came back — 'wrong size', 'damaged on arrival'. Owed only when `movement_reason_required` is 'all'.
+     * @param {boolean} params.restock - Do these goods rejoin SELLABLE stock? A merchant decision, not a fact: apparel usually restocks, hygiene articles never do, many merchants inspect first. Omit it to follow the `restock_on_return_default` setting. `false` answers `restocked: false`, moves nothing and books NOTHING — there is no movement to write, because no stock moved, and that is the branch that makes this route a 200 while its sibling `receive` is a 201.
+     * @param {string} params.sku - Inline single-item form: the article number to move (instead of `product_id`).
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     */
+    inventoriesRestock(params?: {
+        items?: Models.InventoryStockItem[];
+        locationCode?: string;
+        orderRef?: string;
+        productId?: string;
+        quantity?: number;
+        reason?: string;
+        restock?: boolean;
+        sku?: string;
+    }): Promise<Models.Error>;
+    /**
+     * Whether a return rejoins sellable stock follows restock_on_return_default, overridable per call with 'restock'. When the answer is no the response says restocked:false and nothing moves — there is no movement to book, because no stock moved. That branch is why this route answers 200 and its sibling `receive` answers 201: a restock may legitimately create nothing.
+     *
+     * @param {Models.InventoryStockItem[]} items - The goods that came back, at most 200 in one call. Whether they rejoin sellable stock is `restock`, not this list.
+     * @param {string} locationCode - Where the goods came back to — a returns warehouse is a location like any other. Omitted, the `default_location_code` setting decides.
+     * @param {string} orderRef - The order the goods came back from. It is written onto the ledger booking, so the return shows up in that order's stock history next to its reserve and shipment — no reservation is touched by it.
+     * @param {string} productId - Inline single-item form: the product to move, instead of a one-entry `items` array. The two forms are equivalent — nothing downstream knows which arrived.
+     * @param {number} quantity - Inline single-item form: how many came back. Positive.
+     * @param {string} reason - Why the goods came back — 'wrong size', 'damaged on arrival'. Owed only when `movement_reason_required` is 'all'.
+     * @param {boolean} restock - Do these goods rejoin SELLABLE stock? A merchant decision, not a fact: apparel usually restocks, hygiene articles never do, many merchants inspect first. Omit it to follow the `restock_on_return_default` setting. `false` answers `restocked: false`, moves nothing and books NOTHING — there is no movement to write, because no stock moved, and that is the branch that makes this route a 200 while its sibling `receive` is a 201.
+     * @param {string} sku - Inline single-item form: the article number to move (instead of `product_id`).
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    inventoriesRestock(items?: Models.InventoryStockItem[], locationCode?: string, orderRef?: string, productId?: string, quantity?: number, reason?: string, restock?: boolean, sku?: string): Promise<Models.Error>;
+    /**
+     * A stock level is ONE item at ONE location, and it carries two numbers, neither of which is the sellable one: `on_hand` is what is physically there INCLUDING everything already promised, and `reserved` is what has been promised — it never reduces `on_hand`. What may still be sold is their difference, and it is derived on read and never stored, so there is no `available` column to read, filter or order by. This is the operator's view — the whole book, filtered by location or by item — not the shop's: a storefront asking "can I sell five of this" wants POST /inventories/availability, which sums an item across locations and answers `orderable` instead of leaving the caller to subtract. Two things this list will not do: it has no range filters, so "everything running low" is GET /inventories/reorder-alerts and not a query here; and it does not promise one row per item per location — no unique index enforces that. POST /inventories/stock refuses a duplicate with a 409, but that is a check and not a constraint, so a row written past it, or one that predates the guard, still splits an item's balance in two, and the write routes find and update whichever of them the database returns first.
+     *
+     * @param {number} params.limit - Page size (default 50, max 200). A larger value is clamped rather than refused.
+     * @param {number} params.offset - Row offset for pagination (default 0). Page with `page.total` and `page.hasMore`.
+     * @param {string} params.order - Sort by one column: 'column' | 'column.asc' | 'column.desc' — a bare column sorts ascending. The column has to be one this entity has; anything else is refused with 400.
+     * @param {string} params.id - Exact-match filter on `id`. The row's own id, generated by the database.
+     * @param {string} params.locationId - Exact-match filter on `location_id`. The rows held at one location. An id no location carries is an empty page, not an error.
+     * @param {string} params.productId - Exact-match filter on `product_id`. The rows tracking one product, across every location.
+     * @param {string} params.sku - Exact-match filter on `sku`. The rows tracking one SKU — the identity used when an item has no product id.
+     * @param {number} params.onHand - Exact-match filter on `on_hand`. Exact balance, which is rarely what a reader wants: `?on_hand=0` finds the rows that are empty. There is no range filter here — GET /inventories/reorder-alerts is the "running low" question.
+     * @param {number} params.reserved - Exact-match filter on `reserved`. Exact reserved quantity. `?reserved=0` finds the rows nothing is holding.
+     * @param {number} params.reorderPoint - Exact-match filter on `reorder_point`. The available quantity at or below which this row belongs on the replenishment worklist (GET /inventories/reorder-alerts).
+     * @param {string} params.metadata - Exact-match filter on `metadata`. Free-form data the tenant keeps on this stock row, and ONE key this app reads: `backorder`. The WHOLE jsonb document is compared, serialized as JSON — this is equality, not a key lookup or a containment query, and a value that does not parse is answered 400.
+     * @param {string} params.createdAt - Exact-match filter on `created_at`. When the row was created.
+     * @param {string} params.updatedAt - Exact-match filter on `updated_at`. When this row was last written.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     */
+    inventoriesStockList(params?: {
+        limit?: number;
+        offset?: number;
+        order?: string;
+        id?: string;
+        locationId?: string;
+        productId?: string;
+        sku?: string;
+        onHand?: number;
+        reserved?: number;
+        reorderPoint?: number;
+        metadata?: string;
+        createdAt?: string;
+        updatedAt?: string;
+    }): Promise<Models.Error>;
+    /**
+     * A stock level is ONE item at ONE location, and it carries two numbers, neither of which is the sellable one: `on_hand` is what is physically there INCLUDING everything already promised, and `reserved` is what has been promised — it never reduces `on_hand`. What may still be sold is their difference, and it is derived on read and never stored, so there is no `available` column to read, filter or order by. This is the operator's view — the whole book, filtered by location or by item — not the shop's: a storefront asking "can I sell five of this" wants POST /inventories/availability, which sums an item across locations and answers `orderable` instead of leaving the caller to subtract. Two things this list will not do: it has no range filters, so "everything running low" is GET /inventories/reorder-alerts and not a query here; and it does not promise one row per item per location — no unique index enforces that. POST /inventories/stock refuses a duplicate with a 409, but that is a check and not a constraint, so a row written past it, or one that predates the guard, still splits an item's balance in two, and the write routes find and update whichever of them the database returns first.
+     *
+     * @param {number} limit - Page size (default 50, max 200). A larger value is clamped rather than refused.
+     * @param {number} offset - Row offset for pagination (default 0). Page with `page.total` and `page.hasMore`.
+     * @param {string} order - Sort by one column: 'column' | 'column.asc' | 'column.desc' — a bare column sorts ascending. The column has to be one this entity has; anything else is refused with 400.
+     * @param {string} id - Exact-match filter on `id`. The row's own id, generated by the database.
+     * @param {string} locationId - Exact-match filter on `location_id`. The rows held at one location. An id no location carries is an empty page, not an error.
+     * @param {string} productId - Exact-match filter on `product_id`. The rows tracking one product, across every location.
+     * @param {string} sku - Exact-match filter on `sku`. The rows tracking one SKU — the identity used when an item has no product id.
+     * @param {number} onHand - Exact-match filter on `on_hand`. Exact balance, which is rarely what a reader wants: `?on_hand=0` finds the rows that are empty. There is no range filter here — GET /inventories/reorder-alerts is the "running low" question.
+     * @param {number} reserved - Exact-match filter on `reserved`. Exact reserved quantity. `?reserved=0` finds the rows nothing is holding.
+     * @param {number} reorderPoint - Exact-match filter on `reorder_point`. The available quantity at or below which this row belongs on the replenishment worklist (GET /inventories/reorder-alerts).
+     * @param {string} metadata - Exact-match filter on `metadata`. Free-form data the tenant keeps on this stock row, and ONE key this app reads: `backorder`. The WHOLE jsonb document is compared, serialized as JSON — this is equality, not a key lookup or a containment query, and a value that does not parse is answered 400.
+     * @param {string} createdAt - Exact-match filter on `created_at`. When the row was created.
+     * @param {string} updatedAt - Exact-match filter on `updated_at`. When this row was last written.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    inventoriesStockList(limit?: number, offset?: number, order?: string, id?: string, locationId?: string, productId?: string, sku?: string, onHand?: number, reserved?: number, reorderPoint?: number, metadata?: string, createdAt?: string, updatedAt?: string): Promise<Models.Error>;
+    /**
+     * Registers an item at a location. The row is born at ZERO and never gets a balance from this call: `on_hand` and `reserved` are NOT accepted, because they are the running total of the movements ledger, so an opening balance is a receipt (POST /inventories/receive) rather than a field here, and the only thing that ever moves either number afterwards is another booking. What this row carries is its identity (location + `product_id`/`sku`), its `reorder_point` and its metadata. `location_id` is the only field a create cannot omit; every other column is optional or defaulted by the database. The one rule that is a CHECK rather than a column is that a row has to identify its item, so `product_id` or `sku` has to be there as well. Mostly you do not need this route at all — every stock call creates the row it is missing — and a second row for an item this location already tracks is answered 409: no unique index enforces one row per item per location, so that row would split the item's balance across two rows the write routes cannot tell apart, each of them updating whichever the database returns first. That guard is a check before the insert and not a constraint, so it closes a double click or a re-run import and does not claim to close a race between two simultaneous creates.
+     *
+     * @param {string} params.locationId - The location this balance is held at — a `locations` row of this tenant (GET /inventories/locations). There is ONE stock row per (location, item): the same SKU in three warehouses is three rows, and what a storefront shows is their sum (POST /inventories/availability). Deleting the location deletes its stock rows with it. It has to exist already (GET /inventories/locations); an id no location carries is answered 400 by the foreign key, not 404.
+     * @param {object} params.metadata - Free-form data the tenant keeps on this stock row, and ONE key this app reads: `backorder`. A literal boolean `true` there opts this item into backorders while `backorder_policy` is 'allow_per_sku' — anything else, including the string "true", does not, and the reservation is refused with 422. That is how a merchant backorders the supplier-stocked half of a catalogue without promising the rest.
+     * @param {string} params.productId - The product this row tracks, as the products app knows it. A row tracks a `product_id` or a `sku` — the database insists on at least one (CHECK `product_id is not null or sku is not null`) — and matching is exact: a row keyed by SKU is not found by product id.
+     * @param {number} params.reorderPoint - The available quantity at or below which this row belongs on the replenishment worklist (GET /inventories/reorder-alerts). Null falls back to the `reorder_point_default` setting, so replenishment works without a threshold per SKU; 0 never alerts, which is how one row opts out.
+     * @param {string} params.sku - The article number this row tracks when there is no product id, which is the normal case for an ERP-stocked catalogue. Exact match, and the identity every stock call may use instead of a uuid.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     */
+    inventoriesStockCreate(params: {
+        locationId: string;
+        metadata?: object;
+        productId?: string;
+        reorderPoint?: number;
+        sku?: string;
+    }): Promise<Models.Error>;
+    /**
+     * Registers an item at a location. The row is born at ZERO and never gets a balance from this call: `on_hand` and `reserved` are NOT accepted, because they are the running total of the movements ledger, so an opening balance is a receipt (POST /inventories/receive) rather than a field here, and the only thing that ever moves either number afterwards is another booking. What this row carries is its identity (location + `product_id`/`sku`), its `reorder_point` and its metadata. `location_id` is the only field a create cannot omit; every other column is optional or defaulted by the database. The one rule that is a CHECK rather than a column is that a row has to identify its item, so `product_id` or `sku` has to be there as well. Mostly you do not need this route at all — every stock call creates the row it is missing — and a second row for an item this location already tracks is answered 409: no unique index enforces one row per item per location, so that row would split the item's balance across two rows the write routes cannot tell apart, each of them updating whichever the database returns first. That guard is a check before the insert and not a constraint, so it closes a double click or a re-run import and does not claim to close a race between two simultaneous creates.
+     *
+     * @param {string} locationId - The location this balance is held at — a `locations` row of this tenant (GET /inventories/locations). There is ONE stock row per (location, item): the same SKU in three warehouses is three rows, and what a storefront shows is their sum (POST /inventories/availability). Deleting the location deletes its stock rows with it. It has to exist already (GET /inventories/locations); an id no location carries is answered 400 by the foreign key, not 404.
+     * @param {object} metadata - Free-form data the tenant keeps on this stock row, and ONE key this app reads: `backorder`. A literal boolean `true` there opts this item into backorders while `backorder_policy` is 'allow_per_sku' — anything else, including the string "true", does not, and the reservation is refused with 422. That is how a merchant backorders the supplier-stocked half of a catalogue without promising the rest.
+     * @param {string} productId - The product this row tracks, as the products app knows it. A row tracks a `product_id` or a `sku` — the database insists on at least one (CHECK `product_id is not null or sku is not null`) — and matching is exact: a row keyed by SKU is not found by product id.
+     * @param {number} reorderPoint - The available quantity at or below which this row belongs on the replenishment worklist (GET /inventories/reorder-alerts). Null falls back to the `reorder_point_default` setting, so replenishment works without a threshold per SKU; 0 never alerts, which is how one row opts out.
+     * @param {string} sku - The article number this row tracks when there is no product id, which is the normal case for an ERP-stocked catalogue. Exact match, and the identity every stock call may use instead of a uuid.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    inventoriesStockCreate(locationId: string, metadata?: object, productId?: string, reorderPoint?: number, sku?: string): Promise<Models.Error>;
+    /**
+     * Stops tracking one item at one location. A stock level is ONE item at ONE location, and it carries two numbers, neither of which is the sellable one: `on_hand` is what is physically there INCLUDING everything already promised, and `reserved` is what has been promised — it never reduces `on_hand`. What may still be sold is their difference, and it is derived on read and never stored, so there is no `available` column to read, filter or order by. A deleted balance is not recoverable: the ledger is the audit trail, not the source of truth, and nothing in this app ever replays it to rebuild a number — so the next receipt for the same item here creates a FRESH row at zero, standing next to movements that say otherwise. That used to be a trap a caller discovered afterwards. It is a stated property now, because the route REFUSES while the row still holds anything, and answers 409 with what it holds. The two things that block are the location delete's two, asked of one row. A reservation still `active` against this item at this location is the sharper one: /release and /commit look their stock row up by (location, item) on the very next call and would find nothing, so the hold would lower no `reserved` and /commit would book the whole quantity as a shortfall — orphaned immediately rather than eventually. `on_hand` above zero is the stronger one: deleting a LOCATION at least meant "close this warehouse" and took the balances as a side effect of the cascade, while this row IS the balance, so the delete can only ever mean "no longer tracked here" — true once the number is zero and a lie while it is not. POST /inventories/stock/{id}/adjust to zero is the operation that makes it true, and it BOOKS the movement, so the stock leaves through the ledger instead of vanishing with the row. Nothing points at it by foreign key, so the database takes nothing else with it. History therefore never blocks and is never deleted — the ledger is keyed on (location, item) and never on this id, so its bookings survive a row that is gone, BY DESIGN, exactly as they survive a location that is gone.
+     *
+     * @param {string} params.id - The stock row.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     */
+    inventoriesStockDelete(params: {
+        id: string;
+    }): Promise<Models.Error>;
+    /**
+     * Stops tracking one item at one location. A stock level is ONE item at ONE location, and it carries two numbers, neither of which is the sellable one: `on_hand` is what is physically there INCLUDING everything already promised, and `reserved` is what has been promised — it never reduces `on_hand`. What may still be sold is their difference, and it is derived on read and never stored, so there is no `available` column to read, filter or order by. A deleted balance is not recoverable: the ledger is the audit trail, not the source of truth, and nothing in this app ever replays it to rebuild a number — so the next receipt for the same item here creates a FRESH row at zero, standing next to movements that say otherwise. That used to be a trap a caller discovered afterwards. It is a stated property now, because the route REFUSES while the row still holds anything, and answers 409 with what it holds. The two things that block are the location delete's two, asked of one row. A reservation still `active` against this item at this location is the sharper one: /release and /commit look their stock row up by (location, item) on the very next call and would find nothing, so the hold would lower no `reserved` and /commit would book the whole quantity as a shortfall — orphaned immediately rather than eventually. `on_hand` above zero is the stronger one: deleting a LOCATION at least meant "close this warehouse" and took the balances as a side effect of the cascade, while this row IS the balance, so the delete can only ever mean "no longer tracked here" — true once the number is zero and a lie while it is not. POST /inventories/stock/{id}/adjust to zero is the operation that makes it true, and it BOOKS the movement, so the stock leaves through the ledger instead of vanishing with the row. Nothing points at it by foreign key, so the database takes nothing else with it. History therefore never blocks and is never deleted — the ledger is keyed on (location, item) and never on this id, so its bookings survive a row that is gone, BY DESIGN, exactly as they survive a location that is gone.
+     *
+     * @param {string} id - The stock row.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    inventoriesStockDelete(id: string): Promise<Models.Error>;
+    /**
+     * A stock level is ONE item at ONE location, and it carries two numbers, neither of which is the sellable one: `on_hand` is what is physically there INCLUDING everything already promised, and `reserved` is what has been promised — it never reduces `on_hand`. What may still be sold is their difference, and it is derived on read and never stored, so there is no `available` column to read, filter or order by. Read it to see one item's position at one place, and to get the id the two row-scoped routes take: POST /inventories/stock/{id}/adjust corrects this balance, and GET /inventories/reorder-alerts reports it by this id. What it does not answer is how the balance got here — that is GET /inventories/movements filtered by the location and item on this row, because a movement points at (location, item) and never at a stock row id.
+     *
+     * @param {string} params.id - The stock row.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     */
+    inventoriesStockGet(params: {
+        id: string;
+    }): Promise<Models.Error>;
+    /**
+     * A stock level is ONE item at ONE location, and it carries two numbers, neither of which is the sellable one: `on_hand` is what is physically there INCLUDING everything already promised, and `reserved` is what has been promised — it never reduces `on_hand`. What may still be sold is their difference, and it is derived on read and never stored, so there is no `available` column to read, filter or order by. Read it to see one item's position at one place, and to get the id the two row-scoped routes take: POST /inventories/stock/{id}/adjust corrects this balance, and GET /inventories/reorder-alerts reports it by this id. What it does not answer is how the balance got here — that is GET /inventories/movements filtered by the location and item on this row, because a movement points at (location, item) and never at a stock row id.
+     *
+     * @param {string} id - The stock row.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    inventoriesStockGet(id: string): Promise<Models.Error>;
+    /**
+     * Partial update of everything on the row EXCEPT its balance: reorder_point, metadata, identity. on_hand and reserved are dropped from the body — every stock change is a movement, and a body carrying nothing else is answered 422 with the route that was meant (POST /inventories/stock/{id}/adjust).
+     *
+     * @param {string} params.id - The stock row.
+     * @param {string} params.locationId - The location this balance is held at — a `locations` row of this tenant (GET /inventories/locations). There is ONE stock row per (location, item): the same SKU in three warehouses is three rows, and what a storefront shows is their sum (POST /inventories/availability). Deleting the location deletes its stock rows with it. It has to exist already (GET /inventories/locations); an id no location carries is answered 400 by the foreign key, not 404.
+     * @param {object} params.metadata - Free-form data the tenant keeps on this stock row, and ONE key this app reads: `backorder`. A literal boolean `true` there opts this item into backorders while `backorder_policy` is 'allow_per_sku' — anything else, including the string "true", does not, and the reservation is refused with 422. That is how a merchant backorders the supplier-stocked half of a catalogue without promising the rest.
+     * @param {string} params.productId - The product this row tracks, as the products app knows it. A row tracks a `product_id` or a `sku` — the database insists on at least one (CHECK `product_id is not null or sku is not null`) — and matching is exact: a row keyed by SKU is not found by product id.
+     * @param {number} params.reorderPoint - The available quantity at or below which this row belongs on the replenishment worklist (GET /inventories/reorder-alerts). Null falls back to the `reorder_point_default` setting, so replenishment works without a threshold per SKU; 0 never alerts, which is how one row opts out.
+     * @param {string} params.sku - The article number this row tracks when there is no product id, which is the normal case for an ERP-stocked catalogue. Exact match, and the identity every stock call may use instead of a uuid.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     */
+    inventoriesStockUpdate(params: {
+        id: string;
+        locationId?: string;
+        metadata?: object;
+        productId?: string;
+        reorderPoint?: number;
+        sku?: string;
+    }): Promise<Models.Error>;
+    /**
+     * Partial update of everything on the row EXCEPT its balance: reorder_point, metadata, identity. on_hand and reserved are dropped from the body — every stock change is a movement, and a body carrying nothing else is answered 422 with the route that was meant (POST /inventories/stock/{id}/adjust).
+     *
+     * @param {string} id - The stock row.
+     * @param {string} locationId - The location this balance is held at — a `locations` row of this tenant (GET /inventories/locations). There is ONE stock row per (location, item): the same SKU in three warehouses is three rows, and what a storefront shows is their sum (POST /inventories/availability). Deleting the location deletes its stock rows with it. It has to exist already (GET /inventories/locations); an id no location carries is answered 400 by the foreign key, not 404.
+     * @param {object} metadata - Free-form data the tenant keeps on this stock row, and ONE key this app reads: `backorder`. A literal boolean `true` there opts this item into backorders while `backorder_policy` is 'allow_per_sku' — anything else, including the string "true", does not, and the reservation is refused with 422. That is how a merchant backorders the supplier-stocked half of a catalogue without promising the rest.
+     * @param {string} productId - The product this row tracks, as the products app knows it. A row tracks a `product_id` or a `sku` — the database insists on at least one (CHECK `product_id is not null or sku is not null`) — and matching is exact: a row keyed by SKU is not found by product id.
+     * @param {number} reorderPoint - The available quantity at or below which this row belongs on the replenishment worklist (GET /inventories/reorder-alerts). Null falls back to the `reorder_point_default` setting, so replenishment works without a threshold per SKU; 0 never alerts, which is how one row opts out.
+     * @param {string} sku - The article number this row tracks when there is no product id, which is the normal case for an ERP-stocked catalogue. Exact match, and the identity every stock call may use instead of a uuid.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    inventoriesStockUpdate(id: string, locationId?: string, metadata?: object, productId?: string, reorderPoint?: number, sku?: string): Promise<Models.Error>;
+    /**
+     * Corrects the balance of ONE stock row, and only that one. It is the row-scoped twin of POST /inventories/adjust: the row already knows its location and item, so a caller owes nothing but a SIGNED delta on `on_hand` — positive to add, negative to take away — and a reason for it. The delta is not written onto the balance either; it is booked into the movements ledger as an `adjustment` and the balance follows, which is why the answer hands back the row at its new value instead of an acknowledgement. This is the route that replaced the Cockpit's editable on_hand field.
+     *
+     * @param {string} params.id - The stock row to correct.
+     * @param {number} params.quantity - The SIGNED correction to this row's `on_hand`: −3 writes off three, +3 finds three. A delta, not the new balance. Zero is refused (400). A correction that would take `on_hand` below zero is a 422 the database insists on; one that would take it below this row's own `reserved` is a 422 the `allow_negative_stock` setting can permit.
+     * @param {string} params.reason - Why this row is being corrected, written onto the ledger booking. Owed unless `movement_reason_required` is 'none'.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     */
+    inventoriesStockAdjust(params: {
+        id: string;
+        quantity: number;
+        reason?: string;
+    }): Promise<Models.Error>;
+    /**
+     * Corrects the balance of ONE stock row, and only that one. It is the row-scoped twin of POST /inventories/adjust: the row already knows its location and item, so a caller owes nothing but a SIGNED delta on `on_hand` — positive to add, negative to take away — and a reason for it. The delta is not written onto the balance either; it is booked into the movements ledger as an `adjustment` and the balance follows, which is why the answer hands back the row at its new value instead of an acknowledgement. This is the route that replaced the Cockpit's editable on_hand field.
+     *
+     * @param {string} id - The stock row to correct.
+     * @param {number} quantity - The SIGNED correction to this row's `on_hand`: −3 writes off three, +3 finds three. A delta, not the new balance. Zero is refused (400). A correction that would take `on_hand` below zero is a 422 the database insists on; one that would take it below this row's own `reserved` is a 422 the `allow_negative_stock` setting can permit.
+     * @param {string} reason - Why this row is being corrected, written onto the ledger booking. Owed unless `movement_reason_required` is 'none'.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    inventoriesStockAdjust(id: string, quantity: number, reason?: string): Promise<Models.Error>;
+    /**
+     * Discovery for the vocabulary routes: the enums this app publishes, each with its name, its title and its description and deliberately WITHOUT its values, so finding out what exists costs one small call and not one per vocabulary. Names: location-types, movement-types, reservation-statuses. Fetch one with GET /inventories/vocabularies/{name}; a client holding the qualified pair 'inventories.<name>' builds that URL from the pair alone.
+     *
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.InventoryVocabularyIndex>}
+     */
+    inventoriesVocabulariesList(): Promise<Models.InventoryVocabularyIndex>;
+    /**
+     * One vocabulary in full: every permitted value, each carrying the title and description a person reads for it and the badge tone a UI colours it with, so a client renders a status or a movement type without a hard-coded table of its own. 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 lifecycle order for a status. 'closed' says the set is exhaustive, so a value outside it is stale data rather than a missing label. Names: location-types, movement-types, reservation-statuses.
+     *
+     * @param {InventoriesVocabulariesGetName} params.name - The vocabulary name — the part after the dot in the qualified id. One of: location-types, movement-types, reservation-statuses. Anything else is a 404, so the enum is the complete set and not a suggestion.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     */
+    inventoriesVocabulariesGet(params: {
+        name: InventoriesVocabulariesGetName;
+    }): Promise<Models.Error>;
+    /**
+     * One vocabulary in full: every permitted value, each carrying the title and description a person reads for it and the badge tone a UI colours it with, so a client renders a status or a movement type without a hard-coded table of its own. 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 lifecycle order for a status. 'closed' says the set is exhaustive, so a value outside it is stale data rather than a missing label. Names: location-types, movement-types, reservation-statuses.
+     *
+     * @param {InventoriesVocabulariesGetName} name - The vocabulary name — the part after the dot in the qualified id. One of: location-types, movement-types, reservation-statuses. Anything else is a 404, so the enum is the complete set and not a suggestion.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    inventoriesVocabulariesGet(name: InventoriesVocabulariesGetName): Promise<Models.Error>;
+}
+
+export { InventoriesStock };