@revenexx/node 0.0.2 → 0.1.0

package/dist/services/products.d.mts

@@ -1,32 +1,186 @@
 import { Client } from '../client.mjs';
 import { Models } from '../models.mjs';
+import { Kind } from '../enums/kind.mjs';
+import { ProductsKind } from '../enums/products-kind.mjs';
 import '../query.mjs';
-import '../enums/address-type.mjs';
+import '../enums/address-type-row-tone.mjs';
+import '../enums/address-type-row-create-request-tone.mjs';
+import '../enums/address-type-row-update-request-tone.mjs';
+import '../enums/assets-source.mjs';
+import '../enums/attribute-value-bucket.mjs';
+import '../enums/auth-mail-source.mjs';
+import '../enums/recovery-mail-source.mjs';
+import '../enums/registration-status.mjs';
+import '../enums/budget-change-reason.mjs';
+import '../enums/budget-movement-result-status.mjs';
+import '../enums/cart-status.mjs';
+import '../enums/cart-merge-strategy.mjs';
+import '../enums/cart-price-snapshot-mode.mjs';
+import '../enums/cart-io-format.mjs';
 import '../enums/cart-export-format.mjs';
 import '../enums/cart-item-type.mjs';
+import '../enums/cart-vocabulary-tone.mjs';
+import '../enums/cart-vocabulary-name.mjs';
+import '../enums/cart-vocabulary-source.mjs';
+import '../enums/cart-vocabulary-ref-name.mjs';
+import '../enums/categories-rule-match.mjs';
+import '../enums/category-rule-operator.mjs';
+import '../enums/category-rule-match.mjs';
 import '../enums/channel-status.mjs';
-import '../enums/channel-type.mjs';
-import '../enums/contact-role.mjs';
+import '../enums/channel-unassigned-visibility.mjs';
+import '../enums/channel-unresolved-reason.mjs';
+import '../enums/channel-context-source.mjs';
+import '../enums/channel-inactive-behavior.mjs';
+import '../enums/channel-policy-source.mjs';
+import '../enums/channel-policy-tenant-default.mjs';
+import '../enums/channel-unassigned-policy.mjs';
+import '../enums/channel-type-tone.mjs';
+import '../enums/channel-visibility-reason.mjs';
+import '../enums/channel-vocabulary-tone.mjs';
+import '../enums/channel-vocabulary-name.mjs';
+import '../enums/channel-vocabulary-source.mjs';
+import '../enums/channel-vocabulary-ref-name.mjs';
+import '../enums/contact-registration-status.mjs';
 import '../enums/contact-status.mjs';
+import '../enums/contact-activity-kind.mjs';
+import '../enums/contact-create-request-registration-status.mjs';
+import '../enums/contact-event-kind-tone.mjs';
+import '../enums/contact-event-kind-create-request-tone.mjs';
+import '../enums/contact-event-kind-update-request-tone.mjs';
+import '../enums/contact-update-request-registration-status.mjs';
+import '../enums/cost-center-budget-type.mjs';
+import '../enums/cost-center-restriction-type.mjs';
+import '../enums/cost-center-restriction-create-request-type.mjs';
+import '../enums/cost-center-restriction-update-request-type.mjs';
+import '../enums/payment-fee-type.mjs';
+import '../enums/payment-method-kind.mjs';
+import '../enums/form-status.mjs';
+import '../enums/form-submission-status.mjs';
+import '../enums/form-notify-source.mjs';
+import '../enums/form-submission-prune-request-status.mjs';
+import '../enums/forms-vocabulary-tone.mjs';
+import '../enums/forms-vocabulary-name.mjs';
+import '../enums/forms-vocabulary-summary-name.mjs';
+import '../enums/inventory-vocabulary-default-tone.mjs';
+import '../enums/inventory-vocabulary-source.mjs';
 import '../enums/cart-io-apply-mode.mjs';
 import '../enums/cart-io-direction.mjs';
 import '../enums/cart-io-entity.mjs';
-import '../enums/cart-io-format.mjs';
+import '../enums/io-profile-resource-apply-mode.mjs';
+import '../enums/io-profile-resource-direction.mjs';
+import '../enums/lifecycle-stage-tone.mjs';
+import '../enums/lifecycle-stage-create-request-tone.mjs';
+import '../enums/lifecycle-stage-update-request-tone.mjs';
 import '../enums/location-type.mjs';
 import '../enums/market-status.mjs';
+import '../enums/market-default-locale-source.mjs';
+import '../enums/market-locale-fallback.mjs';
+import '../enums/market-locale-granularity.mjs';
+import '../enums/market-pricing-source.mjs';
+import '../enums/market-tax-basis.mjs';
+import '../enums/market-readiness-check-id.mjs';
+import '../enums/market-readiness-severity.mjs';
+import '../enums/markets-vocabulary-tone.mjs';
+import '../enums/markets-vocabulary-name.mjs';
+import '../enums/markets-vocabulary-source.mjs';
+import '../enums/markets-vocabulary-summary-name.mjs';
+import '../enums/order-fulfillment-status.mjs';
+import '../enums/order-payment-status.mjs';
+import '../enums/order-status.mjs';
+import '../enums/order-cancellation-scope.mjs';
 import '../enums/order-comment-visibility.mjs';
 import '../enums/order-item-type.mjs';
-import '../enums/order-list-kind.mjs';
-import '../enums/order-payment-status.mjs';
+import '../enums/order-list-kind-tone.mjs';
+import '../enums/order-list-kind-row-tone.mjs';
+import '../enums/order-list-cart-mode.mjs';
+import '../enums/order-list-vocabulary-default-tone.mjs';
+import '../enums/order-list-vocabulary-name.mjs';
+import '../enums/order-list-vocabulary-source.mjs';
+import '../enums/order-list-vocabulary-tone.mjs';
+import '../enums/order-return-status.mjs';
+import '../enums/order-return-settlement.mjs';
+import '../enums/order-return-refusal.mjs';
+import '../enums/order-vocabulary-tone.mjs';
+import '../enums/order-vocabulary-name.mjs';
+import '../enums/order-vocabulary-source.mjs';
+import '../enums/order-vocabulary-summary-name.mjs';
+import '../enums/order-resolution-stage.mjs';
 import '../enums/organization-status.mjs';
 import '../enums/page-status.mjs';
-import '../enums/payment-fee-type.mjs';
-import '../enums/payment-method-kind.mjs';
+import '../enums/pages-vocabulary-app.mjs';
+import '../enums/pages-vocabulary-tone.mjs';
+import '../enums/pages-vocabulary-name.mjs';
+import '../enums/pages-vocabulary-source.mjs';
+import '../enums/pages-vocabulary-index-app.mjs';
+import '../enums/payment-dunning-stage.mjs';
+import '../enums/payment-failure-code.mjs';
+import '../enums/payment-status.mjs';
+import '../enums/payment-term-tone.mjs';
+import '../enums/payment-term-create-request-tone.mjs';
+import '../enums/payment-term-update-request-tone.mjs';
+import '../enums/payment-vocabulary-tone.mjs';
+import '../enums/price-ending-rule.mjs';
+import '../enums/price-entries-adjust-response-rounding.mjs';
+import '../enums/price-entries-adjust-response-rounding-mode.mjs';
+import '../enums/price-entries-bulk-mode.mjs';
+import '../enums/price-rounding-mode.mjs';
 import '../enums/price-entry-type.mjs';
 import '../enums/price-list-status.mjs';
+import '../enums/price-list-tax-basis.mjs';
+import '../enums/price-currency-source.mjs';
+import '../enums/price-list-tiebreak.mjs';
+import '../enums/price-tax-inclusive-default.mjs';
+import '../enums/price-tax-unresolved-reason.mjs';
+import '../enums/price-tax-market-source.mjs';
+import '../enums/price-vocabulary-tone.mjs';
+import '../enums/price-vocabulary-name.mjs';
+import '../enums/price-vocabulary-source.mjs';
+import '../enums/price-vocabulary-ref-name.mjs';
+import '../enums/product-categories-source.mjs';
+import '../enums/product-grid-column-source.mjs';
+import '../enums/product-label-source.mjs';
+import '../enums/product-label-attribute-source.mjs';
+import '../enums/reorder-point-source.mjs';
+import '../enums/reservation-status.mjs';
+import '../enums/price-on-request-reason.mjs';
+import '../enums/price-tax-basis.mjs';
+import '../enums/price-tax-basis-source.mjs';
+import '../enums/role-catalog-response-source.mjs';
+import '../enums/segment-rule-match.mjs';
+import '../enums/segment-member-source.mjs';
+import '../enums/segment-rule-operator.mjs';
+import '../enums/segment-rule-preview-request-rule-match.mjs';
+import '../enums/segment-rule-preview-request-target.mjs';
+import '../enums/segment-rule-preview-response-rule-match.mjs';
+import '../enums/segment-rule-preview-response-target.mjs';
+import '../enums/segment-rules-target.mjs';
+import '../enums/shipping-carrier-status.mjs';
 import '../enums/shipping-method-matrix-basis.mjs';
 import '../enums/shipping-method-pricing-type.mjs';
+import '../enums/shipping-carrier-source.mjs';
+import '../enums/shipping-rate-pricing-type.mjs';
+import '../enums/shipping-tax-source.mjs';
+import '../enums/shipping-free-above-basis.mjs';
+import '../enums/shipping-rates-basis-matrix-basis-default.mjs';
+import '../enums/shipping-service-level-create-request-tone.mjs';
+import '../enums/shipping-service-level-row-tone.mjs';
+import '../enums/shipping-service-level-update-request-tone.mjs';
+import '../enums/shipping-tax-unresolved-reason.mjs';
+import '../enums/shipping-tax-market-source.mjs';
+import '../enums/shipping-tax-context-via.mjs';
+import '../enums/shipping-tracking-carrier-status.mjs';
+import '../enums/shipping-vocabulary-default-tone.mjs';
+import '../enums/shipping-vocabulary-source.mjs';
+import '../enums/shipping-vocabulary-tone.mjs';
+import '../enums/shipping-weight-unit-create-request-tone.mjs';
+import '../enums/shipping-weight-unit-row-tone.mjs';
+import '../enums/shipping-weight-unit-update-request-tone.mjs';
+import '../enums/stock-movement-type.mjs';
 import '../enums/store-asset-request-visibility.mjs';
+import '../enums/validation-failed-response-status.mjs';
+import '../enums/vocabulary-default-tone.mjs';
+import '../enums/vocabulary-source.mjs';
+import '../enums/vocabulary-tone.mjs';
 import '../enums/attribute-boolean-status.mjs';
 import '../enums/attribute-datetime-status.mjs';
 import '../enums/attribute-email-status.mjs';
@@ -68,49 +222,126 @@ import '../enums/execution-trigger.mjs';
 import '../enums/health-antivirus-status.mjs';
 import '../enums/health-status-status.mjs';
 import '../enums/index-status.mjs';
-import '../enums/message-status.mjs';
+import '../enums/message-2-status.mjs';
 
 declare class Products {
     client: Client;
     constructor(client: Client);
     /**
-     *
-     * @param {number} params.limit - Page size (default 50, max 200).
-     * @param {number} params.offset - Row offset for pagination (default 0).
-     * @param {string} params.order - Sort as 'column.asc' | 'column.desc', e.g. 'created_at.desc'.
-     * @throws {RevenexxAPIRevenexxException}
+     * The catalog itself. A product row carries only what every product has — SKU, kind, family, enabled, tax class — and everything the tenant modelled lives in the `attribute_values` jsonb document, keyed by attribute CODE inside one of four scope buckets (common, per locale, per channel, per channel and locale). `label` is a generated column, maintained by the database so a grid of twenty thousand rows can sort and filter on a name with no join. `kind` says where the row sits in the variant hierarchy: a `model` carries what its variants share and is never sold itself.
+     *
+     * Every column of `products` is an exact-match query parameter, `order` sorts by one column, and `limit`/`offset` page through `page.total`. A query key that is NOT a column is dropped rather than refused, and the `filter` object echoes the ones that were understood — that echo is the only way to tell an unfiltered answer from an empty one. It reads rows exactly as they are stored: no join is resolved, no jsonb value is unpacked, and soft-deleted products are included — filter on `deleted_at` to read the live catalog, or use `GET /products/grid`, which excludes them.
+     *
+     * @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. Anything else is refused with 400.
+     * @param {string} params.id - Exact match on `id`. The row's own id, generated by the database. A client never sends one; it reads one back and uses it in the path of every later call.
+     * @param {string} params.sku - Exact match on `sku`. The merchant's own article number — unique per tenant, and the value every integration (ERP, shop, feed, price list) joins on. The one identifier a person types, and the fallback this app shows when the catalog holds no name.
+     * @param {Kind} params.kind - Exact match on `kind`. Where the product sits in the variant hierarchy. 'simple' stands on its own. 'model' carries the values its variants share and is never sold itself. 'variant' carries the axis values and points at its model through `parent_id`.
+     * @param {string} params.parentId - Exact match on `parent_id`. The product MODEL this variant belongs to. Only a `variant` carries one. Deleting the model leaves its variants behind with a null parent rather than deleting them.
+     * @param {string} params.familyId - Exact match on `family_id`. The family that decides which attributes this product HAS. Without one nothing is required, completeness cannot be computed and the display name never resolves — `POST /products/{id}/family` is the call that sets it and computes completeness in the same step.
+     * @param {string} params.familyVariantId - Exact match on `family_variant_id`. Which variant structure of the family this product follows — the axes it splits on. Null on a simple product.
+     * @param {boolean} params.enabled - Exact match on `enabled`. Whether the product is offered. A create defaults it from the `new_products_enabled_by_default` tenant setting rather than blindly to true, so an import does not publish twenty thousand unfinished products the moment it lands. An explicit value in the body always wins.
+     * @param {string} params.taxClass - Exact match on `tax_class`. The tax class key the prices app resolves a VAT rate from. Free text here — the vocabulary belongs to the app that prices, and `POST /products/batch` exists to hand exactly this column to it in bulk.
+     * @param {string} params.attributeValues - Exact match on `attribute_values`. Every attribute value the record carries, in ONE jsonb document — the core of an attribute-driven PIM. A record's properties are not columns here: they are rows in `attributes`, selected per family by `family_attributes`, and their values live under their attribute CODE inside this object. The whole jsonb document is compared, serialized as JSON — this is equality, not a path or containment query, and `null` cannot be matched this way. A value that does not parse as JSON is refused with 400 `invalid_value`, naming this filter, before the request reaches the data plane.
+     * @param {string} params.label - Exact match on `label`. The display name, maintained by the DATABASE so a grid of twenty thousand rows can sort and filter on a name with no join. It is the first of `attribute_values.common.name`, `…common.label`, the `de`/`en`/`de_DE`/`en_US` locale buckets, `…common.manufacturer_aid`, and finally the SKU — so a value is ALWAYS present, and a label equal to the SKU means the catalog holds no name for this product. A generated column: it cannot be written, and a create or update that names it has it dropped rather than refused. The family-aware answer, which can consult `families.label_attribute` and report where the name came from, is `POST /products/labels`.
+     * @param {string} params.quantifiedAssociations - Exact match on `quantified_associations`. The import-side mirror of associations that carry a quantity — a bundle, a bill of materials, a spare-parts set. NOTHING IN THIS APP READS OR WRITES IT: no route produces it, no route consumes it, and it is null on every product this app has created. The surface that IS served is relational — `product_associations`, whose `quantity` column holds the number, guarded by `association_types.is_quantified`. The whole jsonb document is compared, serialized as JSON — this is equality, not a path or containment query, and `null` cannot be matched this way. A value that does not parse as JSON is refused with 400 `invalid_value`, naming this filter, before the request reaches the data plane.
+     * @param {string} params.completeness - Exact match on `completeness`. How much of what this product's family REQUIRES it actually carries — the number a merchandiser works down. `required` counts the attributes the family marks `is_required`, `filled` how many of those carry a value in ANY bucket, `ratio` is filled/required between 0 and 1 (a family that requires nothing is 1, not undefined), `missing` lists the codes with no value anywhere, sorted, and `computed_at` is when it was measured. The whole jsonb document is compared, serialized as JSON — this is equality, not a path or containment query, and `null` cannot be matched this way. A value that does not parse as JSON is refused with 400 `invalid_value`, naming this filter, before the request reaches the data plane.
+     * @param {string} params.createdAt - Exact match on `created_at`. When the row was created. Server-set — it is not part of any request body.
+     * @param {string} params.updatedAt - Exact match on `updated_at`. When the row was last written. Server-set — it is not part of any request body.
+     * @param {string} params.deletedAt - Exact match on `deleted_at`. When the product was soft-deleted. `GET /products/grid` and every category-rule evaluation exclude a row that carries one; `GET /products` does NOT — filter on it to read the live catalog.
+     * @throws {RevenexxException}
      * @returns {Promise<{}>}
      */
     productsList(params?: {
         limit?: number;
         offset?: number;
         order?: string;
+        id?: string;
+        sku?: string;
+        kind?: Kind;
+        parentId?: string;
+        familyId?: string;
+        familyVariantId?: string;
+        enabled?: boolean;
+        taxClass?: string;
+        attributeValues?: string;
+        label?: string;
+        quantifiedAssociations?: string;
+        completeness?: string;
+        createdAt?: string;
+        updatedAt?: string;
+        deletedAt?: string;
     }): Promise<{}>;
     /**
+     * The catalog itself. A product row carries only what every product has — SKU, kind, family, enabled, tax class — and everything the tenant modelled lives in the `attribute_values` jsonb document, keyed by attribute CODE inside one of four scope buckets (common, per locale, per channel, per channel and locale). `label` is a generated column, maintained by the database so a grid of twenty thousand rows can sort and filter on a name with no join. `kind` says where the row sits in the variant hierarchy: a `model` carries what its variants share and is never sold itself.
      *
-     * @param {number} limit - Page size (default 50, max 200).
-     * @param {number} offset - Row offset for pagination (default 0).
-     * @param {string} order - Sort as 'column.asc' | 'column.desc', e.g. 'created_at.desc'.
-     * @throws {RevenexxAPIRevenexxException}
+     * Every column of `products` is an exact-match query parameter, `order` sorts by one column, and `limit`/`offset` page through `page.total`. A query key that is NOT a column is dropped rather than refused, and the `filter` object echoes the ones that were understood — that echo is the only way to tell an unfiltered answer from an empty one. It reads rows exactly as they are stored: no join is resolved, no jsonb value is unpacked, and soft-deleted products are included — filter on `deleted_at` to read the live catalog, or use `GET /products/grid`, which excludes them.
+     *
+     * @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. Anything else is refused with 400.
+     * @param {string} id - Exact match on `id`. The row's own id, generated by the database. A client never sends one; it reads one back and uses it in the path of every later call.
+     * @param {string} sku - Exact match on `sku`. The merchant's own article number — unique per tenant, and the value every integration (ERP, shop, feed, price list) joins on. The one identifier a person types, and the fallback this app shows when the catalog holds no name.
+     * @param {Kind} kind - Exact match on `kind`. Where the product sits in the variant hierarchy. 'simple' stands on its own. 'model' carries the values its variants share and is never sold itself. 'variant' carries the axis values and points at its model through `parent_id`.
+     * @param {string} parentId - Exact match on `parent_id`. The product MODEL this variant belongs to. Only a `variant` carries one. Deleting the model leaves its variants behind with a null parent rather than deleting them.
+     * @param {string} familyId - Exact match on `family_id`. The family that decides which attributes this product HAS. Without one nothing is required, completeness cannot be computed and the display name never resolves — `POST /products/{id}/family` is the call that sets it and computes completeness in the same step.
+     * @param {string} familyVariantId - Exact match on `family_variant_id`. Which variant structure of the family this product follows — the axes it splits on. Null on a simple product.
+     * @param {boolean} enabled - Exact match on `enabled`. Whether the product is offered. A create defaults it from the `new_products_enabled_by_default` tenant setting rather than blindly to true, so an import does not publish twenty thousand unfinished products the moment it lands. An explicit value in the body always wins.
+     * @param {string} taxClass - Exact match on `tax_class`. The tax class key the prices app resolves a VAT rate from. Free text here — the vocabulary belongs to the app that prices, and `POST /products/batch` exists to hand exactly this column to it in bulk.
+     * @param {string} attributeValues - Exact match on `attribute_values`. Every attribute value the record carries, in ONE jsonb document — the core of an attribute-driven PIM. A record's properties are not columns here: they are rows in `attributes`, selected per family by `family_attributes`, and their values live under their attribute CODE inside this object. The whole jsonb document is compared, serialized as JSON — this is equality, not a path or containment query, and `null` cannot be matched this way. A value that does not parse as JSON is refused with 400 `invalid_value`, naming this filter, before the request reaches the data plane.
+     * @param {string} label - Exact match on `label`. The display name, maintained by the DATABASE so a grid of twenty thousand rows can sort and filter on a name with no join. It is the first of `attribute_values.common.name`, `…common.label`, the `de`/`en`/`de_DE`/`en_US` locale buckets, `…common.manufacturer_aid`, and finally the SKU — so a value is ALWAYS present, and a label equal to the SKU means the catalog holds no name for this product. A generated column: it cannot be written, and a create or update that names it has it dropped rather than refused. The family-aware answer, which can consult `families.label_attribute` and report where the name came from, is `POST /products/labels`.
+     * @param {string} quantifiedAssociations - Exact match on `quantified_associations`. The import-side mirror of associations that carry a quantity — a bundle, a bill of materials, a spare-parts set. NOTHING IN THIS APP READS OR WRITES IT: no route produces it, no route consumes it, and it is null on every product this app has created. The surface that IS served is relational — `product_associations`, whose `quantity` column holds the number, guarded by `association_types.is_quantified`. The whole jsonb document is compared, serialized as JSON — this is equality, not a path or containment query, and `null` cannot be matched this way. A value that does not parse as JSON is refused with 400 `invalid_value`, naming this filter, before the request reaches the data plane.
+     * @param {string} completeness - Exact match on `completeness`. How much of what this product's family REQUIRES it actually carries — the number a merchandiser works down. `required` counts the attributes the family marks `is_required`, `filled` how many of those carry a value in ANY bucket, `ratio` is filled/required between 0 and 1 (a family that requires nothing is 1, not undefined), `missing` lists the codes with no value anywhere, sorted, and `computed_at` is when it was measured. The whole jsonb document is compared, serialized as JSON — this is equality, not a path or containment query, and `null` cannot be matched this way. A value that does not parse as JSON is refused with 400 `invalid_value`, naming this filter, before the request reaches the data plane.
+     * @param {string} createdAt - Exact match on `created_at`. When the row was created. Server-set — it is not part of any request body.
+     * @param {string} updatedAt - Exact match on `updated_at`. When the row was last written. Server-set — it is not part of any request body.
+     * @param {string} deletedAt - Exact match on `deleted_at`. When the product was soft-deleted. `GET /products/grid` and every category-rule evaluation exclude a row that carries one; `GET /products` does NOT — filter on it to read the live catalog.
+     * @throws {RevenexxException}
      * @returns {Promise<{}>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    productsList(limit?: number, offset?: number, order?: string): Promise<{}>;
+    productsList(limit?: number, offset?: number, order?: string, id?: string, sku?: string, kind?: Kind, parentId?: string, familyId?: string, familyVariantId?: string, enabled?: boolean, taxClass?: string, attributeValues?: string, label?: string, quantifiedAssociations?: string, completeness?: string, createdAt?: string, updatedAt?: string, deletedAt?: string): Promise<{}>;
     /**
+     * Creates one product and answers 201 with the stored row, including the id and the timestamps the database filled in — a client never sends an id, it reads one back and uses it in the path of every later call.
+     *
+     * The catalog itself. A product row carries only what every product has — SKU, kind, family, enabled, tax class — and everything the tenant modelled lives in the `attribute_values` jsonb document, keyed by attribute CODE inside one of four scope buckets (common, per locale, per channel, per channel and locale). `label` is a generated column, maintained by the database so a grid of twenty thousand rows can sort and filter on a name with no join. `kind` says where the row sits in the variant hierarchy: a `model` carries what its variants share and is never sold itself.
      *
-     * @param {string} params.sku -
-     * @param {object} params.attributeValues -
-     * @param {object} params.completeness -
-     * @param {string} params.deletedAt -
-     * @param {boolean} params.enabled -
-     * @param {string} params.familyId -
-     * @param {string} params.familyVariantId -
-     * @param {string} params.kind -
-     * @param {string} params.parentId -
-     * @param {object} params.quantifiedAssociations -
-     * @param {string} params.taxClass -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.Products>}
+     * `sku` is the only column the database refuses the row without; everything else has a default or is nullable. A second row with the same `sku` answers 409. This app owns the create: `enabled` defaults from the `new_products_enabled_by_default` tenant setting rather than blindly to true, so an import cannot publish twenty thousand unfinished products the moment it lands, and a product that names no family gets the `default_product_family` one. An explicit value in the body always wins over both.
+     *
+     * @param {string} params.sku - The merchant's own article number — unique per tenant, and the value every integration (ERP, shop, feed, price list) joins on. The one identifier a person types, and the fallback this app shows when the catalog holds no name.
+     * @param {object} params.attributeValues - Every attribute value the record carries, in ONE jsonb document — the core of an attribute-driven PIM. A record's properties are not columns here: they are rows in `attributes`, selected per family by `family_attributes`, and their values live under their attribute CODE inside this object.
+
+Four buckets, and an attribute's own flags decide which one it writes to:
+
+  `common`                    the attribute is neither localizable nor scopable — one value, full stop.
+                              `{"common": {"net_weight": 2.4, "colour": "black"}}`
+  `locale_specific`           `localizable`: one value per language tag.
+                              `{"locale_specific": {"de_DE": {"name": "Akku-Bohrschrauber"}}}`
+  `channel_specific`          `scopable`: one value per channel.
+                              `{"channel_specific": {"b2b": {"minimum_order_quantity": 6}}}`
+  `channel_locale_specific`   both: one value per channel AND language tag.
+                              `{"channel_locale_specific": {"b2b": {"de_DE": {"description": "…"}}}}`
+
+A reader takes the most specific bucket that carries the code and falls back through locale, then channel, then `common`. `common` is always last and always consulted, because early imports wrote everything there whatever an attribute's flags said — a reader that skipped it reports an imported catalog as empty. `GET /products/attribute-schema` answers, per field, the exact path a value belongs at (`storage.path`) and that full fallback order (`from`), so no client has to re-derive any of this.
+
+The value itself is whatever the attribute's `type` implies: a string, a number, a boolean, an option CODE for a select (never its label), a list of codes for a multi-select, `{"amount": …, "unit": …}` for a measure, a list of `{"amount": …, "currency": …}` for a price, an asset code for media.
+
+Defaults to `{}`, and an empty object is a normal state — a record nobody has enriched yet. The declared type also admits an array only because every jsonb column of this app shares one mapping; an array is not meaningful here and every reader in this app treats a non-object as empty.
+     * @param {object} params.completeness - How much of what this product's family REQUIRES it actually carries — the number a merchandiser works down. `required` counts the attributes the family marks `is_required`, `filled` how many of those carry a value in ANY bucket, `ratio` is filled/required between 0 and 1 (a family that requires nothing is 1, not undefined), `missing` lists the codes with no value anywhere, sorted, and `computed_at` is when it was measured.
+
+Written only by `POST /products/{id}/completeness` and by `POST /products/{id}/family`; a plain create or update never touches it, so it is null until one of the two has run. It also stays null for a product with no family — there is nothing to measure it against, and 0 % would be a lie.
+     * @param {string} params.deletedAt - When the product was soft-deleted. `GET /products/grid` and every category-rule evaluation exclude a row that carries one; `GET /products` does NOT — filter on it to read the live catalog.
+     * @param {boolean} params.enabled - Whether the product is offered. A create defaults it from the `new_products_enabled_by_default` tenant setting rather than blindly to true, so an import does not publish twenty thousand unfinished products the moment it lands. An explicit value in the body always wins.
+     * @param {string} params.familyId - The family that decides which attributes this product HAS. Without one nothing is required, completeness cannot be computed and the display name never resolves — `POST /products/{id}/family` is the call that sets it and computes completeness in the same step.
+     * @param {string} params.familyVariantId - Which variant structure of the family this product follows — the axes it splits on. Null on a simple product.
+     * @param {ProductsKind} params.kind - Where the product sits in the variant hierarchy. 'simple' stands on its own. 'model' carries the values its variants share and is never sold itself. 'variant' carries the axis values and points at its model through `parent_id`.
+     * @param {string} params.parentId - The product MODEL this variant belongs to. Only a `variant` carries one. Deleting the model leaves its variants behind with a null parent rather than deleting them.
+     * @param {object} params.quantifiedAssociations - The import-side mirror of associations that carry a quantity — a bundle, a bill of materials, a spare-parts set. NOTHING IN THIS APP READS OR WRITES IT: no route produces it, no route consumes it, and it is null on every product this app has created. The surface that IS served is relational — `product_associations`, whose `quantity` column holds the number, guarded by `association_types.is_quantified`.
+
+It exists because a PIM import (Akeneo, BMEcat) carries these in one blob keyed by association type code, and the column lets that document round-trip instead of being dropped. The database enforces no shape on it, so what a reader finds is whatever the importer wrote; the example is the conventional form.
+     * @param {string} params.taxClass - The tax class key the prices app resolves a VAT rate from. Free text here — the vocabulary belongs to the app that prices, and `POST /products/batch` exists to hand exactly this column to it in bulk.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
      */
     productsCreate(params: {
         sku: string;
@@ -120,1879 +351,572 @@ declare class Products {
         enabled?: boolean;
         familyId?: string;
         familyVariantId?: string;
-        kind?: string;
+        kind?: ProductsKind;
         parentId?: string;
         quantifiedAssociations?: object;
         taxClass?: string;
-    }): Promise<Models.Products>;
+    }): Promise<Models.Error>;
     /**
+     * Creates one product and answers 201 with the stored row, including the id and the timestamps the database filled in — a client never sends an id, it reads one back and uses it in the path of every later call.
      *
-     * @param {string} sku -
-     * @param {object} attributeValues -
-     * @param {object} completeness -
-     * @param {string} deletedAt -
-     * @param {boolean} enabled -
-     * @param {string} familyId -
-     * @param {string} familyVariantId -
-     * @param {string} kind -
-     * @param {string} parentId -
-     * @param {object} quantifiedAssociations -
-     * @param {string} taxClass -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.Products>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsCreate(sku: string, attributeValues?: object, completeness?: object, deletedAt?: string, enabled?: boolean, familyId?: string, familyVariantId?: string, kind?: string, parentId?: string, quantifiedAssociations?: object, taxClass?: string): Promise<Models.Products>;
-    /**
+     * The catalog itself. A product row carries only what every product has — SKU, kind, family, enabled, tax class — and everything the tenant modelled lives in the `attribute_values` jsonb document, keyed by attribute CODE inside one of four scope buckets (common, per locale, per channel, per channel and locale). `label` is a generated column, maintained by the database so a grid of twenty thousand rows can sort and filter on a name with no join. `kind` says where the row sits in the variant hierarchy: a `model` carries what its variants share and is never sold itself.
      *
-     * @param {number} params.limit - Page size (default 50, max 200).
-     * @param {number} params.offset - Row offset for pagination (default 0).
-     * @param {string} params.order - Sort as 'column.asc' | 'column.desc', e.g. 'created_at.desc'.
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     */
-    productsAssetFamiliesList(params?: {
-        limit?: number;
-        offset?: number;
-        order?: string;
-    }): Promise<{}>;
-    /**
+     * `sku` is the only column the database refuses the row without; everything else has a default or is nullable. A second row with the same `sku` answers 409. This app owns the create: `enabled` defaults from the `new_products_enabled_by_default` tenant setting rather than blindly to true, so an import cannot publish twenty thousand unfinished products the moment it lands, and a product that names no family gets the `default_product_family` one. An explicit value in the body always wins over both.
      *
-     * @param {number} limit - Page size (default 50, max 200).
-     * @param {number} offset - Row offset for pagination (default 0).
-     * @param {string} order - Sort as 'column.asc' | 'column.desc', e.g. 'created_at.desc'.
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
+     * @param {string} sku - The merchant's own article number — unique per tenant, and the value every integration (ERP, shop, feed, price list) joins on. The one identifier a person types, and the fallback this app shows when the catalog holds no name.
+     * @param {object} attributeValues - Every attribute value the record carries, in ONE jsonb document — the core of an attribute-driven PIM. A record's properties are not columns here: they are rows in `attributes`, selected per family by `family_attributes`, and their values live under their attribute CODE inside this object.
+
+Four buckets, and an attribute's own flags decide which one it writes to:
+
+  `common`                    the attribute is neither localizable nor scopable — one value, full stop.
+                              `{"common": {"net_weight": 2.4, "colour": "black"}}`
+  `locale_specific`           `localizable`: one value per language tag.
+                              `{"locale_specific": {"de_DE": {"name": "Akku-Bohrschrauber"}}}`
+  `channel_specific`          `scopable`: one value per channel.
+                              `{"channel_specific": {"b2b": {"minimum_order_quantity": 6}}}`
+  `channel_locale_specific`   both: one value per channel AND language tag.
+                              `{"channel_locale_specific": {"b2b": {"de_DE": {"description": "…"}}}}`
+
+A reader takes the most specific bucket that carries the code and falls back through locale, then channel, then `common`. `common` is always last and always consulted, because early imports wrote everything there whatever an attribute's flags said — a reader that skipped it reports an imported catalog as empty. `GET /products/attribute-schema` answers, per field, the exact path a value belongs at (`storage.path`) and that full fallback order (`from`), so no client has to re-derive any of this.
+
+The value itself is whatever the attribute's `type` implies: a string, a number, a boolean, an option CODE for a select (never its label), a list of codes for a multi-select, `{"amount": …, "unit": …}` for a measure, a list of `{"amount": …, "currency": …}` for a price, an asset code for media.
+
+Defaults to `{}`, and an empty object is a normal state — a record nobody has enriched yet. The declared type also admits an array only because every jsonb column of this app shares one mapping; an array is not meaningful here and every reader in this app treats a non-object as empty.
+     * @param {object} completeness - How much of what this product's family REQUIRES it actually carries — the number a merchandiser works down. `required` counts the attributes the family marks `is_required`, `filled` how many of those carry a value in ANY bucket, `ratio` is filled/required between 0 and 1 (a family that requires nothing is 1, not undefined), `missing` lists the codes with no value anywhere, sorted, and `computed_at` is when it was measured.
+
+Written only by `POST /products/{id}/completeness` and by `POST /products/{id}/family`; a plain create or update never touches it, so it is null until one of the two has run. It also stays null for a product with no family — there is nothing to measure it against, and 0 % would be a lie.
+     * @param {string} deletedAt - When the product was soft-deleted. `GET /products/grid` and every category-rule evaluation exclude a row that carries one; `GET /products` does NOT — filter on it to read the live catalog.
+     * @param {boolean} enabled - Whether the product is offered. A create defaults it from the `new_products_enabled_by_default` tenant setting rather than blindly to true, so an import does not publish twenty thousand unfinished products the moment it lands. An explicit value in the body always wins.
+     * @param {string} familyId - The family that decides which attributes this product HAS. Without one nothing is required, completeness cannot be computed and the display name never resolves — `POST /products/{id}/family` is the call that sets it and computes completeness in the same step.
+     * @param {string} familyVariantId - Which variant structure of the family this product follows — the axes it splits on. Null on a simple product.
+     * @param {ProductsKind} kind - Where the product sits in the variant hierarchy. 'simple' stands on its own. 'model' carries the values its variants share and is never sold itself. 'variant' carries the axis values and points at its model through `parent_id`.
+     * @param {string} parentId - The product MODEL this variant belongs to. Only a `variant` carries one. Deleting the model leaves its variants behind with a null parent rather than deleting them.
+     * @param {object} quantifiedAssociations - The import-side mirror of associations that carry a quantity — a bundle, a bill of materials, a spare-parts set. NOTHING IN THIS APP READS OR WRITES IT: no route produces it, no route consumes it, and it is null on every product this app has created. The surface that IS served is relational — `product_associations`, whose `quantity` column holds the number, guarded by `association_types.is_quantified`.
+
+It exists because a PIM import (Akeneo, BMEcat) carries these in one blob keyed by association type code, and the column lets that document round-trip instead of being dropped. The database enforces no shape on it, so what a reader finds is whatever the importer wrote; the example is the conventional form.
+     * @param {string} taxClass - The tax class key the prices app resolves a VAT rate from. Free text here — the vocabulary belongs to the app that prices, and `POST /products/batch` exists to hand exactly this column to it in bulk.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    productsAssetFamiliesList(limit?: number, offset?: number, order?: string): Promise<{}>;
+    productsCreate(sku: string, attributeValues?: object, completeness?: object, deletedAt?: string, enabled?: boolean, familyId?: string, familyVariantId?: string, kind?: ProductsKind, parentId?: string, quantifiedAssociations?: object, taxClass?: string): Promise<Models.Error>;
     /**
+     * Answers four fields — id, sku, tax_class and the resolved display name — for a list of ids and/or SKUs in ONE call. It exists for the app on the other side of a product reference: the prices app holds SKUs and needs a tax class, a feed builder holds ids and needs names, and neither should page through the catalog or fire a request per line. Ask by either identifier or both; the two are unioned and a product named twice comes back once.
      *
-     * @param {string} params.code -
-     * @param {object} params.labels -
-     * @param {object} params.namingConvention -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.AssetFamilies>}
-     */
-    productsAssetFamiliesCreate(params: {
-        code: string;
-        labels?: object;
-        namingConvention?: object;
-    }): Promise<Models.AssetFamilies>;
-    /**
-     *
-     * @param {string} code -
-     * @param {object} labels -
-     * @param {object} namingConvention -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.AssetFamilies>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsAssetFamiliesCreate(code: string, labels?: object, namingConvention?: object): Promise<Models.AssetFamilies>;
-    /**
+     * It answers what it FOUND: an id or SKU that names nothing is simply absent from `items` rather than an error, so compare the length of what you sent with what came back if a miss matters. It is not a general product read — for the whole row use `GET /products/{id}`, and for a scannable list use `GET /products/grid`.
      *
-     * @param {string} params.id -
-     * @throws {RevenexxAPIRevenexxException}
+     * @param {string[]} params.ids - Product ids, when the caller already holds them.
+     * @param {string[]} params.skus - Product SKUs — the identifier a foreign system carries, which is why this route exists at all.
+     * @throws {RevenexxException}
      * @returns {Promise<{}>}
      */
-    productsAssetFamiliesDelete(params: {
-        id: string;
+    productsBatch(params?: {
+        ids?: string[];
+        skus?: string[];
     }): Promise<{}>;
     /**
+     * Answers four fields — id, sku, tax_class and the resolved display name — for a list of ids and/or SKUs in ONE call. It exists for the app on the other side of a product reference: the prices app holds SKUs and needs a tax class, a feed builder holds ids and needs names, and neither should page through the catalog or fire a request per line. Ask by either identifier or both; the two are unioned and a product named twice comes back once.
      *
-     * @param {string} id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsAssetFamiliesDelete(id: string): Promise<{}>;
-    /**
-     *
-     * @param {string} params.id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.AssetFamilies>}
-     */
-    productsAssetFamiliesGet(params: {
-        id: string;
-    }): Promise<Models.AssetFamilies>;
-    /**
+     * It answers what it FOUND: an id or SKU that names nothing is simply absent from `items` rather than an error, so compare the length of what you sent with what came back if a miss matters. It is not a general product read — for the whole row use `GET /products/{id}`, and for a scannable list use `GET /products/grid`.
      *
-     * @param {string} id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.AssetFamilies>}
+     * @param {string[]} ids - Product ids, when the caller already holds them.
+     * @param {string[]} skus - Product SKUs — the identifier a foreign system carries, which is why this route exists at all.
+     * @throws {RevenexxException}
+     * @returns {Promise<{}>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    productsAssetFamiliesGet(id: string): Promise<Models.AssetFamilies>;
-    /**
-     *
-     * @param {string} params.id -
-     * @param {string} params.code -
-     * @param {object} params.labels -
-     * @param {object} params.namingConvention -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.AssetFamilies>}
-     */
-    productsAssetFamiliesUpdate(params: {
-        id: string;
-        code?: string;
-        labels?: object;
-        namingConvention?: object;
-    }): Promise<Models.AssetFamilies>;
+    productsBatch(ids?: string[], skus?: string[]): Promise<{}>;
     /**
+     * The list a merchant can actually scan, as opposed to `GET /products`, which answers SKUs and a jsonb blob. Every row arrives already flattened: its resolved display name and where that name came from, its family code, its stored completeness, and the value of every attribute the catalog marks `usable_in_grid` — no join, no second call. `q` is a case-insensitive substring of the stored `label` column, which falls back to the SKU, so one box finds a product by either. Soft-deleted products are excluded here, unlike `GET /products`.
      *
-     * @param {string} id -
-     * @param {string} code -
-     * @param {object} labels -
-     * @param {object} namingConvention -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.AssetFamilies>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsAssetFamiliesUpdate(id: string, code?: string, labels?: object, namingConvention?: object): Promise<Models.AssetFamilies>;
-    /**
+     * It filters on `q`, `kind`, `enabled` and `family_id`, and on NOTHING ELSE — a query parameter it does not accept is refused with 400 rather than dropped. That matters because of `filters`: the array reports the attributes marked `is_filterable`, which is what a filter bar should OFFER, and it is not a query surface. Filtering on an attribute value is not offered by this API at all — the values live inside a four-bucket jsonb document and are read through a fallback chain, so it is a feature with a design of its own rather than a parameter that was forgotten.
      *
-     * @param {number} params.limit - Page size (default 50, max 200).
-     * @param {number} params.offset - Row offset for pagination (default 0).
-     * @param {string} params.order - Sort as 'column.asc' | 'column.desc', e.g. 'created_at.desc'.
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
+     * @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. Anything else is refused with 400.
+     * @param {string} params.q - Case-insensitive substring of the display name (or the SKU, when there is no name).
+     * @param {Kind} params.kind - Restrict to one product kind.
+     * @param {boolean} params.enabled - Restrict to enabled or disabled products.
+     * @param {string} params.familyId - Restrict to one family. A family id that does not exist is not an error here — it simply matches nothing.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
      */
-    productsAssetsList(params?: {
+    productsGrid(params?: {
         limit?: number;
         offset?: number;
         order?: string;
-    }): Promise<{}>;
-    /**
-     *
-     * @param {number} limit - Page size (default 50, max 200).
-     * @param {number} offset - Row offset for pagination (default 0).
-     * @param {string} order - Sort as 'column.asc' | 'column.desc', e.g. 'created_at.desc'.
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsAssetsList(limit?: number, offset?: number, order?: string): Promise<{}>;
+        q?: string;
+        kind?: Kind;
+        enabled?: boolean;
+        familyId?: string;
+    }): Promise<Models.Error>;
     /**
+     * The list a merchant can actually scan, as opposed to `GET /products`, which answers SKUs and a jsonb blob. Every row arrives already flattened: its resolved display name and where that name came from, its family code, its stored completeness, and the value of every attribute the catalog marks `usable_in_grid` — no join, no second call. `q` is a case-insensitive substring of the stored `label` column, which falls back to the SKU, so one box finds a product by either. Soft-deleted products are excluded here, unlike `GET /products`.
      *
-     * @param {string} params.assetFamilyId -
-     * @param {string} params.code -
-     * @param {object} params.attributeValues -
-     * @param {string} params.mediaUuid -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.Assets>}
-     */
-    productsAssetsCreate(params: {
-        assetFamilyId: string;
-        code: string;
-        attributeValues?: object;
-        mediaUuid?: string;
-    }): Promise<Models.Assets>;
-    /**
+     * It filters on `q`, `kind`, `enabled` and `family_id`, and on NOTHING ELSE — a query parameter it does not accept is refused with 400 rather than dropped. That matters because of `filters`: the array reports the attributes marked `is_filterable`, which is what a filter bar should OFFER, and it is not a query surface. Filtering on an attribute value is not offered by this API at all — the values live inside a four-bucket jsonb document and are read through a fallback chain, so it is a feature with a design of its own rather than a parameter that was forgotten.
      *
-     * @param {string} assetFamilyId -
-     * @param {string} code -
-     * @param {object} attributeValues -
-     * @param {string} mediaUuid -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.Assets>}
+     * @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. Anything else is refused with 400.
+     * @param {string} q - Case-insensitive substring of the display name (or the SKU, when there is no name).
+     * @param {Kind} kind - Restrict to one product kind.
+     * @param {boolean} enabled - Restrict to enabled or disabled products.
+     * @param {string} familyId - Restrict to one family. A family id that does not exist is not an error here — it simply matches nothing.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    productsAssetsCreate(assetFamilyId: string, code: string, attributeValues?: object, mediaUuid?: string): Promise<Models.Assets>;
+    productsGrid(limit?: number, offset?: number, order?: string, q?: string, kind?: Kind, enabled?: boolean, familyId?: string): Promise<Models.Error>;
     /**
+     * What is this product CALLED? A product's name is an attribute rather than a column, and which attribute it is, is per family — so no plain read can answer it. This resolves up to 500 products at once, by id and/or SKU: it reads families.label_attribute (falling back to the default_label_attribute setting, then to the conventional `name`) and looks the value up through the scoped attribute_values document — common, then locale_specific in the label_locales order, then the channel buckets.
      *
-     * @param {string} params.id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     */
-    productsAssetsDelete(params: {
-        id: string;
-    }): Promise<{}>;
-    /**
+     * It reports WHERE the name was found, which is the half that matters: `source: "sku"` means the catalog holds no name for this product and the SKU is standing in for one, so show it as a missing name rather than as a name. Writes nothing, and answers only what it found.
      *
-     * @param {string} id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     * @deprecated Use the object parameter style method for a better developer experience.
+     * @param {string[]} params.ids - Product ids to name. At most 500.
+     * @param {string[]} params.skus - Product SKUs to name. At most 500.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
      */
-    productsAssetsDelete(id: string): Promise<{}>;
+    productsLabels(params?: {
+        ids?: string[];
+        skus?: string[];
+    }): Promise<Models.Error>;
     /**
+     * What is this product CALLED? A product's name is an attribute rather than a column, and which attribute it is, is per family — so no plain read can answer it. This resolves up to 500 products at once, by id and/or SKU: it reads families.label_attribute (falling back to the default_label_attribute setting, then to the conventional `name`) and looks the value up through the scoped attribute_values document — common, then locale_specific in the label_locales order, then the channel buckets.
      *
-     * @param {string} params.id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.Assets>}
-     */
-    productsAssetsGet(params: {
-        id: string;
-    }): Promise<Models.Assets>;
-    /**
+     * It reports WHERE the name was found, which is the half that matters: `source: "sku"` means the catalog holds no name for this product and the SKU is standing in for one, so show it as a missing name rather than as a name. Writes nothing, and answers only what it found.
      *
-     * @param {string} id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.Assets>}
+     * @param {string[]} ids - Product ids to name. At most 500.
+     * @param {string[]} skus - Product SKUs to name. At most 500.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    productsAssetsGet(id: string): Promise<Models.Assets>;
+    productsLabels(ids?: string[], skus?: string[]): Promise<Models.Error>;
     /**
+     * One relation from one product to another, of a declared type: this drill's accessories, this bundle's parts, this article's cross-sells. `quantity` is the number in "this bundle contains 4 casters" and is meaningful only when the association type carries `is_quantified`. This relational surface is the one this app serves; the `products.quantified_associations` column is an importer's blob that no route here reads or writes.
      *
-     * @param {string} params.id -
-     * @param {string} params.assetFamilyId -
-     * @param {object} params.attributeValues -
-     * @param {string} params.code -
-     * @param {string} params.mediaUuid -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.Assets>}
-     */
-    productsAssetsUpdate(params: {
-        id: string;
-        assetFamilyId?: string;
-        attributeValues?: object;
-        code?: string;
-        mediaUuid?: string;
-    }): Promise<Models.Assets>;
-    /**
+     * Every column of `product_associations` is an exact-match query parameter, `order` sorts by one column, and `limit`/`offset` page through `page.total`. A query key that is NOT a column is dropped rather than refused, and the `filter` object echoes the ones that were understood — that echo is the only way to tell an unfiltered answer from an empty one. It reads rows exactly as they are stored: no join is resolved, no jsonb value is unpacked.
      *
-     * @param {string} id -
-     * @param {string} assetFamilyId -
-     * @param {object} attributeValues -
-     * @param {string} code -
-     * @param {string} mediaUuid -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.Assets>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsAssetsUpdate(id: string, assetFamilyId?: string, attributeValues?: object, code?: string, mediaUuid?: string): Promise<Models.Assets>;
-    /**
+     * Answered from the gateway's tenant cache for up to 30 minutes and dropped the moment this entity is written, because the data model changes weekly at most and every product page asks the same question.
      *
-     * @param {number} params.limit - Page size (default 50, max 200).
-     * @param {number} params.offset - Row offset for pagination (default 0).
-     * @param {string} params.order - Sort as 'column.asc' | 'column.desc', e.g. 'created_at.desc'.
-     * @throws {RevenexxAPIRevenexxException}
+     * @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. Anything else is refused with 400.
+     * @param {string} params.id - Exact match on `id`. The row's own id, generated by the database. A client never sends one; it reads one back and uses it in the path of every later call.
+     * @param {string} params.productId - Exact match on `product_id`. The product the relation starts at — the one whose detail page shows it.
+     * @param {string} params.associationTypeId - Exact match on `association_type_id`. Which kind of relation this is — the `association_types` row.
+     * @param {string} params.targetProductId - Exact match on `target_product_id`. The product the relation points at — the accessory, the spare part, the cross-sell.
+     * @param {number} params.quantity - Exact match on `quantity`. How many of the target belong to the source — the 4 in "this bundle contains 4 casters". Only meaningful when the association type carries `is_quantified`; null on an ordinary cross-sell.
+     * @param {number} params.position - Exact match on `position`. Order in which the targets are shown, ascending.
+     * @param {string} params.createdAt - Exact match on `created_at`. When the row was created. Server-set — it is not part of any request body.
+     * @throws {RevenexxException}
      * @returns {Promise<{}>}
      */
-    productsAssociationTypesList(params?: {
+    productsProductAssociationsList(params?: {
         limit?: number;
         offset?: number;
         order?: string;
+        id?: string;
+        productId?: string;
+        associationTypeId?: string;
+        targetProductId?: string;
+        quantity?: number;
+        position?: number;
+        createdAt?: string;
     }): Promise<{}>;
     /**
+     * One relation from one product to another, of a declared type: this drill's accessories, this bundle's parts, this article's cross-sells. `quantity` is the number in "this bundle contains 4 casters" and is meaningful only when the association type carries `is_quantified`. This relational surface is the one this app serves; the `products.quantified_associations` column is an importer's blob that no route here reads or writes.
      *
-     * @param {number} limit - Page size (default 50, max 200).
-     * @param {number} offset - Row offset for pagination (default 0).
-     * @param {string} order - Sort as 'column.asc' | 'column.desc', e.g. 'created_at.desc'.
-     * @throws {RevenexxAPIRevenexxException}
+     * Every column of `product_associations` is an exact-match query parameter, `order` sorts by one column, and `limit`/`offset` page through `page.total`. A query key that is NOT a column is dropped rather than refused, and the `filter` object echoes the ones that were understood — that echo is the only way to tell an unfiltered answer from an empty one. It reads rows exactly as they are stored: no join is resolved, no jsonb value is unpacked.
+     *
+     * Answered from the gateway's tenant cache for up to 30 minutes and dropped the moment this entity is written, because the data model changes weekly at most and every product page asks the same question.
+     *
+     * @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. Anything else is refused with 400.
+     * @param {string} id - Exact match on `id`. The row's own id, generated by the database. A client never sends one; it reads one back and uses it in the path of every later call.
+     * @param {string} productId - Exact match on `product_id`. The product the relation starts at — the one whose detail page shows it.
+     * @param {string} associationTypeId - Exact match on `association_type_id`. Which kind of relation this is — the `association_types` row.
+     * @param {string} targetProductId - Exact match on `target_product_id`. The product the relation points at — the accessory, the spare part, the cross-sell.
+     * @param {number} quantity - Exact match on `quantity`. How many of the target belong to the source — the 4 in "this bundle contains 4 casters". Only meaningful when the association type carries `is_quantified`; null on an ordinary cross-sell.
+     * @param {number} position - Exact match on `position`. Order in which the targets are shown, ascending.
+     * @param {string} createdAt - Exact match on `created_at`. When the row was created. Server-set — it is not part of any request body.
+     * @throws {RevenexxException}
      * @returns {Promise<{}>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    productsAssociationTypesList(limit?: number, offset?: number, order?: string): Promise<{}>;
+    productsProductAssociationsList(limit?: number, offset?: number, order?: string, id?: string, productId?: string, associationTypeId?: string, targetProductId?: string, quantity?: number, position?: number, createdAt?: string): Promise<{}>;
     /**
+     * Creates one product association and answers 201 with the stored row, including the id and the timestamps the database filled in — a client never sends an id, it reads one back and uses it in the path of every later call.
      *
-     * @param {string} params.code -
-     * @param {boolean} params.isQuantified -
-     * @param {boolean} params.isTwoWay -
-     * @param {object} params.labels -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.AssociationTypes>}
-     */
-    productsAssociationTypesCreate(params: {
-        code: string;
-        isQuantified?: boolean;
-        isTwoWay?: boolean;
-        labels?: object;
-    }): Promise<Models.AssociationTypes>;
-    /**
+     * One relation from one product to another, of a declared type: this drill's accessories, this bundle's parts, this article's cross-sells. `quantity` is the number in "this bundle contains 4 casters" and is meaningful only when the association type carries `is_quantified`. This relational surface is the one this app serves; the `products.quantified_associations` column is an importer's blob that no route here reads or writes.
      *
-     * @param {string} code -
-     * @param {boolean} isQuantified -
-     * @param {boolean} isTwoWay -
-     * @param {object} labels -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.AssociationTypes>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsAssociationTypesCreate(code: string, isQuantified?: boolean, isTwoWay?: boolean, labels?: object): Promise<Models.AssociationTypes>;
-    /**
+     * `product_id`, `association_type_id`, `target_product_id` are the only columns the database refuses the row without; everything else has a default or is nullable. A second row with the same `product_id`, `association_type_id`, `target_product_id` answers 409.
      *
-     * @param {string} params.id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
+     * @param {string} params.associationTypeId - Which kind of relation this is — the `association_types` row.
+     * @param {string} params.productId - The product the relation starts at — the one whose detail page shows it.
+     * @param {string} params.targetProductId - The product the relation points at — the accessory, the spare part, the cross-sell.
+     * @param {number} params.position - Order in which the targets are shown, ascending.
+     * @param {number} params.quantity - How many of the target belong to the source — the 4 in "this bundle contains 4 casters". Only meaningful when the association type carries `is_quantified`; null on an ordinary cross-sell.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
      */
-    productsAssociationTypesDelete(params: {
-        id: string;
-    }): Promise<{}>;
+    productsProductAssociationsCreate(params: {
+        associationTypeId: string;
+        productId: string;
+        targetProductId: string;
+        position?: number;
+        quantity?: number;
+    }): Promise<Models.Error>;
     /**
+     * Creates one product association and answers 201 with the stored row, including the id and the timestamps the database filled in — a client never sends an id, it reads one back and uses it in the path of every later call.
      *
-     * @param {string} id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsAssociationTypesDelete(id: string): Promise<{}>;
-    /**
+     * One relation from one product to another, of a declared type: this drill's accessories, this bundle's parts, this article's cross-sells. `quantity` is the number in "this bundle contains 4 casters" and is meaningful only when the association type carries `is_quantified`. This relational surface is the one this app serves; the `products.quantified_associations` column is an importer's blob that no route here reads or writes.
      *
-     * @param {string} params.id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.AssociationTypes>}
-     */
-    productsAssociationTypesGet(params: {
-        id: string;
-    }): Promise<Models.AssociationTypes>;
-    /**
+     * `product_id`, `association_type_id`, `target_product_id` are the only columns the database refuses the row without; everything else has a default or is nullable. A second row with the same `product_id`, `association_type_id`, `target_product_id` answers 409.
      *
-     * @param {string} id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.AssociationTypes>}
+     * @param {string} associationTypeId - Which kind of relation this is — the `association_types` row.
+     * @param {string} productId - The product the relation starts at — the one whose detail page shows it.
+     * @param {string} targetProductId - The product the relation points at — the accessory, the spare part, the cross-sell.
+     * @param {number} position - Order in which the targets are shown, ascending.
+     * @param {number} quantity - How many of the target belong to the source — the 4 in "this bundle contains 4 casters". Only meaningful when the association type carries `is_quantified`; null on an ordinary cross-sell.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    productsAssociationTypesGet(id: string): Promise<Models.AssociationTypes>;
+    productsProductAssociationsCreate(associationTypeId: string, productId: string, targetProductId: string, position?: number, quantity?: number): Promise<Models.Error>;
     /**
+     * Deletes one product association by id. It is a hard delete — the row is gone, and the answer is a confirmation rather than a result to branch on.
+     *
+     * Nothing in this schema references it, so nothing else changes.
      *
-     * @param {string} params.id -
-     * @param {string} params.code -
-     * @param {boolean} params.isQuantified -
-     * @param {boolean} params.isTwoWay -
-     * @param {object} params.labels -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.AssociationTypes>}
+     * An id no product association of this tenant carries answers 404; there is no 409, because every foreign key pointing at this entity resolves itself on delete rather than blocking one.
+     *
+     * @param {string} params.id - The `product_associations` row to address, by id. It names a row THIS TENANT holds, so no example is published — a uuid this app invented would document a call that answers 404, and a real one would be another tenant's data. Read one from `GET /v1/products/product_associations`. An id no product association of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
      */
-    productsAssociationTypesUpdate(params: {
+    productsProductAssociationsDelete(params: {
         id: string;
-        code?: string;
-        isQuantified?: boolean;
-        isTwoWay?: boolean;
-        labels?: object;
-    }): Promise<Models.AssociationTypes>;
+    }): Promise<Models.Error>;
     /**
+     * Deletes one product association by id. It is a hard delete — the row is gone, and the answer is a confirmation rather than a result to branch on.
      *
-     * @param {string} id -
-     * @param {string} code -
-     * @param {boolean} isQuantified -
-     * @param {boolean} isTwoWay -
-     * @param {object} labels -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.AssociationTypes>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsAssociationTypesUpdate(id: string, code?: string, isQuantified?: boolean, isTwoWay?: boolean, labels?: object): Promise<Models.AssociationTypes>;
-    /**
+     * Nothing in this schema references it, so nothing else changes.
      *
-     * @param {number} params.limit - Page size (default 50, max 200).
-     * @param {number} params.offset - Row offset for pagination (default 0).
-     * @param {string} params.order - Sort as 'column.asc' | 'column.desc', e.g. 'created_at.desc'.
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     */
-    productsAttributeGroupsList(params?: {
-        limit?: number;
-        offset?: number;
-        order?: string;
-    }): Promise<{}>;
-    /**
+     * An id no product association of this tenant carries answers 404; there is no 409, because every foreign key pointing at this entity resolves itself on delete rather than blocking one.
      *
-     * @param {number} limit - Page size (default 50, max 200).
-     * @param {number} offset - Row offset for pagination (default 0).
-     * @param {string} order - Sort as 'column.asc' | 'column.desc', e.g. 'created_at.desc'.
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
+     * @param {string} id - The `product_associations` row to address, by id. It names a row THIS TENANT holds, so no example is published — a uuid this app invented would document a call that answers 404, and a real one would be another tenant's data. Read one from `GET /v1/products/product_associations`. An id no product association of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    productsAttributeGroupsList(limit?: number, offset?: number, order?: string): Promise<{}>;
+    productsProductAssociationsDelete(id: string): Promise<Models.Error>;
     /**
+     * Reads one product association by its id — the whole row, every column, as it is stored.
      *
-     * @param {string} params.code -
-     * @param {object} params.labels -
-     * @param {number} params.position -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.AttributeGroups>}
-     */
-    productsAttributeGroupsCreate(params: {
-        code: string;
-        labels?: object;
-        position?: number;
-    }): Promise<Models.AttributeGroups>;
-    /**
+     * One relation from one product to another, of a declared type: this drill's accessories, this bundle's parts, this article's cross-sells. `quantity` is the number in "this bundle contains 4 casters" and is meaningful only when the association type carries `is_quantified`. This relational surface is the one this app serves; the `products.quantified_associations` column is an importer's blob that no route here reads or writes.
      *
-     * @param {string} code -
-     * @param {object} labels -
-     * @param {number} position -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.AttributeGroups>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsAttributeGroupsCreate(code: string, labels?: object, position?: number): Promise<Models.AttributeGroups>;
-    /**
+     * An id no product association of this tenant carries answers 404, and so does one belonging to another tenant: row-level security makes that row invisible rather than forbidden. A malformed id answers 400 before the route is reached.
      *
-     * @param {string} params.id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
+     * Answered from the gateway's tenant cache for up to 30 minutes and dropped the moment this entity is written, because the data model changes weekly at most and every product page asks the same question.
+     *
+     * @param {string} params.id - The `product_associations` row to address, by id. It names a row THIS TENANT holds, so no example is published — a uuid this app invented would document a call that answers 404, and a real one would be another tenant's data. Read one from `GET /v1/products/product_associations`. An id no product association of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
      */
-    productsAttributeGroupsDelete(params: {
+    productsProductAssociationsGet(params: {
         id: string;
-    }): Promise<{}>;
+    }): Promise<Models.Error>;
     /**
+     * Reads one product association by its id — the whole row, every column, as it is stored.
      *
-     * @param {string} id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsAttributeGroupsDelete(id: string): Promise<{}>;
-    /**
+     * One relation from one product to another, of a declared type: this drill's accessories, this bundle's parts, this article's cross-sells. `quantity` is the number in "this bundle contains 4 casters" and is meaningful only when the association type carries `is_quantified`. This relational surface is the one this app serves; the `products.quantified_associations` column is an importer's blob that no route here reads or writes.
      *
-     * @param {string} params.id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.AttributeGroups>}
-     */
-    productsAttributeGroupsGet(params: {
-        id: string;
-    }): Promise<Models.AttributeGroups>;
-    /**
+     * An id no product association of this tenant carries answers 404, and so does one belonging to another tenant: row-level security makes that row invisible rather than forbidden. A malformed id answers 400 before the route is reached.
      *
-     * @param {string} id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.AttributeGroups>}
+     * Answered from the gateway's tenant cache for up to 30 minutes and dropped the moment this entity is written, because the data model changes weekly at most and every product page asks the same question.
+     *
+     * @param {string} id - The `product_associations` row to address, by id. It names a row THIS TENANT holds, so no example is published — a uuid this app invented would document a call that answers 404, and a real one would be another tenant's data. Read one from `GET /v1/products/product_associations`. An id no product association of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    productsAttributeGroupsGet(id: string): Promise<Models.AttributeGroups>;
+    productsProductAssociationsGet(id: string): Promise<Models.Error>;
     /**
+     * Updates one product association by id. A partial patch: the body names only the columns to change and every column it leaves out keeps its current value, so there is no read-modify-write and no way to blank a field by forgetting it.
+     *
+     * One relation from one product to another, of a declared type: this drill's accessories, this bundle's parts, this article's cross-sells. `quantity` is the number in "this bundle contains 4 casters" and is meaningful only when the association type carries `is_quantified`. This relational surface is the one this app serves; the `products.quantified_associations` column is an importer's blob that no route here reads or writes.
      *
-     * @param {string} params.id -
-     * @param {string} params.code -
-     * @param {object} params.labels -
-     * @param {number} params.position -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.AttributeGroups>}
+     * A body that names nothing writable is refused with 400 rather than answered as a no-op, an id nobody carries answers 404, and a value that collides on `product_id`, `association_type_id`, `target_product_id` answers 409.
+     *
+     * @param {string} params.id - The `product_associations` row to address, by id. It names a row THIS TENANT holds, so no example is published — a uuid this app invented would document a call that answers 404, and a real one would be another tenant's data. Read one from `GET /v1/products/product_associations`. An id no product association of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @param {string} params.associationTypeId - Which kind of relation this is — the `association_types` row.
+     * @param {number} params.position - Order in which the targets are shown, ascending.
+     * @param {string} params.productId - The product the relation starts at — the one whose detail page shows it.
+     * @param {number} params.quantity - How many of the target belong to the source — the 4 in "this bundle contains 4 casters". Only meaningful when the association type carries `is_quantified`; null on an ordinary cross-sell.
+     * @param {string} params.targetProductId - The product the relation points at — the accessory, the spare part, the cross-sell.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
      */
-    productsAttributeGroupsUpdate(params: {
+    productsProductAssociationsUpdate(params: {
         id: string;
-        code?: string;
-        labels?: object;
+        associationTypeId?: string;
         position?: number;
-    }): Promise<Models.AttributeGroups>;
+        productId?: string;
+        quantity?: number;
+        targetProductId?: string;
+    }): Promise<Models.Error>;
     /**
+     * Updates one product association by id. A partial patch: the body names only the columns to change and every column it leaves out keeps its current value, so there is no read-modify-write and no way to blank a field by forgetting it.
+     *
+     * One relation from one product to another, of a declared type: this drill's accessories, this bundle's parts, this article's cross-sells. `quantity` is the number in "this bundle contains 4 casters" and is meaningful only when the association type carries `is_quantified`. This relational surface is the one this app serves; the `products.quantified_associations` column is an importer's blob that no route here reads or writes.
+     *
+     * A body that names nothing writable is refused with 400 rather than answered as a no-op, an id nobody carries answers 404, and a value that collides on `product_id`, `association_type_id`, `target_product_id` answers 409.
      *
-     * @param {string} id -
-     * @param {string} code -
-     * @param {object} labels -
-     * @param {number} position -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.AttributeGroups>}
+     * @param {string} id - The `product_associations` row to address, by id. It names a row THIS TENANT holds, so no example is published — a uuid this app invented would document a call that answers 404, and a real one would be another tenant's data. Read one from `GET /v1/products/product_associations`. An id no product association of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @param {string} associationTypeId - Which kind of relation this is — the `association_types` row.
+     * @param {number} position - Order in which the targets are shown, ascending.
+     * @param {string} productId - The product the relation starts at — the one whose detail page shows it.
+     * @param {number} quantity - How many of the target belong to the source — the 4 in "this bundle contains 4 casters". Only meaningful when the association type carries `is_quantified`; null on an ordinary cross-sell.
+     * @param {string} targetProductId - The product the relation points at — the accessory, the spare part, the cross-sell.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    productsAttributeGroupsUpdate(id: string, code?: string, labels?: object, position?: number): Promise<Models.AttributeGroups>;
+    productsProductAssociationsUpdate(id: string, associationTypeId?: string, position?: number, productId?: string, quantity?: number, targetProductId?: string): Promise<Models.Error>;
     /**
+     * The index of the enums this app ENFORCES — `product-kinds`, `membership-sources`, `rule-matches`, `asset-sources` — served by the app that owns the CHECK constraint each one is parsed out of, so a UI never has to keep its own copy of a status map and watch it drift. Names and titles only: fetch one by name for its values, badge tones and descriptions.
      *
-     * @param {number} params.limit - Page size (default 50, max 200).
-     * @param {number} params.offset - Row offset for pagination (default 0).
-     * @param {string} params.order - Sort as 'column.asc' | 'column.desc', e.g. 'created_at.desc'.
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     */
-    productsAttributeOptionsList(params?: {
-        limit?: number;
-        offset?: number;
-        order?: string;
-    }): Promise<{}>;
-    /**
+     * The set is a fixed property of this app rather than tenant data, so it is the same list for every tenant. `attributes.type` is deliberately absent: it carries no CHECK, because the whole point of an attribute-driven PIM is that the type list is data an integrator extends.
      *
-     * @param {number} limit - Page size (default 50, max 200).
-     * @param {number} offset - Row offset for pagination (default 0).
-     * @param {string} order - Sort as 'column.asc' | 'column.desc', e.g. 'created_at.desc'.
-     * @throws {RevenexxAPIRevenexxException}
+     * @throws {RevenexxException}
      * @returns {Promise<{}>}
-     * @deprecated Use the object parameter style method for a better developer experience.
      */
-    productsAttributeOptionsList(limit?: number, offset?: number, order?: string): Promise<{}>;
+    productsVocabulariesList(): Promise<{}>;
     /**
+     * One vocabulary with every value it admits, each with a title, a description and the badge tone a UI should paint it in. The value set is parsed out of the CHECK constraint in schema.json, so what is served IS what is enforced. Labels are curated on top and can only add words and colour — a permitted value nobody labelled still appears, titled from its own key.
      *
-     * @param {string} params.attributeId -
-     * @param {string} params.code -
-     * @param {object} params.labels -
-     * @param {number} params.position -
-     * @param {object} params.swatch -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.AttributeOptions>}
+     * @param {string} params.name - The vocabulary name, as listed by GET /products/vocabularies.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
      */
-    productsAttributeOptionsCreate(params: {
-        attributeId: string;
-        code: string;
-        labels?: object;
-        position?: number;
-        swatch?: object;
-    }): Promise<Models.AttributeOptions>;
+    productsVocabulariesGet(params: {
+        name: string;
+    }): Promise<Models.Error>;
     /**
+     * One vocabulary with every value it admits, each with a title, a description and the badge tone a UI should paint it in. The value set is parsed out of the CHECK constraint in schema.json, so what is served IS what is enforced. Labels are curated on top and can only add words and colour — a permitted value nobody labelled still appears, titled from its own key.
      *
-     * @param {string} attributeId -
-     * @param {string} code -
-     * @param {object} labels -
-     * @param {number} position -
-     * @param {object} swatch -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.AttributeOptions>}
+     * @param {string} name - The vocabulary name, as listed by GET /products/vocabularies.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    productsAttributeOptionsCreate(attributeId: string, code: string, labels?: object, position?: number, swatch?: object): Promise<Models.AttributeOptions>;
+    productsVocabulariesGet(name: string): Promise<Models.Error>;
     /**
+     * Deletes one product by id. It is a hard delete — the row is gone, and the answer is a confirmation rather than a result to branch on.
      *
-     * @param {string} params.id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     */
-    productsAttributeOptionsDelete(params: {
-        id: string;
-    }): Promise<{}>;
-    /**
+     * It takes what hangs off it: product category memberships (`product_id`), product associations (`product_id` and `target_product_id`) are deleted with it. `products.parent_id` is set to null instead, so the rows that pointed at it survive the delete rather than going with it.
      *
-     * @param {string} id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsAttributeOptionsDelete(id: string): Promise<{}>;
-    /**
+     * An id no product of this tenant carries answers 404; there is no 409, because every foreign key pointing at this entity resolves itself on delete rather than blocking one. `products.deleted_at` is a SOFT-delete marker that the grid and every category-rule evaluation honour, but no route in this app ever writes it — to soft-delete instead, `PUT /products/{id}` with a `deleted_at`.
      *
-     * @param {string} params.id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.AttributeOptions>}
+     * @param {string} params.id - The `products` row to address, by id. It names a row THIS TENANT holds, so no example is published — a uuid this app invented would document a call that answers 404, and a real one would be another tenant's data. Read one from `GET /v1/products`. An id no product of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
      */
-    productsAttributeOptionsGet(params: {
+    productsDelete(params: {
         id: string;
-    }): Promise<Models.AttributeOptions>;
+    }): Promise<Models.Error>;
     /**
+     * Deletes one product by id. It is a hard delete — the row is gone, and the answer is a confirmation rather than a result to branch on.
+     *
+     * It takes what hangs off it: product category memberships (`product_id`), product associations (`product_id` and `target_product_id`) are deleted with it. `products.parent_id` is set to null instead, so the rows that pointed at it survive the delete rather than going with it.
      *
-     * @param {string} id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.AttributeOptions>}
+     * An id no product of this tenant carries answers 404; there is no 409, because every foreign key pointing at this entity resolves itself on delete rather than blocking one. `products.deleted_at` is a SOFT-delete marker that the grid and every category-rule evaluation honour, but no route in this app ever writes it — to soft-delete instead, `PUT /products/{id}` with a `deleted_at`.
+     *
+     * @param {string} id - The `products` row to address, by id. It names a row THIS TENANT holds, so no example is published — a uuid this app invented would document a call that answers 404, and a real one would be another tenant's data. Read one from `GET /v1/products`. An id no product of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    productsAttributeOptionsGet(id: string): Promise<Models.AttributeOptions>;
+    productsDelete(id: string): Promise<Models.Error>;
     /**
+     * Reads one product by its id — the whole row, every column, as it is stored.
+     *
+     * The catalog itself. A product row carries only what every product has — SKU, kind, family, enabled, tax class — and everything the tenant modelled lives in the `attribute_values` jsonb document, keyed by attribute CODE inside one of four scope buckets (common, per locale, per channel, per channel and locale). `label` is a generated column, maintained by the database so a grid of twenty thousand rows can sort and filter on a name with no join. `kind` says where the row sits in the variant hierarchy: a `model` carries what its variants share and is never sold itself.
      *
-     * @param {string} params.id -
-     * @param {string} params.attributeId -
-     * @param {string} params.code -
-     * @param {object} params.labels -
-     * @param {number} params.position -
-     * @param {object} params.swatch -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.AttributeOptions>}
+     * An id no product of this tenant carries answers 404, and so does one belonging to another tenant: row-level security makes that row invisible rather than forbidden. A malformed id answers 400 before the route is reached. Nothing is resolved for you here — for the display name, the family code and the grid attributes already unpacked, use `GET /products/grid` or `POST /products/labels`.
+     *
+     * @param {string} params.id - The `products` row to address, by id. It names a row THIS TENANT holds, so no example is published — a uuid this app invented would document a call that answers 404, and a real one would be another tenant's data. Read one from `GET /v1/products`. An id no product of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
      */
-    productsAttributeOptionsUpdate(params: {
+    productsGet(params: {
         id: string;
-        attributeId?: string;
-        code?: string;
-        labels?: object;
-        position?: number;
-        swatch?: object;
-    }): Promise<Models.AttributeOptions>;
+    }): Promise<Models.Error>;
     /**
+     * Reads one product by its id — the whole row, every column, as it is stored.
      *
-     * @param {string} id -
-     * @param {string} attributeId -
-     * @param {string} code -
-     * @param {object} labels -
-     * @param {number} position -
-     * @param {object} swatch -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.AttributeOptions>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsAttributeOptionsUpdate(id: string, attributeId?: string, code?: string, labels?: object, position?: number, swatch?: object): Promise<Models.AttributeOptions>;
-    /**
+     * The catalog itself. A product row carries only what every product has — SKU, kind, family, enabled, tax class — and everything the tenant modelled lives in the `attribute_values` jsonb document, keyed by attribute CODE inside one of four scope buckets (common, per locale, per channel, per channel and locale). `label` is a generated column, maintained by the database so a grid of twenty thousand rows can sort and filter on a name with no join. `kind` says where the row sits in the variant hierarchy: a `model` carries what its variants share and is never sold itself.
      *
-     * @param {number} params.limit - Page size (default 50, max 200).
-     * @param {number} params.offset - Row offset for pagination (default 0).
-     * @param {string} params.order - Sort as 'column.asc' | 'column.desc', e.g. 'created_at.desc'.
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     */
-    productsAttributesList(params?: {
-        limit?: number;
-        offset?: number;
-        order?: string;
-    }): Promise<{}>;
-    /**
+     * An id no product of this tenant carries answers 404, and so does one belonging to another tenant: row-level security makes that row invisible rather than forbidden. A malformed id answers 400 before the route is reached. Nothing is resolved for you here — for the display name, the family code and the grid attributes already unpacked, use `GET /products/grid` or `POST /products/labels`.
      *
-     * @param {number} limit - Page size (default 50, max 200).
-     * @param {number} offset - Row offset for pagination (default 0).
-     * @param {string} order - Sort as 'column.asc' | 'column.desc', e.g. 'created_at.desc'.
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
+     * @param {string} id - The `products` row to address, by id. It names a row THIS TENANT holds, so no example is published — a uuid this app invented would document a call that answers 404, and a real one would be another tenant's data. Read one from `GET /v1/products`. An id no product of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    productsAttributesList(limit?: number, offset?: number, order?: string): Promise<{}>;
+    productsGet(id: string): Promise<Models.Error>;
     /**
+     * Updates one product by id. A partial patch: the body names only the columns to change and every column it leaves out keeps its current value, so there is no read-modify-write and no way to blank a field by forgetting it.
      *
-     * @param {string} params.code -
-     * @param {string} params.type -
-     * @param {object} params.config -
-     * @param {string} params.entityRef -
-     * @param {string} params.entityType -
-     * @param {string} params.groupId -
-     * @param {boolean} params.isFilterable -
-     * @param {boolean} params.isUnique -
-     * @param {object} params.labels -
-     * @param {boolean} params.localizable -
-     * @param {number} params.position -
-     * @param {boolean} params.scopable -
-     * @param {boolean} params.usableInGrid -
-     * @param {object} params.validation -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.Attributes>}
-     */
-    productsAttributesCreate(params: {
-        code: string;
-        type: string;
-        config?: object;
-        entityRef?: string;
-        entityType?: string;
-        groupId?: string;
-        isFilterable?: boolean;
-        isUnique?: boolean;
-        labels?: object;
-        localizable?: boolean;
-        position?: number;
-        scopable?: boolean;
-        usableInGrid?: boolean;
-        validation?: object;
-    }): Promise<Models.Attributes>;
-    /**
+     * The catalog itself. A product row carries only what every product has — SKU, kind, family, enabled, tax class — and everything the tenant modelled lives in the `attribute_values` jsonb document, keyed by attribute CODE inside one of four scope buckets (common, per locale, per channel, per channel and locale). `label` is a generated column, maintained by the database so a grid of twenty thousand rows can sort and filter on a name with no join. `kind` says where the row sits in the variant hierarchy: a `model` carries what its variants share and is never sold itself.
      *
-     * @param {string} code -
-     * @param {string} type -
-     * @param {object} config -
-     * @param {string} entityRef -
-     * @param {string} entityType -
-     * @param {string} groupId -
-     * @param {boolean} isFilterable -
-     * @param {boolean} isUnique -
-     * @param {object} labels -
-     * @param {boolean} localizable -
-     * @param {number} position -
-     * @param {boolean} scopable -
-     * @param {boolean} usableInGrid -
-     * @param {object} validation -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.Attributes>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsAttributesCreate(code: string, type: string, config?: object, entityRef?: string, entityType?: string, groupId?: string, isFilterable?: boolean, isUnique?: boolean, labels?: object, localizable?: boolean, position?: number, scopable?: boolean, usableInGrid?: boolean, validation?: object): Promise<Models.Attributes>;
-    /**
+     * A body that names nothing writable is refused with 400 rather than answered as a no-op, an id nobody carries answers 404, and a value that collides on `sku` answers 409. `label` is a generated column: naming it is dropped rather than refused, and `completeness` is written by the two metadata routes, not here.
      *
-     * @param {string} params.id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
+     * @param {string} params.id - The `products` row to address, by id. It names a row THIS TENANT holds, so no example is published — a uuid this app invented would document a call that answers 404, and a real one would be another tenant's data. Read one from `GET /v1/products`. An id no product of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @param {object} params.attributeValues - Every attribute value the record carries, in ONE jsonb document — the core of an attribute-driven PIM. A record's properties are not columns here: they are rows in `attributes`, selected per family by `family_attributes`, and their values live under their attribute CODE inside this object.
+
+Four buckets, and an attribute's own flags decide which one it writes to:
+
+  `common`                    the attribute is neither localizable nor scopable — one value, full stop.
+                              `{"common": {"net_weight": 2.4, "colour": "black"}}`
+  `locale_specific`           `localizable`: one value per language tag.
+                              `{"locale_specific": {"de_DE": {"name": "Akku-Bohrschrauber"}}}`
+  `channel_specific`          `scopable`: one value per channel.
+                              `{"channel_specific": {"b2b": {"minimum_order_quantity": 6}}}`
+  `channel_locale_specific`   both: one value per channel AND language tag.
+                              `{"channel_locale_specific": {"b2b": {"de_DE": {"description": "…"}}}}`
+
+A reader takes the most specific bucket that carries the code and falls back through locale, then channel, then `common`. `common` is always last and always consulted, because early imports wrote everything there whatever an attribute's flags said — a reader that skipped it reports an imported catalog as empty. `GET /products/attribute-schema` answers, per field, the exact path a value belongs at (`storage.path`) and that full fallback order (`from`), so no client has to re-derive any of this.
+
+The value itself is whatever the attribute's `type` implies: a string, a number, a boolean, an option CODE for a select (never its label), a list of codes for a multi-select, `{"amount": …, "unit": …}` for a measure, a list of `{"amount": …, "currency": …}` for a price, an asset code for media.
+
+Defaults to `{}`, and an empty object is a normal state — a record nobody has enriched yet. The declared type also admits an array only because every jsonb column of this app shares one mapping; an array is not meaningful here and every reader in this app treats a non-object as empty.
+     * @param {object} params.completeness - How much of what this product's family REQUIRES it actually carries — the number a merchandiser works down. `required` counts the attributes the family marks `is_required`, `filled` how many of those carry a value in ANY bucket, `ratio` is filled/required between 0 and 1 (a family that requires nothing is 1, not undefined), `missing` lists the codes with no value anywhere, sorted, and `computed_at` is when it was measured.
+
+Written only by `POST /products/{id}/completeness` and by `POST /products/{id}/family`; a plain create or update never touches it, so it is null until one of the two has run. It also stays null for a product with no family — there is nothing to measure it against, and 0 % would be a lie.
+     * @param {string} params.deletedAt - When the product was soft-deleted. `GET /products/grid` and every category-rule evaluation exclude a row that carries one; `GET /products` does NOT — filter on it to read the live catalog.
+     * @param {boolean} params.enabled - Whether the product is offered. A create defaults it from the `new_products_enabled_by_default` tenant setting rather than blindly to true, so an import does not publish twenty thousand unfinished products the moment it lands. An explicit value in the body always wins.
+     * @param {string} params.familyId - The family that decides which attributes this product HAS. Without one nothing is required, completeness cannot be computed and the display name never resolves — `POST /products/{id}/family` is the call that sets it and computes completeness in the same step.
+     * @param {string} params.familyVariantId - Which variant structure of the family this product follows — the axes it splits on. Null on a simple product.
+     * @param {ProductsKind} params.kind - Where the product sits in the variant hierarchy. 'simple' stands on its own. 'model' carries the values its variants share and is never sold itself. 'variant' carries the axis values and points at its model through `parent_id`.
+     * @param {string} params.parentId - The product MODEL this variant belongs to. Only a `variant` carries one. Deleting the model leaves its variants behind with a null parent rather than deleting them.
+     * @param {object} params.quantifiedAssociations - The import-side mirror of associations that carry a quantity — a bundle, a bill of materials, a spare-parts set. NOTHING IN THIS APP READS OR WRITES IT: no route produces it, no route consumes it, and it is null on every product this app has created. The surface that IS served is relational — `product_associations`, whose `quantity` column holds the number, guarded by `association_types.is_quantified`.
+
+It exists because a PIM import (Akeneo, BMEcat) carries these in one blob keyed by association type code, and the column lets that document round-trip instead of being dropped. The database enforces no shape on it, so what a reader finds is whatever the importer wrote; the example is the conventional form.
+     * @param {string} params.sku - The merchant's own article number — unique per tenant, and the value every integration (ERP, shop, feed, price list) joins on. The one identifier a person types, and the fallback this app shows when the catalog holds no name.
+     * @param {string} params.taxClass - The tax class key the prices app resolves a VAT rate from. Free text here — the vocabulary belongs to the app that prices, and `POST /products/batch` exists to hand exactly this column to it in bulk.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
      */
-    productsAttributesDelete(params: {
+    productsUpdate(params: {
         id: string;
-    }): Promise<{}>;
+        attributeValues?: object;
+        completeness?: object;
+        deletedAt?: string;
+        enabled?: boolean;
+        familyId?: string;
+        familyVariantId?: string;
+        kind?: ProductsKind;
+        parentId?: string;
+        quantifiedAssociations?: object;
+        sku?: string;
+        taxClass?: string;
+    }): Promise<Models.Error>;
     /**
+     * Updates one product by id. A partial patch: the body names only the columns to change and every column it leaves out keeps its current value, so there is no read-modify-write and no way to blank a field by forgetting it.
      *
-     * @param {string} id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsAttributesDelete(id: string): Promise<{}>;
-    /**
+     * The catalog itself. A product row carries only what every product has — SKU, kind, family, enabled, tax class — and everything the tenant modelled lives in the `attribute_values` jsonb document, keyed by attribute CODE inside one of four scope buckets (common, per locale, per channel, per channel and locale). `label` is a generated column, maintained by the database so a grid of twenty thousand rows can sort and filter on a name with no join. `kind` says where the row sits in the variant hierarchy: a `model` carries what its variants share and is never sold itself.
      *
-     * @param {string} params.id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.Attributes>}
-     */
-    productsAttributesGet(params: {
-        id: string;
-    }): Promise<Models.Attributes>;
-    /**
+     * A body that names nothing writable is refused with 400 rather than answered as a no-op, an id nobody carries answers 404, and a value that collides on `sku` answers 409. `label` is a generated column: naming it is dropped rather than refused, and `completeness` is written by the two metadata routes, not here.
      *
-     * @param {string} id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.Attributes>}
+     * @param {string} id - The `products` row to address, by id. It names a row THIS TENANT holds, so no example is published — a uuid this app invented would document a call that answers 404, and a real one would be another tenant's data. Read one from `GET /v1/products`. An id no product of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @param {object} attributeValues - Every attribute value the record carries, in ONE jsonb document — the core of an attribute-driven PIM. A record's properties are not columns here: they are rows in `attributes`, selected per family by `family_attributes`, and their values live under their attribute CODE inside this object.
+
+Four buckets, and an attribute's own flags decide which one it writes to:
+
+  `common`                    the attribute is neither localizable nor scopable — one value, full stop.
+                              `{"common": {"net_weight": 2.4, "colour": "black"}}`
+  `locale_specific`           `localizable`: one value per language tag.
+                              `{"locale_specific": {"de_DE": {"name": "Akku-Bohrschrauber"}}}`
+  `channel_specific`          `scopable`: one value per channel.
+                              `{"channel_specific": {"b2b": {"minimum_order_quantity": 6}}}`
+  `channel_locale_specific`   both: one value per channel AND language tag.
+                              `{"channel_locale_specific": {"b2b": {"de_DE": {"description": "…"}}}}`
+
+A reader takes the most specific bucket that carries the code and falls back through locale, then channel, then `common`. `common` is always last and always consulted, because early imports wrote everything there whatever an attribute's flags said — a reader that skipped it reports an imported catalog as empty. `GET /products/attribute-schema` answers, per field, the exact path a value belongs at (`storage.path`) and that full fallback order (`from`), so no client has to re-derive any of this.
+
+The value itself is whatever the attribute's `type` implies: a string, a number, a boolean, an option CODE for a select (never its label), a list of codes for a multi-select, `{"amount": …, "unit": …}` for a measure, a list of `{"amount": …, "currency": …}` for a price, an asset code for media.
+
+Defaults to `{}`, and an empty object is a normal state — a record nobody has enriched yet. The declared type also admits an array only because every jsonb column of this app shares one mapping; an array is not meaningful here and every reader in this app treats a non-object as empty.
+     * @param {object} completeness - How much of what this product's family REQUIRES it actually carries — the number a merchandiser works down. `required` counts the attributes the family marks `is_required`, `filled` how many of those carry a value in ANY bucket, `ratio` is filled/required between 0 and 1 (a family that requires nothing is 1, not undefined), `missing` lists the codes with no value anywhere, sorted, and `computed_at` is when it was measured.
+
+Written only by `POST /products/{id}/completeness` and by `POST /products/{id}/family`; a plain create or update never touches it, so it is null until one of the two has run. It also stays null for a product with no family — there is nothing to measure it against, and 0 % would be a lie.
+     * @param {string} deletedAt - When the product was soft-deleted. `GET /products/grid` and every category-rule evaluation exclude a row that carries one; `GET /products` does NOT — filter on it to read the live catalog.
+     * @param {boolean} enabled - Whether the product is offered. A create defaults it from the `new_products_enabled_by_default` tenant setting rather than blindly to true, so an import does not publish twenty thousand unfinished products the moment it lands. An explicit value in the body always wins.
+     * @param {string} familyId - The family that decides which attributes this product HAS. Without one nothing is required, completeness cannot be computed and the display name never resolves — `POST /products/{id}/family` is the call that sets it and computes completeness in the same step.
+     * @param {string} familyVariantId - Which variant structure of the family this product follows — the axes it splits on. Null on a simple product.
+     * @param {ProductsKind} kind - Where the product sits in the variant hierarchy. 'simple' stands on its own. 'model' carries the values its variants share and is never sold itself. 'variant' carries the axis values and points at its model through `parent_id`.
+     * @param {string} parentId - The product MODEL this variant belongs to. Only a `variant` carries one. Deleting the model leaves its variants behind with a null parent rather than deleting them.
+     * @param {object} quantifiedAssociations - The import-side mirror of associations that carry a quantity — a bundle, a bill of materials, a spare-parts set. NOTHING IN THIS APP READS OR WRITES IT: no route produces it, no route consumes it, and it is null on every product this app has created. The surface that IS served is relational — `product_associations`, whose `quantity` column holds the number, guarded by `association_types.is_quantified`.
+
+It exists because a PIM import (Akeneo, BMEcat) carries these in one blob keyed by association type code, and the column lets that document round-trip instead of being dropped. The database enforces no shape on it, so what a reader finds is whatever the importer wrote; the example is the conventional form.
+     * @param {string} sku - The merchant's own article number — unique per tenant, and the value every integration (ERP, shop, feed, price list) joins on. The one identifier a person types, and the fallback this app shows when the catalog holds no name.
+     * @param {string} taxClass - The tax class key the prices app resolves a VAT rate from. Free text here — the vocabulary belongs to the app that prices, and `POST /products/batch` exists to hand exactly this column to it in bulk.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    productsAttributesGet(id: string): Promise<Models.Attributes>;
+    productsUpdate(id: string, attributeValues?: object, completeness?: object, deletedAt?: string, enabled?: boolean, familyId?: string, familyVariantId?: string, kind?: ProductsKind, parentId?: string, quantifiedAssociations?: object, sku?: string, taxClass?: string): Promise<Models.Error>;
     /**
+     * How much of what its family REQUIRES does this product actually carry — the number a merchandiser works down. products.completeness is jsonb that nothing had ever written. This computes it from family_attributes (is_required) against the product's own scoped attribute_values and stores the result. A product with no family answers 400 rather than an invented 0 % — it has nothing to be measured against.
      *
-     * @param {string} params.id -
-     * @param {string} params.code -
-     * @param {object} params.config -
-     * @param {string} params.entityRef -
-     * @param {string} params.entityType -
-     * @param {string} params.groupId -
-     * @param {boolean} params.isFilterable -
-     * @param {boolean} params.isUnique -
-     * @param {object} params.labels -
-     * @param {boolean} params.localizable -
-     * @param {number} params.position -
-     * @param {boolean} params.scopable -
-     * @param {string} params.type -
-     * @param {boolean} params.usableInGrid -
-     * @param {object} params.validation -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.Attributes>}
+     * @param {string} params.id - The `products` row to address, by id. It names a row THIS TENANT holds, so no example is published — a uuid this app invented would document a call that answers 404, and a real one would be another tenant's data. Read one from `GET /v1/products`. An id no product of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @param {object} params.data - Request body
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
      */
-    productsAttributesUpdate(params: {
+    productsCompleteness(params: {
         id: string;
-        code?: string;
-        config?: object;
-        entityRef?: string;
-        entityType?: string;
-        groupId?: string;
-        isFilterable?: boolean;
-        isUnique?: boolean;
-        labels?: object;
-        localizable?: boolean;
-        position?: number;
-        scopable?: boolean;
-        type?: string;
-        usableInGrid?: boolean;
-        validation?: object;
-    }): Promise<Models.Attributes>;
+        data: object;
+    }): Promise<Models.Error>;
     /**
+     * How much of what its family REQUIRES does this product actually carry — the number a merchandiser works down. products.completeness is jsonb that nothing had ever written. This computes it from family_attributes (is_required) against the product's own scoped attribute_values and stores the result. A product with no family answers 400 rather than an invented 0 % — it has nothing to be measured against.
      *
-     * @param {string} id -
-     * @param {string} code -
-     * @param {object} config -
-     * @param {string} entityRef -
-     * @param {string} entityType -
-     * @param {string} groupId -
-     * @param {boolean} isFilterable -
-     * @param {boolean} isUnique -
-     * @param {object} labels -
-     * @param {boolean} localizable -
-     * @param {number} position -
-     * @param {boolean} scopable -
-     * @param {string} type -
-     * @param {boolean} usableInGrid -
-     * @param {object} validation -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.Attributes>}
+     * @param {string} id - The `products` row to address, by id. It names a row THIS TENANT holds, so no example is published — a uuid this app invented would document a call that answers 404, and a real one would be another tenant's data. Read one from `GET /v1/products`. An id no product of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @param {object} data - Request body
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    productsAttributesUpdate(id: string, code?: string, config?: object, entityRef?: string, entityType?: string, groupId?: string, isFilterable?: boolean, isUnique?: boolean, labels?: object, localizable?: boolean, position?: number, scopable?: boolean, type?: string, usableInGrid?: boolean, validation?: object): Promise<Models.Attributes>;
+    productsCompleteness(id: string, data: object): Promise<Models.Error>;
     /**
+     * Names the family in the body — by `family_id` or by `family_code`, whichever the caller holds — and computes the product's completeness in the same call. The step every family-driven surface waits on: a product with no family has no required attributes, so its completeness cannot be computed and its family's label attribute never resolves. Assigning the family recomputes and STORES products.completeness immediately, so the metadata cannot go stale between the two operations.
      *
-     * @param {string[]} params.ids -
-     * @param {string[]} params.skus -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
+     * @param {string} params.id - The `products` row to address, by id. It names a row THIS TENANT holds, so no example is published — a uuid this app invented would document a call that answers 404, and a real one would be another tenant's data. Read one from `GET /v1/products`. An id no product of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @param {string} params.familyCode - Alternative to family_id — a `families.code` this tenant holds, from `GET /products/families`. No example: a code is tenant data, and any value published here names a family somebody does not have.
+     * @param {string} params.familyId - The family to assign.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
      */
-    productsBatch(params?: {
-        ids?: string[];
-        skus?: string[];
-    }): Promise<{}>;
-    /**
-     *
-     * @param {string[]} ids -
-     * @param {string[]} skus -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsBatch(ids?: string[], skus?: string[]): Promise<{}>;
-    /**
-     *
-     * @param {number} params.limit - Page size (default 50, max 200).
-     * @param {number} params.offset - Row offset for pagination (default 0).
-     * @param {string} params.order - Sort as 'column.asc' | 'column.desc', e.g. 'created_at.desc'.
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     */
-    productsCategoriesList(params?: {
-        limit?: number;
-        offset?: number;
-        order?: string;
-    }): Promise<{}>;
-    /**
-     *
-     * @param {number} limit - Page size (default 50, max 200).
-     * @param {number} offset - Row offset for pagination (default 0).
-     * @param {string} order - Sort as 'column.asc' | 'column.desc', e.g. 'created_at.desc'.
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsCategoriesList(limit?: number, offset?: number, order?: string): Promise<{}>;
-    /**
-     *
-     * @param {string} params.code -
-     * @param {object} params.labels -
-     * @param {string} params.parentId -
-     * @param {string} params.xpath -
-     * @param {number} params.position -
-     * @param {object} params.values -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.Categories>}
-     */
-    productsCategoriesCreate(params: {
-        code: string;
-        labels?: object;
-        parentId?: string;
-        xpath?: string;
-        position?: number;
-        values?: object;
-    }): Promise<Models.Categories>;
-    /**
-     *
-     * @param {string} code -
-     * @param {object} labels -
-     * @param {string} parentId -
-     * @param {string} xpath -
-     * @param {number} position -
-     * @param {object} values -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.Categories>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsCategoriesCreate(code: string, labels?: object, parentId?: string, xpath?: string, position?: number, values?: object): Promise<Models.Categories>;
-    /**
-     *
-     * @param {string} params.id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     */
-    productsCategoriesDelete(params: {
-        id: string;
-    }): Promise<{}>;
-    /**
-     *
-     * @param {string} id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsCategoriesDelete(id: string): Promise<{}>;
-    /**
-     *
-     * @param {string} params.id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.Categories>}
-     */
-    productsCategoriesGet(params: {
-        id: string;
-    }): Promise<Models.Categories>;
-    /**
-     *
-     * @param {string} id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.Categories>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsCategoriesGet(id: string): Promise<Models.Categories>;
-    /**
-     *
-     * @param {string} params.id -
-     * @param {string} params.code -
-     * @param {object} params.labels -
-     * @param {string} params.parentId -
-     * @param {string} params.xpath -
-     * @param {number} params.position -
-     * @param {object} params.values -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.Categories>}
-     */
-    productsCategoriesUpdate(params: {
-        id: string;
-        code?: string;
-        labels?: object;
-        parentId?: string;
-        xpath?: string;
-        position?: number;
-        values?: object;
-    }): Promise<Models.Categories>;
-    /**
-     *
-     * @param {string} id -
-     * @param {string} code -
-     * @param {object} labels -
-     * @param {string} parentId -
-     * @param {string} xpath -
-     * @param {number} position -
-     * @param {object} values -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.Categories>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsCategoriesUpdate(id: string, code?: string, labels?: object, parentId?: string, xpath?: string, position?: number, values?: object): Promise<Models.Categories>;
-    /**
-     *
-     * @param {number} params.limit - Page size (default 50, max 200).
-     * @param {number} params.offset - Row offset for pagination (default 0).
-     * @param {string} params.order - Sort as 'column.asc' | 'column.desc', e.g. 'created_at.desc'.
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     */
-    productsFamiliesList(params?: {
-        limit?: number;
-        offset?: number;
-        order?: string;
-    }): Promise<{}>;
-    /**
-     *
-     * @param {number} limit - Page size (default 50, max 200).
-     * @param {number} offset - Row offset for pagination (default 0).
-     * @param {string} order - Sort as 'column.asc' | 'column.desc', e.g. 'created_at.desc'.
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsFamiliesList(limit?: number, offset?: number, order?: string): Promise<{}>;
-    /**
-     *
-     * @param {string} params.code -
-     * @param {string} params.imageAttribute -
-     * @param {string} params.labelAttribute -
-     * @param {object} params.labels -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.Families>}
-     */
-    productsFamiliesCreate(params: {
-        code: string;
-        imageAttribute?: string;
-        labelAttribute?: string;
-        labels?: object;
-    }): Promise<Models.Families>;
-    /**
-     *
-     * @param {string} code -
-     * @param {string} imageAttribute -
-     * @param {string} labelAttribute -
-     * @param {object} labels -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.Families>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsFamiliesCreate(code: string, imageAttribute?: string, labelAttribute?: string, labels?: object): Promise<Models.Families>;
-    /**
-     *
-     * @param {string} params.id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     */
-    productsFamiliesDelete(params: {
-        id: string;
-    }): Promise<{}>;
-    /**
-     *
-     * @param {string} id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsFamiliesDelete(id: string): Promise<{}>;
-    /**
-     *
-     * @param {string} params.id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.Families>}
-     */
-    productsFamiliesGet(params: {
-        id: string;
-    }): Promise<Models.Families>;
-    /**
-     *
-     * @param {string} id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.Families>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsFamiliesGet(id: string): Promise<Models.Families>;
-    /**
-     *
-     * @param {string} params.id -
-     * @param {string} params.code -
-     * @param {string} params.imageAttribute -
-     * @param {string} params.labelAttribute -
-     * @param {object} params.labels -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.Families>}
-     */
-    productsFamiliesUpdate(params: {
-        id: string;
-        code?: string;
-        imageAttribute?: string;
-        labelAttribute?: string;
-        labels?: object;
-    }): Promise<Models.Families>;
-    /**
-     *
-     * @param {string} id -
-     * @param {string} code -
-     * @param {string} imageAttribute -
-     * @param {string} labelAttribute -
-     * @param {object} labels -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.Families>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsFamiliesUpdate(id: string, code?: string, imageAttribute?: string, labelAttribute?: string, labels?: object): Promise<Models.Families>;
-    /**
-     *
-     * @param {number} params.limit - Page size (default 50, max 200).
-     * @param {number} params.offset - Row offset for pagination (default 0).
-     * @param {string} params.order - Sort as 'column.asc' | 'column.desc', e.g. 'created_at.desc'.
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     */
-    productsFamilyAttributesList(params?: {
-        limit?: number;
-        offset?: number;
-        order?: string;
-    }): Promise<{}>;
-    /**
-     *
-     * @param {number} limit - Page size (default 50, max 200).
-     * @param {number} offset - Row offset for pagination (default 0).
-     * @param {string} order - Sort as 'column.asc' | 'column.desc', e.g. 'created_at.desc'.
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsFamilyAttributesList(limit?: number, offset?: number, order?: string): Promise<{}>;
-    /**
-     *
-     * @param {string} params.attributeId -
-     * @param {string} params.familyId -
-     * @param {boolean} params.isRequired -
-     * @param {number} params.position -
-     * @param {object} params.requiredChannels -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.FamilyAttributes>}
-     */
-    productsFamilyAttributesCreate(params: {
-        attributeId: string;
-        familyId: string;
-        isRequired?: boolean;
-        position?: number;
-        requiredChannels?: object;
-    }): Promise<Models.FamilyAttributes>;
-    /**
-     *
-     * @param {string} attributeId -
-     * @param {string} familyId -
-     * @param {boolean} isRequired -
-     * @param {number} position -
-     * @param {object} requiredChannels -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.FamilyAttributes>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsFamilyAttributesCreate(attributeId: string, familyId: string, isRequired?: boolean, position?: number, requiredChannels?: object): Promise<Models.FamilyAttributes>;
-    /**
-     *
-     * @param {string} params.id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     */
-    productsFamilyAttributesDelete(params: {
-        id: string;
-    }): Promise<{}>;
-    /**
-     *
-     * @param {string} id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsFamilyAttributesDelete(id: string): Promise<{}>;
-    /**
-     *
-     * @param {string} params.id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.FamilyAttributes>}
-     */
-    productsFamilyAttributesGet(params: {
-        id: string;
-    }): Promise<Models.FamilyAttributes>;
-    /**
-     *
-     * @param {string} id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.FamilyAttributes>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsFamilyAttributesGet(id: string): Promise<Models.FamilyAttributes>;
-    /**
-     *
-     * @param {string} params.id -
-     * @param {string} params.attributeId -
-     * @param {string} params.familyId -
-     * @param {boolean} params.isRequired -
-     * @param {number} params.position -
-     * @param {object} params.requiredChannels -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.FamilyAttributes>}
-     */
-    productsFamilyAttributesUpdate(params: {
-        id: string;
-        attributeId?: string;
-        familyId?: string;
-        isRequired?: boolean;
-        position?: number;
-        requiredChannels?: object;
-    }): Promise<Models.FamilyAttributes>;
-    /**
-     *
-     * @param {string} id -
-     * @param {string} attributeId -
-     * @param {string} familyId -
-     * @param {boolean} isRequired -
-     * @param {number} position -
-     * @param {object} requiredChannels -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.FamilyAttributes>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsFamilyAttributesUpdate(id: string, attributeId?: string, familyId?: string, isRequired?: boolean, position?: number, requiredChannels?: object): Promise<Models.FamilyAttributes>;
-    /**
-     *
-     * @param {number} params.limit - Page size (default 50, max 200).
-     * @param {number} params.offset - Row offset for pagination (default 0).
-     * @param {string} params.order - Sort as 'column.asc' | 'column.desc', e.g. 'created_at.desc'.
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     */
-    productsFamilyVariantsList(params?: {
-        limit?: number;
-        offset?: number;
-        order?: string;
-    }): Promise<{}>;
-    /**
-     *
-     * @param {number} limit - Page size (default 50, max 200).
-     * @param {number} offset - Row offset for pagination (default 0).
-     * @param {string} order - Sort as 'column.asc' | 'column.desc', e.g. 'created_at.desc'.
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsFamilyVariantsList(limit?: number, offset?: number, order?: string): Promise<{}>;
-    /**
-     *
-     * @param {string} params.code -
-     * @param {string} params.familyId -
-     * @param {object} params.axes -
-     * @param {object} params.labels -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.FamilyVariants>}
-     */
-    productsFamilyVariantsCreate(params: {
-        code: string;
-        familyId: string;
-        axes?: object;
-        labels?: object;
-    }): Promise<Models.FamilyVariants>;
-    /**
-     *
-     * @param {string} code -
-     * @param {string} familyId -
-     * @param {object} axes -
-     * @param {object} labels -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.FamilyVariants>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsFamilyVariantsCreate(code: string, familyId: string, axes?: object, labels?: object): Promise<Models.FamilyVariants>;
-    /**
-     *
-     * @param {string} params.id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     */
-    productsFamilyVariantsDelete(params: {
-        id: string;
-    }): Promise<{}>;
-    /**
-     *
-     * @param {string} id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsFamilyVariantsDelete(id: string): Promise<{}>;
-    /**
-     *
-     * @param {string} params.id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.FamilyVariants>}
-     */
-    productsFamilyVariantsGet(params: {
-        id: string;
-    }): Promise<Models.FamilyVariants>;
-    /**
-     *
-     * @param {string} id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.FamilyVariants>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsFamilyVariantsGet(id: string): Promise<Models.FamilyVariants>;
-    /**
-     *
-     * @param {string} params.id -
-     * @param {object} params.axes -
-     * @param {string} params.code -
-     * @param {string} params.familyId -
-     * @param {object} params.labels -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.FamilyVariants>}
-     */
-    productsFamilyVariantsUpdate(params: {
-        id: string;
-        axes?: object;
-        code?: string;
-        familyId?: string;
-        labels?: object;
-    }): Promise<Models.FamilyVariants>;
-    /**
-     *
-     * @param {string} id -
-     * @param {object} axes -
-     * @param {string} code -
-     * @param {string} familyId -
-     * @param {object} labels -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.FamilyVariants>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsFamilyVariantsUpdate(id: string, axes?: object, code?: string, familyId?: string, labels?: object): Promise<Models.FamilyVariants>;
-    /**
-     *
-     * @param {number} params.limit - Page size (default 50, max 200).
-     * @param {number} params.offset - Row offset for pagination (default 0).
-     * @param {string} params.order - Sort as 'column.asc' | 'column.desc', e.g. 'created_at.desc'.
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     */
-    productsMeasurementFamiliesList(params?: {
-        limit?: number;
-        offset?: number;
-        order?: string;
-    }): Promise<{}>;
-    /**
-     *
-     * @param {number} limit - Page size (default 50, max 200).
-     * @param {number} offset - Row offset for pagination (default 0).
-     * @param {string} order - Sort as 'column.asc' | 'column.desc', e.g. 'created_at.desc'.
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsMeasurementFamiliesList(limit?: number, offset?: number, order?: string): Promise<{}>;
-    /**
-     *
-     * @param {string} params.code -
-     * @param {string} params.standardUnit -
-     * @param {object} params.labels -
-     * @param {object} params.units -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.MeasurementFamilies>}
-     */
-    productsMeasurementFamiliesCreate(params: {
-        code: string;
-        standardUnit: string;
-        labels?: object;
-        units?: object;
-    }): Promise<Models.MeasurementFamilies>;
-    /**
-     *
-     * @param {string} code -
-     * @param {string} standardUnit -
-     * @param {object} labels -
-     * @param {object} units -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.MeasurementFamilies>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsMeasurementFamiliesCreate(code: string, standardUnit: string, labels?: object, units?: object): Promise<Models.MeasurementFamilies>;
-    /**
-     *
-     * @param {string} params.id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     */
-    productsMeasurementFamiliesDelete(params: {
-        id: string;
-    }): Promise<{}>;
-    /**
-     *
-     * @param {string} id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsMeasurementFamiliesDelete(id: string): Promise<{}>;
-    /**
-     *
-     * @param {string} params.id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.MeasurementFamilies>}
-     */
-    productsMeasurementFamiliesGet(params: {
-        id: string;
-    }): Promise<Models.MeasurementFamilies>;
-    /**
-     *
-     * @param {string} id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.MeasurementFamilies>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsMeasurementFamiliesGet(id: string): Promise<Models.MeasurementFamilies>;
-    /**
-     *
-     * @param {string} params.id -
-     * @param {string} params.code -
-     * @param {object} params.labels -
-     * @param {string} params.standardUnit -
-     * @param {object} params.units -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.MeasurementFamilies>}
-     */
-    productsMeasurementFamiliesUpdate(params: {
-        id: string;
-        code?: string;
-        labels?: object;
-        standardUnit?: string;
-        units?: object;
-    }): Promise<Models.MeasurementFamilies>;
-    /**
-     *
-     * @param {string} id -
-     * @param {string} code -
-     * @param {object} labels -
-     * @param {string} standardUnit -
-     * @param {object} units -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.MeasurementFamilies>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsMeasurementFamiliesUpdate(id: string, code?: string, labels?: object, standardUnit?: string, units?: object): Promise<Models.MeasurementFamilies>;
-    /**
-     *
-     * @param {number} params.limit - Page size (default 50, max 200).
-     * @param {number} params.offset - Row offset for pagination (default 0).
-     * @param {string} params.order - Sort as 'column.asc' | 'column.desc', e.g. 'created_at.desc'.
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     */
-    productsProductAssociationsList(params?: {
-        limit?: number;
-        offset?: number;
-        order?: string;
-    }): Promise<{}>;
-    /**
-     *
-     * @param {number} limit - Page size (default 50, max 200).
-     * @param {number} offset - Row offset for pagination (default 0).
-     * @param {string} order - Sort as 'column.asc' | 'column.desc', e.g. 'created_at.desc'.
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsProductAssociationsList(limit?: number, offset?: number, order?: string): Promise<{}>;
-    /**
-     *
-     * @param {string} params.associationTypeId -
-     * @param {string} params.productId -
-     * @param {string} params.targetProductId -
-     * @param {number} params.position -
-     * @param {number} params.quantity -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.ProductAssociations>}
-     */
-    productsProductAssociationsCreate(params: {
-        associationTypeId: string;
-        productId: string;
-        targetProductId: string;
-        position?: number;
-        quantity?: number;
-    }): Promise<Models.ProductAssociations>;
-    /**
-     *
-     * @param {string} associationTypeId -
-     * @param {string} productId -
-     * @param {string} targetProductId -
-     * @param {number} position -
-     * @param {number} quantity -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.ProductAssociations>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsProductAssociationsCreate(associationTypeId: string, productId: string, targetProductId: string, position?: number, quantity?: number): Promise<Models.ProductAssociations>;
-    /**
-     *
-     * @param {string} params.id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     */
-    productsProductAssociationsDelete(params: {
-        id: string;
-    }): Promise<{}>;
-    /**
-     *
-     * @param {string} id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsProductAssociationsDelete(id: string): Promise<{}>;
-    /**
-     *
-     * @param {string} params.id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.ProductAssociations>}
-     */
-    productsProductAssociationsGet(params: {
+    productsFamilyAssign(params: {
         id: string;
-    }): Promise<Models.ProductAssociations>;
-    /**
-     *
-     * @param {string} id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.ProductAssociations>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsProductAssociationsGet(id: string): Promise<Models.ProductAssociations>;
-    /**
-     *
-     * @param {string} params.id -
-     * @param {string} params.associationTypeId -
-     * @param {number} params.position -
-     * @param {string} params.productId -
-     * @param {number} params.quantity -
-     * @param {string} params.targetProductId -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.ProductAssociations>}
-     */
-    productsProductAssociationsUpdate(params: {
-        id: string;
-        associationTypeId?: string;
-        position?: number;
-        productId?: string;
-        quantity?: number;
-        targetProductId?: string;
-    }): Promise<Models.ProductAssociations>;
-    /**
-     *
-     * @param {string} id -
-     * @param {string} associationTypeId -
-     * @param {number} position -
-     * @param {string} productId -
-     * @param {number} quantity -
-     * @param {string} targetProductId -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.ProductAssociations>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsProductAssociationsUpdate(id: string, associationTypeId?: string, position?: number, productId?: string, quantity?: number, targetProductId?: string): Promise<Models.ProductAssociations>;
-    /**
-     *
-     * @param {number} params.limit - Page size (default 50, max 200).
-     * @param {number} params.offset - Row offset for pagination (default 0).
-     * @param {string} params.order - Sort as 'column.asc' | 'column.desc', e.g. 'created_at.desc'.
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     */
-    productsProductCategoriesList(params?: {
-        limit?: number;
-        offset?: number;
-        order?: string;
-    }): Promise<{}>;
-    /**
-     *
-     * @param {number} limit - Page size (default 50, max 200).
-     * @param {number} offset - Row offset for pagination (default 0).
-     * @param {string} order - Sort as 'column.asc' | 'column.desc', e.g. 'created_at.desc'.
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsProductCategoriesList(limit?: number, offset?: number, order?: string): Promise<{}>;
-    /**
-     *
-     * @param {string} params.categoryId -
-     * @param {string} params.productId -
-     * @param {number} params.position -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.ProductCategories>}
-     */
-    productsProductCategoriesCreate(params: {
-        categoryId: string;
-        productId: string;
-        position?: number;
-    }): Promise<Models.ProductCategories>;
-    /**
-     *
-     * @param {string} categoryId -
-     * @param {string} productId -
-     * @param {number} position -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.ProductCategories>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsProductCategoriesCreate(categoryId: string, productId: string, position?: number): Promise<Models.ProductCategories>;
-    /**
-     *
-     * @param {string} params.id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     */
-    productsProductCategoriesDelete(params: {
-        id: string;
-    }): Promise<{}>;
-    /**
-     *
-     * @param {string} id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsProductCategoriesDelete(id: string): Promise<{}>;
-    /**
-     *
-     * @param {string} params.id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.ProductCategories>}
-     */
-    productsProductCategoriesGet(params: {
-        id: string;
-    }): Promise<Models.ProductCategories>;
-    /**
-     *
-     * @param {string} id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.ProductCategories>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsProductCategoriesGet(id: string): Promise<Models.ProductCategories>;
-    /**
-     *
-     * @param {string} params.id -
-     * @param {string} params.categoryId -
-     * @param {number} params.position -
-     * @param {string} params.productId -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.ProductCategories>}
-     */
-    productsProductCategoriesUpdate(params: {
-        id: string;
-        categoryId?: string;
-        position?: number;
-        productId?: string;
-    }): Promise<Models.ProductCategories>;
-    /**
-     *
-     * @param {string} id -
-     * @param {string} categoryId -
-     * @param {number} position -
-     * @param {string} productId -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.ProductCategories>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsProductCategoriesUpdate(id: string, categoryId?: string, position?: number, productId?: string): Promise<Models.ProductCategories>;
-    /**
-     *
-     * @param {number} params.limit - Page size (default 50, max 200).
-     * @param {number} params.offset - Row offset for pagination (default 0).
-     * @param {string} params.order - Sort as 'column.asc' | 'column.desc', e.g. 'created_at.desc'.
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     */
-    productsReferenceEntitiesList(params?: {
-        limit?: number;
-        offset?: number;
-        order?: string;
-    }): Promise<{}>;
-    /**
-     *
-     * @param {number} limit - Page size (default 50, max 200).
-     * @param {number} offset - Row offset for pagination (default 0).
-     * @param {string} order - Sort as 'column.asc' | 'column.desc', e.g. 'created_at.desc'.
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsReferenceEntitiesList(limit?: number, offset?: number, order?: string): Promise<{}>;
-    /**
-     *
-     * @param {string} params.code -
-     * @param {string} params.image -
-     * @param {object} params.labels -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.ReferenceEntities>}
-     */
-    productsReferenceEntitiesCreate(params: {
-        code: string;
-        image?: string;
-        labels?: object;
-    }): Promise<Models.ReferenceEntities>;
-    /**
-     *
-     * @param {string} code -
-     * @param {string} image -
-     * @param {object} labels -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.ReferenceEntities>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsReferenceEntitiesCreate(code: string, image?: string, labels?: object): Promise<Models.ReferenceEntities>;
-    /**
-     *
-     * @param {string} params.id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     */
-    productsReferenceEntitiesDelete(params: {
-        id: string;
-    }): Promise<{}>;
-    /**
-     *
-     * @param {string} id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsReferenceEntitiesDelete(id: string): Promise<{}>;
-    /**
-     *
-     * @param {string} params.id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.ReferenceEntities>}
-     */
-    productsReferenceEntitiesGet(params: {
-        id: string;
-    }): Promise<Models.ReferenceEntities>;
-    /**
-     *
-     * @param {string} id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.ReferenceEntities>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsReferenceEntitiesGet(id: string): Promise<Models.ReferenceEntities>;
-    /**
-     *
-     * @param {string} params.id -
-     * @param {string} params.code -
-     * @param {string} params.image -
-     * @param {object} params.labels -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.ReferenceEntities>}
-     */
-    productsReferenceEntitiesUpdate(params: {
-        id: string;
-        code?: string;
-        image?: string;
-        labels?: object;
-    }): Promise<Models.ReferenceEntities>;
-    /**
-     *
-     * @param {string} id -
-     * @param {string} code -
-     * @param {string} image -
-     * @param {object} labels -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.ReferenceEntities>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsReferenceEntitiesUpdate(id: string, code?: string, image?: string, labels?: object): Promise<Models.ReferenceEntities>;
-    /**
-     *
-     * @param {number} params.limit - Page size (default 50, max 200).
-     * @param {number} params.offset - Row offset for pagination (default 0).
-     * @param {string} params.order - Sort as 'column.asc' | 'column.desc', e.g. 'created_at.desc'.
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     */
-    productsReferenceEntityRecordsList(params?: {
-        limit?: number;
-        offset?: number;
-        order?: string;
-    }): Promise<{}>;
-    /**
-     *
-     * @param {number} limit - Page size (default 50, max 200).
-     * @param {number} offset - Row offset for pagination (default 0).
-     * @param {string} order - Sort as 'column.asc' | 'column.desc', e.g. 'created_at.desc'.
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsReferenceEntityRecordsList(limit?: number, offset?: number, order?: string): Promise<{}>;
-    /**
-     *
-     * @param {string} params.code -
-     * @param {string} params.referenceEntityId -
-     * @param {object} params.attributeValues -
-     * @param {object} params.labels -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.ReferenceEntityRecords>}
-     */
-    productsReferenceEntityRecordsCreate(params: {
-        code: string;
-        referenceEntityId: string;
-        attributeValues?: object;
-        labels?: object;
-    }): Promise<Models.ReferenceEntityRecords>;
-    /**
-     *
-     * @param {string} code -
-     * @param {string} referenceEntityId -
-     * @param {object} attributeValues -
-     * @param {object} labels -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.ReferenceEntityRecords>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsReferenceEntityRecordsCreate(code: string, referenceEntityId: string, attributeValues?: object, labels?: object): Promise<Models.ReferenceEntityRecords>;
-    /**
-     *
-     * @param {string} params.id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     */
-    productsReferenceEntityRecordsDelete(params: {
-        id: string;
-    }): Promise<{}>;
-    /**
-     *
-     * @param {string} id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsReferenceEntityRecordsDelete(id: string): Promise<{}>;
-    /**
-     *
-     * @param {string} params.id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.ReferenceEntityRecords>}
-     */
-    productsReferenceEntityRecordsGet(params: {
-        id: string;
-    }): Promise<Models.ReferenceEntityRecords>;
-    /**
-     *
-     * @param {string} id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.ReferenceEntityRecords>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsReferenceEntityRecordsGet(id: string): Promise<Models.ReferenceEntityRecords>;
-    /**
-     *
-     * @param {string} params.id -
-     * @param {object} params.attributeValues -
-     * @param {string} params.code -
-     * @param {object} params.labels -
-     * @param {string} params.referenceEntityId -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.ReferenceEntityRecords>}
-     */
-    productsReferenceEntityRecordsUpdate(params: {
-        id: string;
-        attributeValues?: object;
-        code?: string;
-        labels?: object;
-        referenceEntityId?: string;
-    }): Promise<Models.ReferenceEntityRecords>;
-    /**
-     *
-     * @param {string} id -
-     * @param {object} attributeValues -
-     * @param {string} code -
-     * @param {object} labels -
-     * @param {string} referenceEntityId -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.ReferenceEntityRecords>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsReferenceEntityRecordsUpdate(id: string, attributeValues?: object, code?: string, labels?: object, referenceEntityId?: string): Promise<Models.ReferenceEntityRecords>;
-    /**
-     *
-     * @param {string} params.id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     */
-    productsDelete(params: {
-        id: string;
-    }): Promise<{}>;
-    /**
-     *
-     * @param {string} id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<{}>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsDelete(id: string): Promise<{}>;
-    /**
-     *
-     * @param {string} params.id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.Products>}
-     */
-    productsGet(params: {
-        id: string;
-    }): Promise<Models.Products>;
-    /**
-     *
-     * @param {string} id -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.Products>}
-     * @deprecated Use the object parameter style method for a better developer experience.
-     */
-    productsGet(id: string): Promise<Models.Products>;
-    /**
-     *
-     * @param {string} params.id -
-     * @param {object} params.attributeValues -
-     * @param {object} params.completeness -
-     * @param {string} params.deletedAt -
-     * @param {boolean} params.enabled -
-     * @param {string} params.familyId -
-     * @param {string} params.familyVariantId -
-     * @param {string} params.kind -
-     * @param {string} params.parentId -
-     * @param {object} params.quantifiedAssociations -
-     * @param {string} params.sku -
-     * @param {string} params.taxClass -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.Products>}
-     */
-    productsUpdate(params: {
-        id: string;
-        attributeValues?: object;
-        completeness?: object;
-        deletedAt?: string;
-        enabled?: boolean;
+        familyCode?: string;
         familyId?: string;
-        familyVariantId?: string;
-        kind?: string;
-        parentId?: string;
-        quantifiedAssociations?: object;
-        sku?: string;
-        taxClass?: string;
-    }): Promise<Models.Products>;
+    }): Promise<Models.Error>;
     /**
+     * Names the family in the body — by `family_id` or by `family_code`, whichever the caller holds — and computes the product's completeness in the same call. The step every family-driven surface waits on: a product with no family has no required attributes, so its completeness cannot be computed and its family's label attribute never resolves. Assigning the family recomputes and STORES products.completeness immediately, so the metadata cannot go stale between the two operations.
      *
-     * @param {string} id -
-     * @param {object} attributeValues -
-     * @param {object} completeness -
-     * @param {string} deletedAt -
-     * @param {boolean} enabled -
-     * @param {string} familyId -
-     * @param {string} familyVariantId -
-     * @param {string} kind -
-     * @param {string} parentId -
-     * @param {object} quantifiedAssociations -
-     * @param {string} sku -
-     * @param {string} taxClass -
-     * @throws {RevenexxAPIRevenexxException}
-     * @returns {Promise<Models.Products>}
+     * @param {string} id - The `products` row to address, by id. It names a row THIS TENANT holds, so no example is published — a uuid this app invented would document a call that answers 404, and a real one would be another tenant's data. Read one from `GET /v1/products`. An id no product of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @param {string} familyCode - Alternative to family_id — a `families.code` this tenant holds, from `GET /products/families`. No example: a code is tenant data, and any value published here names a family somebody does not have.
+     * @param {string} familyId - The family to assign.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    productsUpdate(id: string, attributeValues?: object, completeness?: object, deletedAt?: string, enabled?: boolean, familyId?: string, familyVariantId?: string, kind?: string, parentId?: string, quantifiedAssociations?: object, sku?: string, taxClass?: string): Promise<Models.Products>;
+    productsFamilyAssign(id: string, familyCode?: string, familyId?: string): Promise<Models.Error>;
 }
 
 export { Products };