@revenexx/node 0.1.1 → 0.2.0

package/dist/services/products-data-model.d.ts

@@ -1,8 +1,11 @@
 import { Client } from '../client.js';
 import { Models } from '../models.js';
 import { EntityType } from '../enums/entity-type.js';
-import { Kind } from '../enums/kind.js';
+import { ProductsListKind } from '../enums/products-list-kind.js';
 import '../query.js';
+import '../enums/accept-line-decision.js';
+import '../enums/accept-result-origin.js';
+import '../enums/accept-result-status.js';
 import '../enums/address-type-row-tone.js';
 import '../enums/address-type-row-create-request-tone.js';
 import '../enums/address-type-row-update-request-tone.js';
@@ -16,12 +19,23 @@ import '../enums/approval-rule-update-request-approver-type.js';
 import '../enums/approval-rule-update-request-condition.js';
 import '../enums/approval-rule-update-request-effect.js';
 import '../enums/assets-source.js';
+import '../enums/assignment-role-tone.js';
+import '../enums/assignment-role-create-request-tone.js';
+import '../enums/assignment-role-update-request-tone.js';
+import '../enums/attach-request-direction.js';
+import '../enums/attach-request-visibility.js';
 import '../enums/attribute-value-bucket.js';
 import '../enums/auth-mail-source.js';
+import '../enums/auth-mfa-challenge-request-factor.js';
 import '../enums/recovery-mail-source.js';
 import '../enums/registration-status.js';
+import '../enums/availability-state-tone.js';
+import '../enums/banner-draft-layout.js';
+import '../enums/banner-draft-update-request-layout.js';
 import '../enums/budget-change-reason.js';
 import '../enums/budget-movement-result-status.js';
+import '../enums/budget-release-scope.js';
+import '../enums/budget-release-status.js';
 import '../enums/cart-status.js';
 import '../enums/cart-merge-strategy.js';
 import '../enums/cart-price-snapshot-mode.js';
@@ -49,18 +63,44 @@ import '../enums/channel-vocabulary-tone.js';
 import '../enums/channel-vocabulary-name.js';
 import '../enums/channel-vocabulary-source.js';
 import '../enums/channel-vocabulary-ref-name.js';
+import '../enums/consent-record-action.js';
+import '../enums/consent-record-surface.js';
+import '../enums/consent-record-create-request-action.js';
+import '../enums/consent-record-create-request-surface.js';
+import '../enums/consent-vocabulary-source.js';
+import '../enums/contact-order-approval-mode.js';
 import '../enums/contact-registration-status.js';
 import '../enums/contact-status.js';
 import '../enums/contact-activity-kind.js';
+import '../enums/order-approval-mode.js';
 import '../enums/contact-create-request-registration-status.js';
 import '../enums/contact-event-kind-tone.js';
 import '../enums/contact-event-kind-create-request-tone.js';
 import '../enums/contact-event-kind-update-request-tone.js';
-import '../enums/contact-update-request-registration-status.js';
+import '../enums/contact-point-kind-tone.js';
+import '../enums/contact-point-kind-create-request-tone.js';
+import '../enums/contact-point-kind-update-request-tone.js';
+import '../enums/cookie-kind.js';
+import '../enums/cookie-create-request-kind.js';
+import '../enums/cookie-update-request-kind.js';
 import '../enums/cost-center-budget-type.js';
+import '../enums/cost-center-create-request-budget-type.js';
 import '../enums/cost-center-restriction-type.js';
 import '../enums/cost-center-restriction-create-request-type.js';
 import '../enums/cost-center-restriction-update-request-type.js';
+import '../enums/cost-center-update-request-budget-type.js';
+import '../enums/cost-centers-vocabulary-tone.js';
+import '../enums/cost-centers-vocabulary-name.js';
+import '../enums/cost-centers-vocabulary-source.js';
+import '../enums/cost-centers-vocabulary-summary-name.js';
+import '../enums/direct-order-status.js';
+import '../enums/document-source.js';
+import '../enums/document-visibility.js';
+import '../enums/document-kind-tone.js';
+import '../enums/document-vocabulary-default-tone.js';
+import '../enums/document-vocabulary-name.js';
+import '../enums/document-vocabulary-source.js';
+import '../enums/document-vocabulary-tone.js';
 import '../enums/payment-fee-type.js';
 import '../enums/payment-method-kind.js';
 import '../enums/form-status.js';
@@ -70,6 +110,7 @@ import '../enums/form-submission-prune-request-status.js';
 import '../enums/forms-vocabulary-tone.js';
 import '../enums/forms-vocabulary-name.js';
 import '../enums/forms-vocabulary-summary-name.js';
+import '../enums/inventory-receive-warning-code.js';
 import '../enums/inventory-vocabulary-default-tone.js';
 import '../enums/inventory-vocabulary-source.js';
 import '../enums/cart-io-apply-mode.js';
@@ -77,6 +118,7 @@ import '../enums/cart-io-direction.js';
 import '../enums/cart-io-entity.js';
 import '../enums/io-profile-resource-apply-mode.js';
 import '../enums/io-profile-resource-direction.js';
+import '../enums/inventory-unorderable-reason.js';
 import '../enums/lifecycle-stage-tone.js';
 import '../enums/lifecycle-stage-create-request-tone.js';
 import '../enums/lifecycle-stage-update-request-tone.js';
@@ -93,28 +135,40 @@ import '../enums/markets-vocabulary-tone.js';
 import '../enums/markets-vocabulary-name.js';
 import '../enums/markets-vocabulary-source.js';
 import '../enums/markets-vocabulary-summary-name.js';
+import '../enums/note-request-visibility.js';
 import '../enums/order-fulfillment-status.js';
 import '../enums/order-payment-status.js';
 import '../enums/order-status.js';
 import '../enums/order-cancellation-scope.js';
 import '../enums/order-comment-visibility.js';
+import '../enums/order-discount-target.js';
+import '../enums/order-discount-effect-kind.js';
+import '../enums/order-discount-placement.js';
+import '../enums/order-discount-source.js';
+import '../enums/order-discount-value-type.js';
 import '../enums/order-item-type.js';
 import '../enums/order-list-kind-tone.js';
 import '../enums/order-list-kind-row-tone.js';
+import '../enums/order-list-skip-reason.js';
 import '../enums/order-list-cart-mode.js';
 import '../enums/order-list-vocabulary-default-tone.js';
 import '../enums/order-list-vocabulary-name.js';
 import '../enums/order-list-vocabulary-source.js';
 import '../enums/order-list-vocabulary-tone.js';
+import '../enums/order-return-refund-mode.js';
 import '../enums/order-return-status.js';
 import '../enums/order-return-settlement.js';
-import '../enums/order-return-refusal.js';
 import '../enums/order-vocabulary-tone.js';
+import '../enums/order-return-refusal.js';
 import '../enums/order-vocabulary-name.js';
 import '../enums/order-vocabulary-source.js';
 import '../enums/order-vocabulary-summary-name.js';
 import '../enums/order-resolution-stage.js';
+import '../enums/organization-credit-limit-mode.js';
+import '../enums/organization-shipping-advice.js';
 import '../enums/organization-status.js';
+import '../enums/credit-limit-mode.js';
+import '../enums/shipping-advice.js';
 import '../enums/page-status.js';
 import '../enums/pages-vocabulary-app.js';
 import '../enums/pages-vocabulary-tone.js';
@@ -136,6 +190,7 @@ import '../enums/price-entries-adjust-response-rounding-mode.js';
 import '../enums/price-entries-bulk-mode.js';
 import '../enums/price-rounding-mode.js';
 import '../enums/price-entry-type.js';
+import '../enums/price-line-price-reason.js';
 import '../enums/price-list-status.js';
 import '../enums/price-list-tax-basis.js';
 import '../enums/price-currency-source.js';
@@ -147,22 +202,86 @@ import '../enums/price-vocabulary-tone.js';
 import '../enums/price-vocabulary-name.js';
 import '../enums/price-vocabulary-source.js';
 import '../enums/price-vocabulary-ref-name.js';
+import '../enums/procurement-vocabulary-default-tone.js';
+import '../enums/procurement-vocabulary-name.js';
+import '../enums/procurement-vocabulary-source.js';
+import '../enums/procurement-vocabulary-summary-name.js';
+import '../enums/procurement-vocabulary-value-tone.js';
 import '../enums/product-categories-source.js';
 import '../enums/product-grid-column-source.js';
 import '../enums/product-label-source.js';
 import '../enums/product-label-attribute-source.js';
 import '../enums/products-kind.js';
+import '../enums/promotion-condition-match.js';
+import '../enums/promotion-reach.js';
+import '../enums/promotion-recurrence-kind.js';
+import '../enums/promotion-return-behaviour.js';
+import '../enums/promotion-status.js';
+import '../enums/promotion-bundle-allocation.js';
+import '../enums/promotion-bundle-patch-allocation.js';
+import '../enums/promotion-bundle-write-allocation.js';
+import '../enums/promotion-condition-kind.js';
+import '../enums/promotion-condition-match-mode.js';
+import '../enums/promotion-condition-patch-kind.js';
+import '../enums/promotion-condition-patch-match-mode.js';
+import '../enums/promotion-condition-write-kind.js';
+import '../enums/promotion-condition-write-match-mode.js';
+import '../enums/promotion-effect-kind.js';
+import '../enums/promotion-effect-target-scope.js';
+import '../enums/promotion-effect-unit-choice.js';
+import '../enums/promotion-effect-value-type.js';
+import '../enums/promotion-effect-patch-kind.js';
+import '../enums/promotion-effect-patch-target-scope.js';
+import '../enums/promotion-effect-patch-unit-choice.js';
+import '../enums/promotion-effect-patch-value-type.js';
+import '../enums/promotion-effect-write-kind.js';
+import '../enums/promotion-effect-write-target-scope.js';
+import '../enums/promotion-effect-write-unit-choice.js';
+import '../enums/promotion-effect-write-value-type.js';
+import '../enums/promotion-patch-condition-match.js';
+import '../enums/promotion-patch-reach.js';
+import '../enums/promotion-patch-recurrence-kind.js';
+import '../enums/promotion-patch-return-behaviour.js';
+import '../enums/promotion-patch-status.js';
+import '../enums/promotion-release-request-reason.js';
+import '../enums/promotion-write-condition-match.js';
+import '../enums/promotion-write-reach.js';
+import '../enums/promotion-write-recurrence-kind.js';
+import '../enums/promotion-write-return-behaviour.js';
+import '../enums/promotion-write-status.js';
+import '../enums/punchout-entry-probe-result-entry-probe-status.js';
+import '../enums/punchout-entry-test-result-protocol.js';
+import '../enums/punchout-field-mapping-import-request-protocol.js';
+import '../enums/punchout-return-preview-protocol.js';
 import '../enums/purchase-request-status.js';
 import '../enums/purchase-request-event-name.js';
 import '../enums/purchase-request-item-type.js';
 import '../enums/purchase-request-item-create-request-type.js';
 import '../enums/purchase-request-item-update-request-type.js';
+import '../enums/purpose-legal-basis.js';
+import '../enums/purpose-create-request-legal-basis.js';
+import '../enums/purpose-update-request-legal-basis.js';
+import '../enums/quote-origin.js';
+import '../enums/quote-status.js';
+import '../enums/quote-attachment-direction.js';
+import '../enums/quote-attachment-visibility.js';
+import '../enums/quote-detail-origin.js';
+import '../enums/quote-detail-status.js';
+import '../enums/quote-event-visibility.js';
+import '../enums/quote-item-decision.js';
+import '../enums/quote-item-price-reason.js';
+import '../enums/quote-line-input-price-reason.js';
+import '../enums/redemption-state.js';
 import '../enums/reorder-point-source.js';
 import '../enums/reservation-status.js';
 import '../enums/price-on-request-reason.js';
 import '../enums/price-tax-basis.js';
 import '../enums/price-tax-basis-source.js';
 import '../enums/role-catalog-response-source.js';
+import '../enums/sales-rep-vocabulary-default-tone.js';
+import '../enums/sales-rep-vocabulary-source.js';
+import '../enums/seed-request-mode.js';
+import '../enums/seed-result-mode.js';
 import '../enums/segment-rule-match.js';
 import '../enums/segment-member-source.js';
 import '../enums/segment-rule-operator.js';
@@ -192,14 +311,35 @@ import '../enums/shipping-vocabulary-tone.js';
 import '../enums/shipping-weight-unit-create-request-tone.js';
 import '../enums/shipping-weight-unit-row-tone.js';
 import '../enums/shipping-weight-unit-update-request-tone.js';
+import '../enums/stacking-group-mode.js';
+import '../enums/stacking-group-patch-mode.js';
+import '../enums/stacking-group-write-mode.js';
 import '../enums/stock-movement-type.js';
 import '../enums/store-asset-request-visibility.js';
 import '../enums/submit-item-type.js';
 import '../enums/submit-result-outcome.js';
+import '../enums/tag-manager-container-check-reason.js';
+import '../enums/tag-manager-marketing-tag-kind.js';
+import '../enums/tag-manager-marketing-tag-load.js';
+import '../enums/tag-manager-marketing-tag-input-kind.js';
+import '../enums/tag-manager-marketing-tag-input-load.js';
+import '../enums/tag-manager-trigger-kind.js';
+import '../enums/tag-manager-trigger-input-kind.js';
+import '../enums/tag-manager-variable-kind.js';
+import '../enums/tag-manager-variable-input-kind.js';
 import '../enums/validation-failed-response-status.js';
+import '../enums/vendor-legal-basis-override.js';
+import '../enums/vendor-create-request-legal-basis-override.js';
+import '../enums/vendor-update-request-legal-basis-override.js';
 import '../enums/vocabulary-default-tone.js';
 import '../enums/vocabulary-source.js';
 import '../enums/vocabulary-tone.js';
+import '../enums/voucher-status.js';
+import '../enums/voucher-batch-status.js';
+import '../enums/voucher-batch-patch-status.js';
+import '../enums/voucher-batch-write-status.js';
+import '../enums/voucher-patch-status.js';
+import '../enums/voucher-write-status.js';
 import '../enums/attribute-boolean-status.js';
 import '../enums/attribute-datetime-status.js';
 import '../enums/attribute-email-status.js';
@@ -440,6 +580,7 @@ declare class ProductsDataModel {
      * @param {boolean} params.isQuantified - Exact match on `is_quantified`. Declares that a relation of this kind carries a quantity — a bundle, a bill of materials. `product_associations.quantity` is where that number goes, and it is meaningless without this flag.
      * @param {string} params.labels - Exact match on `labels`. What the relation is called in a product form, per language tag. 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.
      * @throws {RevenexxException}
      * @returns {Promise<{}>}
      */
@@ -453,6 +594,7 @@ declare class ProductsDataModel {
         isQuantified?: boolean;
         labels?: string;
         createdAt?: string;
+        updatedAt?: string;
     }): Promise<{}>;
     /**
      * The KIND of relation two products can have — cross-sell, accessory, spare part, bill of materials. `is_two_way` declares the relation symmetric and `is_quantified` declares that it carries a quantity; both are declarations a client READS rather than behaviour this app performs — it stores one row per direction and never creates the mirror for you.
@@ -470,11 +612,12 @@ declare class ProductsDataModel {
      * @param {boolean} isQuantified - Exact match on `is_quantified`. Declares that a relation of this kind carries a quantity — a bundle, a bill of materials. `product_associations.quantity` is where that number goes, and it is meaningless without this flag.
      * @param {string} labels - Exact match on `labels`. What the relation is called in a product form, per language tag. 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.
      * @throws {RevenexxException}
      * @returns {Promise<{}>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    productsAssociationTypesList(limit?: number, offset?: number, order?: string, id?: string, code?: string, isTwoWay?: boolean, isQuantified?: boolean, labels?: string, createdAt?: string): Promise<{}>;
+    productsAssociationTypesList(limit?: number, offset?: number, order?: string, id?: string, code?: string, isTwoWay?: boolean, isQuantified?: boolean, labels?: string, createdAt?: string, updatedAt?: string): Promise<{}>;
     /**
      * Creates one association type 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.
      *
@@ -617,7 +760,7 @@ declare class ProductsDataModel {
      * @param {string} params.entityRef - Narrows entity_type to one reference entity / asset family, by its code.
      * @param {string} params.locale - Resolves labels and the storage path of every localizable field. Omitted: labels fall back to English and localizable fields report a null path.
      * @param {string} params.channel - Resolves the storage path of every scopable field, and narrows `required` to the channels the family requires the attribute in.
-     * @param {Kind} params.kind - The product kind the fields are for. 'model' locks the family's variant axes, which are set on the variants.
+     * @param {ProductsListKind} params.kind - The product kind the fields are for. 'model' locks the family's variant axes, which are set on the variants.
      * @throws {RevenexxException}
      * @returns {Promise<{}>}
      */
@@ -628,7 +771,7 @@ declare class ProductsDataModel {
         entityRef?: string;
         locale?: string;
         channel?: string;
-        kind?: Kind;
+        kind?: ProductsListKind;
     }): Promise<{}>;
     /**
      * Which fields does this family have — one ready-to-render list, not six joined tables. The catalog's SHAPE is tenant data: a product's properties are rows in `attributes`, grouped by `attribute_groups`, selected per family by `family_attributes`, with their permitted values in `attribute_options` and their variant axes in `family_variants`. Reading that shape used to mean five reads, a join, and a private `attributes.type` → input mapping in every client — and that mapping is the part that must live here, because the type list carries no CHECK by design and an integrator extends it. Answers one field list instead, ordered by group then by the family's own ordering. Without a family it answers every attribute declared for `entity_type`/`entity_ref` — the shape of a reference entity's records or an asset family, which have attributes but no family. Writes nothing.
@@ -639,12 +782,12 @@ declare class ProductsDataModel {
      * @param {string} entityRef - Narrows entity_type to one reference entity / asset family, by its code.
      * @param {string} locale - Resolves labels and the storage path of every localizable field. Omitted: labels fall back to English and localizable fields report a null path.
      * @param {string} channel - Resolves the storage path of every scopable field, and narrows `required` to the channels the family requires the attribute in.
-     * @param {Kind} kind - The product kind the fields are for. 'model' locks the family's variant axes, which are set on the variants.
+     * @param {ProductsListKind} kind - The product kind the fields are for. 'model' locks the family's variant axes, which are set on the variants.
      * @throws {RevenexxException}
      * @returns {Promise<{}>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    productsAttributeSchema(familyId?: string, familyCode?: string, entityType?: EntityType, entityRef?: string, locale?: string, channel?: string, kind?: Kind): Promise<{}>;
+    productsAttributeSchema(familyId?: string, familyCode?: string, entityType?: EntityType, entityRef?: string, locale?: string, channel?: string, kind?: ProductsListKind): Promise<{}>;
     /**
      * An attribute group is a SECTION of a product form — "Technical attributes", "Logistics" — and the thing every attribute is filed under. It carries a `position`, which is the order the sections appear in, and per-language `labels`, which is what an operator reads; the `code` is what an attribute joins on and is never shown. `GET /products/attribute-schema` already resolves a group's heading onto every field it returns, so these routes are for MANAGING the sections, not for rendering a form.
      *
@@ -659,6 +802,11 @@ declare class ProductsDataModel {
      * @param {string} params.code - Exact match on `code`. The group's stable identifier, and the value an `AttributeField` carries as its `group` — a SECTION of the product form, not a label. Unique per tenant and the key an import joins on.
      * @param {number} params.position - Exact match on `position`. Where this section sits in a form, ascending. Sections that tie keep the order the database returns them in.
      * @param {string} params.labels - Exact match on `labels`. The section heading a person sees, keyed by language tag. The code is never shown to an operator; a tag nobody translated falls back to the next filled one, then to English. 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.externalId - Exact match on `external_id`. The key this section has in the system that owns the property model — the block a supplier's data sheet groups its fields under. Unique per tenant where set, and null for a section somebody created here to tidy up a form, which is most of them.
+     * @param {string} params.externalRefs - Exact match on `external_refs`. Every OTHER system that knows this row, keyed by system name — a second PIM, a supplier's feed, a GTIN register. `external_id` is the system that OWNS the row; this is the rest, so the next identifier standard costs a key in here rather than a column and a migration. It filters the way every jsonb column of this app filters: the WHOLE document is compared, so there is no asking for one key — read the row by `external_id` and take this off the answer. 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.sourceSyncedAt - Exact match on `source_synced_at`. When this row was last CONFIRMED against its source — not when it last changed. A delta run asks for everything it has not seen since its last pass, and over 25 000 products that is the difference between an index scan and reading the whole catalog, which is the reason the column is indexed. An edit made here leaves it alone, so a value that has stopped moving says the feed has gone quiet, not that nobody works the record. Null for a row no source owns.
+     * @param {string} params.sourceData - Exact match on `source_data`. What the source said about this row, kept as it said it: `{"system": …, "etag": …, "raw": {…}}`. The `etag` is what a write-back has to hand back in `If-Match`, and between two runs there is nowhere else to keep it. `raw` carries the source fields this app does not model, so they survive a round trip instead of being lost the first time somebody edits here. Written by whatever imports the row; nothing in this app reads or maintains it. 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.metadata - Exact match on `metadata`. Free-form jsonb this tenant owns — the extension point a section otherwise has none of. `source_data` is what the SOURCE said about the row; this is what you say about it. Nothing in this app reads it. 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.
      * @throws {RevenexxException}
@@ -672,6 +820,11 @@ declare class ProductsDataModel {
         code?: string;
         position?: number;
         labels?: string;
+        externalId?: string;
+        externalRefs?: string;
+        sourceSyncedAt?: string;
+        sourceData?: string;
+        metadata?: string;
         createdAt?: string;
         updatedAt?: string;
     }): Promise<{}>;
@@ -689,13 +842,18 @@ declare class ProductsDataModel {
      * @param {string} code - Exact match on `code`. The group's stable identifier, and the value an `AttributeField` carries as its `group` — a SECTION of the product form, not a label. Unique per tenant and the key an import joins on.
      * @param {number} position - Exact match on `position`. Where this section sits in a form, ascending. Sections that tie keep the order the database returns them in.
      * @param {string} labels - Exact match on `labels`. The section heading a person sees, keyed by language tag. The code is never shown to an operator; a tag nobody translated falls back to the next filled one, then to English. 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} externalId - Exact match on `external_id`. The key this section has in the system that owns the property model — the block a supplier's data sheet groups its fields under. Unique per tenant where set, and null for a section somebody created here to tidy up a form, which is most of them.
+     * @param {string} externalRefs - Exact match on `external_refs`. Every OTHER system that knows this row, keyed by system name — a second PIM, a supplier's feed, a GTIN register. `external_id` is the system that OWNS the row; this is the rest, so the next identifier standard costs a key in here rather than a column and a migration. It filters the way every jsonb column of this app filters: the WHOLE document is compared, so there is no asking for one key — read the row by `external_id` and take this off the answer. 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} sourceSyncedAt - Exact match on `source_synced_at`. When this row was last CONFIRMED against its source — not when it last changed. A delta run asks for everything it has not seen since its last pass, and over 25 000 products that is the difference between an index scan and reading the whole catalog, which is the reason the column is indexed. An edit made here leaves it alone, so a value that has stopped moving says the feed has gone quiet, not that nobody works the record. Null for a row no source owns.
+     * @param {string} sourceData - Exact match on `source_data`. What the source said about this row, kept as it said it: `{"system": …, "etag": …, "raw": {…}}`. The `etag` is what a write-back has to hand back in `If-Match`, and between two runs there is nowhere else to keep it. `raw` carries the source fields this app does not model, so they survive a round trip instead of being lost the first time somebody edits here. Written by whatever imports the row; nothing in this app reads or maintains it. 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} metadata - Exact match on `metadata`. Free-form jsonb this tenant owns — the extension point a section otherwise has none of. `source_data` is what the SOURCE said about the row; this is what you say about it. Nothing in this app reads it. 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.
      * @throws {RevenexxException}
      * @returns {Promise<{}>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    productsAttributeGroupsList(limit?: number, offset?: number, order?: string, id?: string, code?: string, position?: number, labels?: string, createdAt?: string, updatedAt?: string): Promise<{}>;
+    productsAttributeGroupsList(limit?: number, offset?: number, order?: string, id?: string, code?: string, position?: number, labels?: string, externalId?: string, externalRefs?: string, sourceSyncedAt?: string, sourceData?: string, metadata?: string, createdAt?: string, updatedAt?: string): Promise<{}>;
     /**
      * Creates one attribute group 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.
      *
@@ -704,15 +862,25 @@ declare class ProductsDataModel {
      * `code` is the only column the database refuses the row without; everything else has a default or is nullable. A second row with the same `code` answers 409.
      *
      * @param {string} params.code - The group's stable identifier, and the value an `AttributeField` carries as its `group` — a SECTION of the product form, not a label. Unique per tenant and the key an import joins on.
+     * @param {string} params.externalId - The key this section has in the system that owns the property model — the block a supplier's data sheet groups its fields under. Unique per tenant where set, and null for a section somebody created here to tidy up a form, which is most of them.
+     * @param {object} params.externalRefs - Every OTHER system that knows this row, keyed by system name — a second PIM, a supplier's feed, a GTIN register. `external_id` is the system that OWNS the row; this is the rest, so the next identifier standard costs a key in here rather than a column and a migration. It filters the way every jsonb column of this app filters: the WHOLE document is compared, so there is no asking for one key — read the row by `external_id` and take this off the answer.
      * @param {object} params.labels - The section heading a person sees, keyed by language tag. The code is never shown to an operator; a tag nobody translated falls back to the next filled one, then to English.
+     * @param {object} params.metadata - Free-form jsonb this tenant owns — the extension point a section otherwise has none of. `source_data` is what the SOURCE said about the row; this is what you say about it. Nothing in this app reads it.
      * @param {number} params.position - Where this section sits in a form, ascending. Sections that tie keep the order the database returns them in.
+     * @param {object} params.sourceData - What the source said about this row, kept as it said it: `{"system": …, "etag": …, "raw": {…}}`. The `etag` is what a write-back has to hand back in `If-Match`, and between two runs there is nowhere else to keep it. `raw` carries the source fields this app does not model, so they survive a round trip instead of being lost the first time somebody edits here. Written by whatever imports the row; nothing in this app reads or maintains it.
+     * @param {string} params.sourceSyncedAt - When this row was last CONFIRMED against its source — not when it last changed. A delta run asks for everything it has not seen since its last pass, and over 25 000 products that is the difference between an index scan and reading the whole catalog, which is the reason the column is indexed. An edit made here leaves it alone, so a value that has stopped moving says the feed has gone quiet, not that nobody works the record. Null for a row no source owns.
      * @throws {RevenexxException}
      * @returns {Promise<Models.AttributeGroups>}
      */
     productsAttributeGroupsCreate(params: {
         code: string;
+        externalId?: string;
+        externalRefs?: object;
         labels?: object;
+        metadata?: object;
         position?: number;
+        sourceData?: object;
+        sourceSyncedAt?: string;
     }): Promise<Models.AttributeGroups>;
     /**
      * Creates one attribute group 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.
@@ -722,13 +890,18 @@ declare class ProductsDataModel {
      * `code` is the only column the database refuses the row without; everything else has a default or is nullable. A second row with the same `code` answers 409.
      *
      * @param {string} code - The group's stable identifier, and the value an `AttributeField` carries as its `group` — a SECTION of the product form, not a label. Unique per tenant and the key an import joins on.
+     * @param {string} externalId - The key this section has in the system that owns the property model — the block a supplier's data sheet groups its fields under. Unique per tenant where set, and null for a section somebody created here to tidy up a form, which is most of them.
+     * @param {object} externalRefs - Every OTHER system that knows this row, keyed by system name — a second PIM, a supplier's feed, a GTIN register. `external_id` is the system that OWNS the row; this is the rest, so the next identifier standard costs a key in here rather than a column and a migration. It filters the way every jsonb column of this app filters: the WHOLE document is compared, so there is no asking for one key — read the row by `external_id` and take this off the answer.
      * @param {object} labels - The section heading a person sees, keyed by language tag. The code is never shown to an operator; a tag nobody translated falls back to the next filled one, then to English.
+     * @param {object} metadata - Free-form jsonb this tenant owns — the extension point a section otherwise has none of. `source_data` is what the SOURCE said about the row; this is what you say about it. Nothing in this app reads it.
      * @param {number} position - Where this section sits in a form, ascending. Sections that tie keep the order the database returns them in.
+     * @param {object} sourceData - What the source said about this row, kept as it said it: `{"system": …, "etag": …, "raw": {…}}`. The `etag` is what a write-back has to hand back in `If-Match`, and between two runs there is nowhere else to keep it. `raw` carries the source fields this app does not model, so they survive a round trip instead of being lost the first time somebody edits here. Written by whatever imports the row; nothing in this app reads or maintains it.
+     * @param {string} sourceSyncedAt - When this row was last CONFIRMED against its source — not when it last changed. A delta run asks for everything it has not seen since its last pass, and over 25 000 products that is the difference between an index scan and reading the whole catalog, which is the reason the column is indexed. An edit made here leaves it alone, so a value that has stopped moving says the feed has gone quiet, not that nobody works the record. Null for a row no source owns.
      * @throws {RevenexxException}
      * @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>;
+    productsAttributeGroupsCreate(code: string, externalId?: string, externalRefs?: object, labels?: object, metadata?: object, position?: number, sourceData?: object, sourceSyncedAt?: string): Promise<Models.AttributeGroups>;
     /**
      * Deletes one attribute group by id. It is a hard delete — the row is gone, and the answer is a confirmation rather than a result to branch on.
      *
@@ -796,16 +969,26 @@ declare class ProductsDataModel {
      *
      * @param {string} params.id - The `attribute_groups` 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/attribute_groups`. An id no attribute group of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
      * @param {string} params.code - The group's stable identifier, and the value an `AttributeField` carries as its `group` — a SECTION of the product form, not a label. Unique per tenant and the key an import joins on.
+     * @param {string} params.externalId - The key this section has in the system that owns the property model — the block a supplier's data sheet groups its fields under. Unique per tenant where set, and null for a section somebody created here to tidy up a form, which is most of them.
+     * @param {object} params.externalRefs - Every OTHER system that knows this row, keyed by system name — a second PIM, a supplier's feed, a GTIN register. `external_id` is the system that OWNS the row; this is the rest, so the next identifier standard costs a key in here rather than a column and a migration. It filters the way every jsonb column of this app filters: the WHOLE document is compared, so there is no asking for one key — read the row by `external_id` and take this off the answer.
      * @param {object} params.labels - The section heading a person sees, keyed by language tag. The code is never shown to an operator; a tag nobody translated falls back to the next filled one, then to English.
+     * @param {object} params.metadata - Free-form jsonb this tenant owns — the extension point a section otherwise has none of. `source_data` is what the SOURCE said about the row; this is what you say about it. Nothing in this app reads it.
      * @param {number} params.position - Where this section sits in a form, ascending. Sections that tie keep the order the database returns them in.
+     * @param {object} params.sourceData - What the source said about this row, kept as it said it: `{"system": …, "etag": …, "raw": {…}}`. The `etag` is what a write-back has to hand back in `If-Match`, and between two runs there is nowhere else to keep it. `raw` carries the source fields this app does not model, so they survive a round trip instead of being lost the first time somebody edits here. Written by whatever imports the row; nothing in this app reads or maintains it.
+     * @param {string} params.sourceSyncedAt - When this row was last CONFIRMED against its source — not when it last changed. A delta run asks for everything it has not seen since its last pass, and over 25 000 products that is the difference between an index scan and reading the whole catalog, which is the reason the column is indexed. An edit made here leaves it alone, so a value that has stopped moving says the feed has gone quiet, not that nobody works the record. Null for a row no source owns.
      * @throws {RevenexxException}
      * @returns {Promise<Models.AttributeGroups>}
      */
     productsAttributeGroupsUpdate(params: {
         id: string;
         code?: string;
+        externalId?: string;
+        externalRefs?: object;
         labels?: object;
+        metadata?: object;
         position?: number;
+        sourceData?: object;
+        sourceSyncedAt?: string;
     }): Promise<Models.AttributeGroups>;
     /**
      * Updates one attribute group 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.
@@ -816,13 +999,18 @@ declare class ProductsDataModel {
      *
      * @param {string} id - The `attribute_groups` 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/attribute_groups`. An id no attribute group of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
      * @param {string} code - The group's stable identifier, and the value an `AttributeField` carries as its `group` — a SECTION of the product form, not a label. Unique per tenant and the key an import joins on.
+     * @param {string} externalId - The key this section has in the system that owns the property model — the block a supplier's data sheet groups its fields under. Unique per tenant where set, and null for a section somebody created here to tidy up a form, which is most of them.
+     * @param {object} externalRefs - Every OTHER system that knows this row, keyed by system name — a second PIM, a supplier's feed, a GTIN register. `external_id` is the system that OWNS the row; this is the rest, so the next identifier standard costs a key in here rather than a column and a migration. It filters the way every jsonb column of this app filters: the WHOLE document is compared, so there is no asking for one key — read the row by `external_id` and take this off the answer.
      * @param {object} labels - The section heading a person sees, keyed by language tag. The code is never shown to an operator; a tag nobody translated falls back to the next filled one, then to English.
+     * @param {object} metadata - Free-form jsonb this tenant owns — the extension point a section otherwise has none of. `source_data` is what the SOURCE said about the row; this is what you say about it. Nothing in this app reads it.
      * @param {number} position - Where this section sits in a form, ascending. Sections that tie keep the order the database returns them in.
+     * @param {object} sourceData - What the source said about this row, kept as it said it: `{"system": …, "etag": …, "raw": {…}}`. The `etag` is what a write-back has to hand back in `If-Match`, and between two runs there is nowhere else to keep it. `raw` carries the source fields this app does not model, so they survive a round trip instead of being lost the first time somebody edits here. Written by whatever imports the row; nothing in this app reads or maintains it.
+     * @param {string} sourceSyncedAt - When this row was last CONFIRMED against its source — not when it last changed. A delta run asks for everything it has not seen since its last pass, and over 25 000 products that is the difference between an index scan and reading the whole catalog, which is the reason the column is indexed. An edit made here leaves it alone, so a value that has stopped moving says the feed has gone quiet, not that nobody works the record. Null for a row no source owns.
      * @throws {RevenexxException}
      * @returns {Promise<Models.AttributeGroups>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    productsAttributeGroupsUpdate(id: string, code?: string, labels?: object, position?: number): Promise<Models.AttributeGroups>;
+    productsAttributeGroupsUpdate(id: string, code?: string, externalId?: string, externalRefs?: object, labels?: object, metadata?: object, position?: number, sourceData?: object, sourceSyncedAt?: string): Promise<Models.AttributeGroups>;
     /**
      * The permitted values of one select or multi-select attribute. A record stores the option's CODE and never its label, so renaming an option in every language leaves every product that picked it untouched, and `position` is the order it appears in the dropdown. `GET /products/attribute-schema` republishes these as a field's `options`, already resolved for a locale.
      *
@@ -839,7 +1027,13 @@ declare class ProductsDataModel {
      * @param {number} params.position - Exact match on `position`. Order in the dropdown, ascending. Options that tie keep the order the database returns them in, so give every option a position if the order matters.
      * @param {string} params.swatch - Exact match on `swatch`. A colour or texture chip for the picker. Null for an option that is not visual. 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.labels - Exact match on `labels`. What the option is called, per language tag. Two tenants may label the same code differently; only the code is ever written into a record. 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.externalId - Exact match on `external_id`. The key this option has in the system that owns the value list — an ETIM value, an eCl@ss value key. Unique per tenant where set. `code` is what a product stores when the option is picked; this is what the source calls the same choice, and holding the two apart is what stops a re-import founding a second option that means the same thing.
+     * @param {string} params.externalRefs - Exact match on `external_refs`. Every OTHER system that knows this row, keyed by system name — a second PIM, a supplier's feed, a GTIN register. `external_id` is the system that OWNS the row; this is the rest, so the next identifier standard costs a key in here rather than a column and a migration. It filters the way every jsonb column of this app filters: the WHOLE document is compared, so there is no asking for one key — read the row by `external_id` and take this off the answer. 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.sourceSyncedAt - Exact match on `source_synced_at`. When this row was last CONFIRMED against its source — not when it last changed. A delta run asks for everything it has not seen since its last pass, and over 25 000 products that is the difference between an index scan and reading the whole catalog, which is the reason the column is indexed. An edit made here leaves it alone, so a value that has stopped moving says the feed has gone quiet, not that nobody works the record. Null for a row no source owns.
+     * @param {string} params.sourceData - Exact match on `source_data`. What the source said about this row, kept as it said it: `{"system": …, "etag": …, "raw": {…}}`. The `etag` is what a write-back has to hand back in `If-Match`, and between two runs there is nowhere else to keep it. `raw` carries the source fields this app does not model, so they survive a round trip instead of being lost the first time somebody edits here. Written by whatever imports the row; nothing in this app reads or maintains it. 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.metadata - Exact match on `metadata`. Free-form jsonb this tenant owns, for whatever an integration has to remember about an option beyond its code, its label and its swatch. Nothing in this app reads it. 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.
      * @throws {RevenexxException}
      * @returns {Promise<{}>}
      */
@@ -853,7 +1047,13 @@ declare class ProductsDataModel {
         position?: number;
         swatch?: string;
         labels?: string;
+        externalId?: string;
+        externalRefs?: string;
+        sourceSyncedAt?: string;
+        sourceData?: string;
+        metadata?: string;
         createdAt?: string;
+        updatedAt?: string;
     }): Promise<{}>;
     /**
      * The permitted values of one select or multi-select attribute. A record stores the option's CODE and never its label, so renaming an option in every language leaves every product that picked it untouched, and `position` is the order it appears in the dropdown. `GET /products/attribute-schema` republishes these as a field's `options`, already resolved for a locale.
@@ -871,12 +1071,18 @@ declare class ProductsDataModel {
      * @param {number} position - Exact match on `position`. Order in the dropdown, ascending. Options that tie keep the order the database returns them in, so give every option a position if the order matters.
      * @param {string} swatch - Exact match on `swatch`. A colour or texture chip for the picker. Null for an option that is not visual. 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} labels - Exact match on `labels`. What the option is called, per language tag. Two tenants may label the same code differently; only the code is ever written into a record. 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} externalId - Exact match on `external_id`. The key this option has in the system that owns the value list — an ETIM value, an eCl@ss value key. Unique per tenant where set. `code` is what a product stores when the option is picked; this is what the source calls the same choice, and holding the two apart is what stops a re-import founding a second option that means the same thing.
+     * @param {string} externalRefs - Exact match on `external_refs`. Every OTHER system that knows this row, keyed by system name — a second PIM, a supplier's feed, a GTIN register. `external_id` is the system that OWNS the row; this is the rest, so the next identifier standard costs a key in here rather than a column and a migration. It filters the way every jsonb column of this app filters: the WHOLE document is compared, so there is no asking for one key — read the row by `external_id` and take this off the answer. 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} sourceSyncedAt - Exact match on `source_synced_at`. When this row was last CONFIRMED against its source — not when it last changed. A delta run asks for everything it has not seen since its last pass, and over 25 000 products that is the difference between an index scan and reading the whole catalog, which is the reason the column is indexed. An edit made here leaves it alone, so a value that has stopped moving says the feed has gone quiet, not that nobody works the record. Null for a row no source owns.
+     * @param {string} sourceData - Exact match on `source_data`. What the source said about this row, kept as it said it: `{"system": …, "etag": …, "raw": {…}}`. The `etag` is what a write-back has to hand back in `If-Match`, and between two runs there is nowhere else to keep it. `raw` carries the source fields this app does not model, so they survive a round trip instead of being lost the first time somebody edits here. Written by whatever imports the row; nothing in this app reads or maintains it. 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} metadata - Exact match on `metadata`. Free-form jsonb this tenant owns, for whatever an integration has to remember about an option beyond its code, its label and its swatch. Nothing in this app reads it. 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.
      * @throws {RevenexxException}
      * @returns {Promise<{}>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    productsAttributeOptionsList(limit?: number, offset?: number, order?: string, id?: string, attributeId?: string, code?: string, position?: number, swatch?: string, labels?: string, createdAt?: string): Promise<{}>;
+    productsAttributeOptionsList(limit?: number, offset?: number, order?: string, id?: string, attributeId?: string, code?: string, position?: number, swatch?: string, labels?: string, externalId?: string, externalRefs?: string, sourceSyncedAt?: string, sourceData?: string, metadata?: string, createdAt?: string, updatedAt?: string): Promise<{}>;
     /**
      * Creates one attribute option 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.
      *
@@ -886,8 +1092,13 @@ declare class ProductsDataModel {
      *
      * @param {string} params.attributeId - The select / multi-select attribute these are the permitted values of. Deleting the attribute deletes its options with it.
      * @param {string} params.code - The value actually STORED in a record's `attribute_values` when this option is picked — never the label. Unique within the attribute.
+     * @param {string} params.externalId - The key this option has in the system that owns the value list — an ETIM value, an eCl@ss value key. Unique per tenant where set. `code` is what a product stores when the option is picked; this is what the source calls the same choice, and holding the two apart is what stops a re-import founding a second option that means the same thing.
+     * @param {object} params.externalRefs - Every OTHER system that knows this row, keyed by system name — a second PIM, a supplier's feed, a GTIN register. `external_id` is the system that OWNS the row; this is the rest, so the next identifier standard costs a key in here rather than a column and a migration. It filters the way every jsonb column of this app filters: the WHOLE document is compared, so there is no asking for one key — read the row by `external_id` and take this off the answer.
      * @param {object} params.labels - What the option is called, per language tag. Two tenants may label the same code differently; only the code is ever written into a record.
+     * @param {object} params.metadata - Free-form jsonb this tenant owns, for whatever an integration has to remember about an option beyond its code, its label and its swatch. Nothing in this app reads it.
      * @param {number} params.position - Order in the dropdown, ascending. Options that tie keep the order the database returns them in, so give every option a position if the order matters.
+     * @param {object} params.sourceData - What the source said about this row, kept as it said it: `{"system": …, "etag": …, "raw": {…}}`. The `etag` is what a write-back has to hand back in `If-Match`, and between two runs there is nowhere else to keep it. `raw` carries the source fields this app does not model, so they survive a round trip instead of being lost the first time somebody edits here. Written by whatever imports the row; nothing in this app reads or maintains it.
+     * @param {string} params.sourceSyncedAt - When this row was last CONFIRMED against its source — not when it last changed. A delta run asks for everything it has not seen since its last pass, and over 25 000 products that is the difference between an index scan and reading the whole catalog, which is the reason the column is indexed. An edit made here leaves it alone, so a value that has stopped moving says the feed has gone quiet, not that nobody works the record. Null for a row no source owns.
      * @param {object} params.swatch - A colour or texture chip for the picker. Null for an option that is not visual.
      * @throws {RevenexxException}
      * @returns {Promise<Models.AttributeOptions>}
@@ -895,8 +1106,13 @@ declare class ProductsDataModel {
     productsAttributeOptionsCreate(params: {
         attributeId: string;
         code: string;
+        externalId?: string;
+        externalRefs?: object;
         labels?: object;
+        metadata?: object;
         position?: number;
+        sourceData?: object;
+        sourceSyncedAt?: string;
         swatch?: object;
     }): Promise<Models.AttributeOptions>;
     /**
@@ -908,14 +1124,19 @@ declare class ProductsDataModel {
      *
      * @param {string} attributeId - The select / multi-select attribute these are the permitted values of. Deleting the attribute deletes its options with it.
      * @param {string} code - The value actually STORED in a record's `attribute_values` when this option is picked — never the label. Unique within the attribute.
+     * @param {string} externalId - The key this option has in the system that owns the value list — an ETIM value, an eCl@ss value key. Unique per tenant where set. `code` is what a product stores when the option is picked; this is what the source calls the same choice, and holding the two apart is what stops a re-import founding a second option that means the same thing.
+     * @param {object} externalRefs - Every OTHER system that knows this row, keyed by system name — a second PIM, a supplier's feed, a GTIN register. `external_id` is the system that OWNS the row; this is the rest, so the next identifier standard costs a key in here rather than a column and a migration. It filters the way every jsonb column of this app filters: the WHOLE document is compared, so there is no asking for one key — read the row by `external_id` and take this off the answer.
      * @param {object} labels - What the option is called, per language tag. Two tenants may label the same code differently; only the code is ever written into a record.
+     * @param {object} metadata - Free-form jsonb this tenant owns, for whatever an integration has to remember about an option beyond its code, its label and its swatch. Nothing in this app reads it.
      * @param {number} position - Order in the dropdown, ascending. Options that tie keep the order the database returns them in, so give every option a position if the order matters.
+     * @param {object} sourceData - What the source said about this row, kept as it said it: `{"system": …, "etag": …, "raw": {…}}`. The `etag` is what a write-back has to hand back in `If-Match`, and between two runs there is nowhere else to keep it. `raw` carries the source fields this app does not model, so they survive a round trip instead of being lost the first time somebody edits here. Written by whatever imports the row; nothing in this app reads or maintains it.
+     * @param {string} sourceSyncedAt - When this row was last CONFIRMED against its source — not when it last changed. A delta run asks for everything it has not seen since its last pass, and over 25 000 products that is the difference between an index scan and reading the whole catalog, which is the reason the column is indexed. An edit made here leaves it alone, so a value that has stopped moving says the feed has gone quiet, not that nobody works the record. Null for a row no source owns.
      * @param {object} swatch - A colour or texture chip for the picker. Null for an option that is not visual.
      * @throws {RevenexxException}
      * @returns {Promise<Models.AttributeOptions>}
      * @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>;
+    productsAttributeOptionsCreate(attributeId: string, code: string, externalId?: string, externalRefs?: object, labels?: object, metadata?: object, position?: number, sourceData?: object, sourceSyncedAt?: string, swatch?: object): Promise<Models.AttributeOptions>;
     /**
      * Deletes one attribute option by id. It is a hard delete — the row is gone, and the answer is a confirmation rather than a result to branch on.
      *
@@ -984,8 +1205,13 @@ declare class ProductsDataModel {
      * @param {string} params.id - The `attribute_options` 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/attribute_options`. An id no attribute option of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
      * @param {string} params.attributeId - The select / multi-select attribute these are the permitted values of. Deleting the attribute deletes its options with it.
      * @param {string} params.code - The value actually STORED in a record's `attribute_values` when this option is picked — never the label. Unique within the attribute.
+     * @param {string} params.externalId - The key this option has in the system that owns the value list — an ETIM value, an eCl@ss value key. Unique per tenant where set. `code` is what a product stores when the option is picked; this is what the source calls the same choice, and holding the two apart is what stops a re-import founding a second option that means the same thing.
+     * @param {object} params.externalRefs - Every OTHER system that knows this row, keyed by system name — a second PIM, a supplier's feed, a GTIN register. `external_id` is the system that OWNS the row; this is the rest, so the next identifier standard costs a key in here rather than a column and a migration. It filters the way every jsonb column of this app filters: the WHOLE document is compared, so there is no asking for one key — read the row by `external_id` and take this off the answer.
      * @param {object} params.labels - What the option is called, per language tag. Two tenants may label the same code differently; only the code is ever written into a record.
+     * @param {object} params.metadata - Free-form jsonb this tenant owns, for whatever an integration has to remember about an option beyond its code, its label and its swatch. Nothing in this app reads it.
      * @param {number} params.position - Order in the dropdown, ascending. Options that tie keep the order the database returns them in, so give every option a position if the order matters.
+     * @param {object} params.sourceData - What the source said about this row, kept as it said it: `{"system": …, "etag": …, "raw": {…}}`. The `etag` is what a write-back has to hand back in `If-Match`, and between two runs there is nowhere else to keep it. `raw` carries the source fields this app does not model, so they survive a round trip instead of being lost the first time somebody edits here. Written by whatever imports the row; nothing in this app reads or maintains it.
+     * @param {string} params.sourceSyncedAt - When this row was last CONFIRMED against its source — not when it last changed. A delta run asks for everything it has not seen since its last pass, and over 25 000 products that is the difference between an index scan and reading the whole catalog, which is the reason the column is indexed. An edit made here leaves it alone, so a value that has stopped moving says the feed has gone quiet, not that nobody works the record. Null for a row no source owns.
      * @param {object} params.swatch - A colour or texture chip for the picker. Null for an option that is not visual.
      * @throws {RevenexxException}
      * @returns {Promise<Models.AttributeOptions>}
@@ -994,8 +1220,13 @@ declare class ProductsDataModel {
         id: string;
         attributeId?: string;
         code?: string;
+        externalId?: string;
+        externalRefs?: object;
         labels?: object;
+        metadata?: object;
         position?: number;
+        sourceData?: object;
+        sourceSyncedAt?: string;
         swatch?: object;
     }): Promise<Models.AttributeOptions>;
     /**
@@ -1008,14 +1239,19 @@ declare class ProductsDataModel {
      * @param {string} id - The `attribute_options` 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/attribute_options`. An id no attribute option of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
      * @param {string} attributeId - The select / multi-select attribute these are the permitted values of. Deleting the attribute deletes its options with it.
      * @param {string} code - The value actually STORED in a record's `attribute_values` when this option is picked — never the label. Unique within the attribute.
+     * @param {string} externalId - The key this option has in the system that owns the value list — an ETIM value, an eCl@ss value key. Unique per tenant where set. `code` is what a product stores when the option is picked; this is what the source calls the same choice, and holding the two apart is what stops a re-import founding a second option that means the same thing.
+     * @param {object} externalRefs - Every OTHER system that knows this row, keyed by system name — a second PIM, a supplier's feed, a GTIN register. `external_id` is the system that OWNS the row; this is the rest, so the next identifier standard costs a key in here rather than a column and a migration. It filters the way every jsonb column of this app filters: the WHOLE document is compared, so there is no asking for one key — read the row by `external_id` and take this off the answer.
      * @param {object} labels - What the option is called, per language tag. Two tenants may label the same code differently; only the code is ever written into a record.
+     * @param {object} metadata - Free-form jsonb this tenant owns, for whatever an integration has to remember about an option beyond its code, its label and its swatch. Nothing in this app reads it.
      * @param {number} position - Order in the dropdown, ascending. Options that tie keep the order the database returns them in, so give every option a position if the order matters.
+     * @param {object} sourceData - What the source said about this row, kept as it said it: `{"system": …, "etag": …, "raw": {…}}`. The `etag` is what a write-back has to hand back in `If-Match`, and between two runs there is nowhere else to keep it. `raw` carries the source fields this app does not model, so they survive a round trip instead of being lost the first time somebody edits here. Written by whatever imports the row; nothing in this app reads or maintains it.
+     * @param {string} sourceSyncedAt - When this row was last CONFIRMED against its source — not when it last changed. A delta run asks for everything it has not seen since its last pass, and over 25 000 products that is the difference between an index scan and reading the whole catalog, which is the reason the column is indexed. An edit made here leaves it alone, so a value that has stopped moving says the feed has gone quiet, not that nobody works the record. Null for a row no source owns.
      * @param {object} swatch - A colour or texture chip for the picker. Null for an option that is not visual.
      * @throws {RevenexxException}
      * @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>;
+    productsAttributeOptionsUpdate(id: string, attributeId?: string, code?: string, externalId?: string, externalRefs?: object, labels?: object, metadata?: object, position?: number, sourceData?: object, sourceSyncedAt?: string, swatch?: object): Promise<Models.AttributeOptions>;
     /**
      * An attribute is one property a record can carry, and in an attribute-driven PIM it is a ROW rather than a column: giving the catalog a "net weight" is a create here, not a migration. Its own flags decide everything downstream — `localizable` and `scopable` pick which of the four `attribute_values` buckets its values are written to, `type` picks the editor that renders it, `usable_in_grid` and `is_filterable` are what the product grid reads. `entity_type`/`entity_ref` say which kind of record carries it: a product, one reference entity's records, one asset family, or a category.
      *
@@ -1041,6 +1277,11 @@ declare class ProductsDataModel {
      * @param {string} params.config - Exact match on `config`. Type-specific settings; which keys apply depends on `type`. The ones this app reads: `units` (the unit list a measure attribute offers) and `reference_entity` (which entity a reference attribute draws its options from). The ones the cockpit edits alongside them: `unit`, `metric_family`, `decimals_allowed`, `asset_family`, `max_file_size`, `allowed_extensions`. 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.labels - Exact match on `labels`. The field label a person sees, keyed by language tag. Resolution falls back to English and then to the code, so an untranslated attribute is still renderable. 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 {number} params.position - Exact match on `position`. Where the field sits inside its group. A family may override it for its own form through `family_attributes.position`; this is the attribute's default.
+     * @param {string} params.externalId - Exact match on `external_id`. The key this attribute has in the system that owns the property model — an ETIM feature, an eCl@ss property, a column of a supplier's data sheet. Unique per tenant where set. It is the half that survives a rename of `code`, so an import maps a source property onto an attribute once rather than on every run.
+     * @param {string} params.externalRefs - Exact match on `external_refs`. Every OTHER system that knows this row, keyed by system name — a second PIM, a supplier's feed, a GTIN register. `external_id` is the system that OWNS the row; this is the rest, so the next identifier standard costs a key in here rather than a column and a migration. It filters the way every jsonb column of this app filters: the WHOLE document is compared, so there is no asking for one key — read the row by `external_id` and take this off the answer. 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.sourceSyncedAt - Exact match on `source_synced_at`. When this row was last CONFIRMED against its source — not when it last changed. A delta run asks for everything it has not seen since its last pass, and over 25 000 products that is the difference between an index scan and reading the whole catalog, which is the reason the column is indexed. An edit made here leaves it alone, so a value that has stopped moving says the feed has gone quiet, not that nobody works the record. Null for a row no source owns.
+     * @param {string} params.sourceData - Exact match on `source_data`. What the source said about this row, kept as it said it: `{"system": …, "etag": …, "raw": {…}}`. The `etag` is what a write-back has to hand back in `If-Match`, and between two runs there is nowhere else to keep it. `raw` carries the source fields this app does not model, so they survive a round trip instead of being lost the first time somebody edits here. Written by whatever imports the row; nothing in this app reads or maintains it. 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.metadata - Exact match on `metadata`. Free-form jsonb this tenant owns. `validation` and `config` are read by this app and mean something to it; this is the pocket for everything else an integration has to remember about an attribute — a mapping note, an owning team, an export flag. Nothing here reads it. 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.
      * @throws {RevenexxException}
@@ -1065,6 +1306,11 @@ declare class ProductsDataModel {
         config?: string;
         labels?: string;
         position?: number;
+        externalId?: string;
+        externalRefs?: string;
+        sourceSyncedAt?: string;
+        sourceData?: string;
+        metadata?: string;
         createdAt?: string;
         updatedAt?: string;
     }): Promise<{}>;
@@ -1093,13 +1339,18 @@ declare class ProductsDataModel {
      * @param {string} config - Exact match on `config`. Type-specific settings; which keys apply depends on `type`. The ones this app reads: `units` (the unit list a measure attribute offers) and `reference_entity` (which entity a reference attribute draws its options from). The ones the cockpit edits alongside them: `unit`, `metric_family`, `decimals_allowed`, `asset_family`, `max_file_size`, `allowed_extensions`. 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} labels - Exact match on `labels`. The field label a person sees, keyed by language tag. Resolution falls back to English and then to the code, so an untranslated attribute is still renderable. 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 {number} position - Exact match on `position`. Where the field sits inside its group. A family may override it for its own form through `family_attributes.position`; this is the attribute's default.
+     * @param {string} externalId - Exact match on `external_id`. The key this attribute has in the system that owns the property model — an ETIM feature, an eCl@ss property, a column of a supplier's data sheet. Unique per tenant where set. It is the half that survives a rename of `code`, so an import maps a source property onto an attribute once rather than on every run.
+     * @param {string} externalRefs - Exact match on `external_refs`. Every OTHER system that knows this row, keyed by system name — a second PIM, a supplier's feed, a GTIN register. `external_id` is the system that OWNS the row; this is the rest, so the next identifier standard costs a key in here rather than a column and a migration. It filters the way every jsonb column of this app filters: the WHOLE document is compared, so there is no asking for one key — read the row by `external_id` and take this off the answer. 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} sourceSyncedAt - Exact match on `source_synced_at`. When this row was last CONFIRMED against its source — not when it last changed. A delta run asks for everything it has not seen since its last pass, and over 25 000 products that is the difference between an index scan and reading the whole catalog, which is the reason the column is indexed. An edit made here leaves it alone, so a value that has stopped moving says the feed has gone quiet, not that nobody works the record. Null for a row no source owns.
+     * @param {string} sourceData - Exact match on `source_data`. What the source said about this row, kept as it said it: `{"system": …, "etag": …, "raw": {…}}`. The `etag` is what a write-back has to hand back in `If-Match`, and between two runs there is nowhere else to keep it. `raw` carries the source fields this app does not model, so they survive a round trip instead of being lost the first time somebody edits here. Written by whatever imports the row; nothing in this app reads or maintains it. 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} metadata - Exact match on `metadata`. Free-form jsonb this tenant owns. `validation` and `config` are read by this app and mean something to it; this is the pocket for everything else an integration has to remember about an attribute — a mapping note, an owning team, an export flag. Nothing here reads it. 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.
      * @throws {RevenexxException}
      * @returns {Promise<{}>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    productsAttributesList(limit?: number, offset?: number, order?: string, id?: string, code?: string, entityType?: string, entityRef?: string, type?: string, groupId?: string, localizable?: boolean, scopable?: boolean, isUnique?: boolean, isFilterable?: boolean, usableInGrid?: boolean, validation?: string, config?: string, labels?: string, position?: number, createdAt?: string, updatedAt?: string): Promise<{}>;
+    productsAttributesList(limit?: number, offset?: number, order?: string, id?: string, code?: string, entityType?: string, entityRef?: string, type?: string, groupId?: string, localizable?: boolean, scopable?: boolean, isUnique?: boolean, isFilterable?: boolean, usableInGrid?: boolean, validation?: string, config?: string, labels?: string, position?: number, externalId?: string, externalRefs?: string, sourceSyncedAt?: string, sourceData?: string, metadata?: string, createdAt?: string, updatedAt?: string): Promise<{}>;
     /**
      * Creates one attribute 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.
      *
@@ -1112,13 +1363,18 @@ declare class ProductsDataModel {
      * @param {object} params.config - Type-specific settings; which keys apply depends on `type`. The ones this app reads: `units` (the unit list a measure attribute offers) and `reference_entity` (which entity a reference attribute draws its options from). The ones the cockpit edits alongside them: `unit`, `metric_family`, `decimals_allowed`, `asset_family`, `max_file_size`, `allowed_extensions`.
      * @param {string} params.entityRef - Narrows `entity_type` to ONE reference entity or asset family, by its code — the attributes of `brand` rather than of every reference entity. Null for a plain product attribute.
      * @param {string} params.entityType - Which kind of record carries this attribute: 'product' for the catalog itself, 'reference_entity', 'asset' or 'category' for the other things in this app that have attributes. Deliberately carries no CHECK — a tenant that models a fifth kind is served on it too.
+     * @param {string} params.externalId - The key this attribute has in the system that owns the property model — an ETIM feature, an eCl@ss property, a column of a supplier's data sheet. Unique per tenant where set. It is the half that survives a rename of `code`, so an import maps a source property onto an attribute once rather than on every run.
+     * @param {object} params.externalRefs - Every OTHER system that knows this row, keyed by system name — a second PIM, a supplier's feed, a GTIN register. `external_id` is the system that OWNS the row; this is the rest, so the next identifier standard costs a key in here rather than a column and a migration. It filters the way every jsonb column of this app filters: the WHOLE document is compared, so there is no asking for one key — read the row by `external_id` and take this off the answer.
      * @param {string} params.groupId - The `attribute_groups` row this attribute is filed under — the form section it appears in. Null is ungrouped, and an ungrouped field is rendered after every section that has a name.
      * @param {boolean} params.isFilterable - Offer this attribute as a filter in a product list. `GET /products/grid` reports exactly these attributes in its `filters` array, and nothing else reads the flag.
      * @param {boolean} params.isUnique - Declares that the value identifies the product — an EAN, a manufacturer part number. It is metadata a form and an importer read: no database index enforces it, because the value lives inside jsonb rather than in a column.
      * @param {object} params.labels - The field label a person sees, keyed by language tag. Resolution falls back to English and then to the code, so an untranslated attribute is still renderable.
      * @param {boolean} params.localizable - True → the record holds ONE VALUE PER LOCALE, under `attribute_values.locale_specific.<locale>.<code>`. False → one value, under `attribute_values.common.<code>`. This flag is what decides where a write goes.
+     * @param {object} params.metadata - Free-form jsonb this tenant owns. `validation` and `config` are read by this app and mean something to it; this is the pocket for everything else an integration has to remember about an attribute — a mapping note, an owning team, an export flag. Nothing here reads it.
      * @param {number} params.position - Where the field sits inside its group. A family may override it for its own form through `family_attributes.position`; this is the attribute's default.
      * @param {boolean} params.scopable - True → one value PER CHANNEL, under `attribute_values.channel_specific.<channel>.<code>`. Set together with `localizable` it means one value per channel AND locale, in `channel_locale_specific`.
+     * @param {object} params.sourceData - What the source said about this row, kept as it said it: `{"system": …, "etag": …, "raw": {…}}`. The `etag` is what a write-back has to hand back in `If-Match`, and between two runs there is nowhere else to keep it. `raw` carries the source fields this app does not model, so they survive a round trip instead of being lost the first time somebody edits here. Written by whatever imports the row; nothing in this app reads or maintains it.
+     * @param {string} params.sourceSyncedAt - When this row was last CONFIRMED against its source — not when it last changed. A delta run asks for everything it has not seen since its last pass, and over 25 000 products that is the difference between an index scan and reading the whole catalog, which is the reason the column is indexed. An edit made here leaves it alone, so a value that has stopped moving says the feed has gone quiet, not that nobody works the record. Null for a row no source owns.
      * @param {boolean} params.usableInGrid - Show this attribute as a COLUMN in the product grid. `GET /products/grid` returns a column definition and a per-row value for exactly these.
      * @param {object} params.validation - Limits a value has to satisfy, as a flat object. The seven keys a client can act on are `min`, `max`, `min_length`, `max_length`, `pattern`, `min_items`, `max_items` — `GET /products/attribute-schema` republishes those and leaves anything else the tenant stored untouched.
      * @throws {RevenexxException}
@@ -1130,13 +1386,18 @@ declare class ProductsDataModel {
         config?: object;
         entityRef?: string;
         entityType?: string;
+        externalId?: string;
+        externalRefs?: object;
         groupId?: string;
         isFilterable?: boolean;
         isUnique?: boolean;
         labels?: object;
         localizable?: boolean;
+        metadata?: object;
         position?: number;
         scopable?: boolean;
+        sourceData?: object;
+        sourceSyncedAt?: string;
         usableInGrid?: boolean;
         validation?: object;
     }): Promise<Models.Attributes>;
@@ -1152,20 +1413,25 @@ declare class ProductsDataModel {
      * @param {object} config - Type-specific settings; which keys apply depends on `type`. The ones this app reads: `units` (the unit list a measure attribute offers) and `reference_entity` (which entity a reference attribute draws its options from). The ones the cockpit edits alongside them: `unit`, `metric_family`, `decimals_allowed`, `asset_family`, `max_file_size`, `allowed_extensions`.
      * @param {string} entityRef - Narrows `entity_type` to ONE reference entity or asset family, by its code — the attributes of `brand` rather than of every reference entity. Null for a plain product attribute.
      * @param {string} entityType - Which kind of record carries this attribute: 'product' for the catalog itself, 'reference_entity', 'asset' or 'category' for the other things in this app that have attributes. Deliberately carries no CHECK — a tenant that models a fifth kind is served on it too.
+     * @param {string} externalId - The key this attribute has in the system that owns the property model — an ETIM feature, an eCl@ss property, a column of a supplier's data sheet. Unique per tenant where set. It is the half that survives a rename of `code`, so an import maps a source property onto an attribute once rather than on every run.
+     * @param {object} externalRefs - Every OTHER system that knows this row, keyed by system name — a second PIM, a supplier's feed, a GTIN register. `external_id` is the system that OWNS the row; this is the rest, so the next identifier standard costs a key in here rather than a column and a migration. It filters the way every jsonb column of this app filters: the WHOLE document is compared, so there is no asking for one key — read the row by `external_id` and take this off the answer.
      * @param {string} groupId - The `attribute_groups` row this attribute is filed under — the form section it appears in. Null is ungrouped, and an ungrouped field is rendered after every section that has a name.
      * @param {boolean} isFilterable - Offer this attribute as a filter in a product list. `GET /products/grid` reports exactly these attributes in its `filters` array, and nothing else reads the flag.
      * @param {boolean} isUnique - Declares that the value identifies the product — an EAN, a manufacturer part number. It is metadata a form and an importer read: no database index enforces it, because the value lives inside jsonb rather than in a column.
      * @param {object} labels - The field label a person sees, keyed by language tag. Resolution falls back to English and then to the code, so an untranslated attribute is still renderable.
      * @param {boolean} localizable - True → the record holds ONE VALUE PER LOCALE, under `attribute_values.locale_specific.<locale>.<code>`. False → one value, under `attribute_values.common.<code>`. This flag is what decides where a write goes.
+     * @param {object} metadata - Free-form jsonb this tenant owns. `validation` and `config` are read by this app and mean something to it; this is the pocket for everything else an integration has to remember about an attribute — a mapping note, an owning team, an export flag. Nothing here reads it.
      * @param {number} position - Where the field sits inside its group. A family may override it for its own form through `family_attributes.position`; this is the attribute's default.
      * @param {boolean} scopable - True → one value PER CHANNEL, under `attribute_values.channel_specific.<channel>.<code>`. Set together with `localizable` it means one value per channel AND locale, in `channel_locale_specific`.
+     * @param {object} sourceData - What the source said about this row, kept as it said it: `{"system": …, "etag": …, "raw": {…}}`. The `etag` is what a write-back has to hand back in `If-Match`, and between two runs there is nowhere else to keep it. `raw` carries the source fields this app does not model, so they survive a round trip instead of being lost the first time somebody edits here. Written by whatever imports the row; nothing in this app reads or maintains it.
+     * @param {string} sourceSyncedAt - When this row was last CONFIRMED against its source — not when it last changed. A delta run asks for everything it has not seen since its last pass, and over 25 000 products that is the difference between an index scan and reading the whole catalog, which is the reason the column is indexed. An edit made here leaves it alone, so a value that has stopped moving says the feed has gone quiet, not that nobody works the record. Null for a row no source owns.
      * @param {boolean} usableInGrid - Show this attribute as a COLUMN in the product grid. `GET /products/grid` returns a column definition and a per-row value for exactly these.
      * @param {object} validation - Limits a value has to satisfy, as a flat object. The seven keys a client can act on are `min`, `max`, `min_length`, `max_length`, `pattern`, `min_items`, `max_items` — `GET /products/attribute-schema` republishes those and leaves anything else the tenant stored untouched.
      * @throws {RevenexxException}
      * @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>;
+    productsAttributesCreate(code: string, type: string, config?: object, entityRef?: string, entityType?: string, externalId?: string, externalRefs?: object, groupId?: string, isFilterable?: boolean, isUnique?: boolean, labels?: object, localizable?: boolean, metadata?: object, position?: number, scopable?: boolean, sourceData?: object, sourceSyncedAt?: string, usableInGrid?: boolean, validation?: object): Promise<Models.Attributes>;
     /**
      * Deletes one attribute by id. It is a hard delete — the row is gone, and the answer is a confirmation rather than a result to branch on.
      *
@@ -1236,13 +1502,18 @@ declare class ProductsDataModel {
      * @param {object} params.config - Type-specific settings; which keys apply depends on `type`. The ones this app reads: `units` (the unit list a measure attribute offers) and `reference_entity` (which entity a reference attribute draws its options from). The ones the cockpit edits alongside them: `unit`, `metric_family`, `decimals_allowed`, `asset_family`, `max_file_size`, `allowed_extensions`.
      * @param {string} params.entityRef - Narrows `entity_type` to ONE reference entity or asset family, by its code — the attributes of `brand` rather than of every reference entity. Null for a plain product attribute.
      * @param {string} params.entityType - Which kind of record carries this attribute: 'product' for the catalog itself, 'reference_entity', 'asset' or 'category' for the other things in this app that have attributes. Deliberately carries no CHECK — a tenant that models a fifth kind is served on it too.
+     * @param {string} params.externalId - The key this attribute has in the system that owns the property model — an ETIM feature, an eCl@ss property, a column of a supplier's data sheet. Unique per tenant where set. It is the half that survives a rename of `code`, so an import maps a source property onto an attribute once rather than on every run.
+     * @param {object} params.externalRefs - Every OTHER system that knows this row, keyed by system name — a second PIM, a supplier's feed, a GTIN register. `external_id` is the system that OWNS the row; this is the rest, so the next identifier standard costs a key in here rather than a column and a migration. It filters the way every jsonb column of this app filters: the WHOLE document is compared, so there is no asking for one key — read the row by `external_id` and take this off the answer.
      * @param {string} params.groupId - The `attribute_groups` row this attribute is filed under — the form section it appears in. Null is ungrouped, and an ungrouped field is rendered after every section that has a name.
      * @param {boolean} params.isFilterable - Offer this attribute as a filter in a product list. `GET /products/grid` reports exactly these attributes in its `filters` array, and nothing else reads the flag.
      * @param {boolean} params.isUnique - Declares that the value identifies the product — an EAN, a manufacturer part number. It is metadata a form and an importer read: no database index enforces it, because the value lives inside jsonb rather than in a column.
      * @param {object} params.labels - The field label a person sees, keyed by language tag. Resolution falls back to English and then to the code, so an untranslated attribute is still renderable.
      * @param {boolean} params.localizable - True → the record holds ONE VALUE PER LOCALE, under `attribute_values.locale_specific.<locale>.<code>`. False → one value, under `attribute_values.common.<code>`. This flag is what decides where a write goes.
+     * @param {object} params.metadata - Free-form jsonb this tenant owns. `validation` and `config` are read by this app and mean something to it; this is the pocket for everything else an integration has to remember about an attribute — a mapping note, an owning team, an export flag. Nothing here reads it.
      * @param {number} params.position - Where the field sits inside its group. A family may override it for its own form through `family_attributes.position`; this is the attribute's default.
      * @param {boolean} params.scopable - True → one value PER CHANNEL, under `attribute_values.channel_specific.<channel>.<code>`. Set together with `localizable` it means one value per channel AND locale, in `channel_locale_specific`.
+     * @param {object} params.sourceData - What the source said about this row, kept as it said it: `{"system": …, "etag": …, "raw": {…}}`. The `etag` is what a write-back has to hand back in `If-Match`, and between two runs there is nowhere else to keep it. `raw` carries the source fields this app does not model, so they survive a round trip instead of being lost the first time somebody edits here. Written by whatever imports the row; nothing in this app reads or maintains it.
+     * @param {string} params.sourceSyncedAt - When this row was last CONFIRMED against its source — not when it last changed. A delta run asks for everything it has not seen since its last pass, and over 25 000 products that is the difference between an index scan and reading the whole catalog, which is the reason the column is indexed. An edit made here leaves it alone, so a value that has stopped moving says the feed has gone quiet, not that nobody works the record. Null for a row no source owns.
      * @param {string} params.type - Which editor the value asks for — 'text', 'select', 'metric', 'price', 'asset_collection', 'reference_entity'. Carries no CHECK on purpose: an integrator adds a type, and `GET /products/attribute-schema` maps an unknown one onto a text field rather than refusing to answer.
      * @param {boolean} params.usableInGrid - Show this attribute as a COLUMN in the product grid. `GET /products/grid` returns a column definition and a per-row value for exactly these.
      * @param {object} params.validation - Limits a value has to satisfy, as a flat object. The seven keys a client can act on are `min`, `max`, `min_length`, `max_length`, `pattern`, `min_items`, `max_items` — `GET /products/attribute-schema` republishes those and leaves anything else the tenant stored untouched.
@@ -1255,13 +1526,18 @@ declare class ProductsDataModel {
         config?: object;
         entityRef?: string;
         entityType?: string;
+        externalId?: string;
+        externalRefs?: object;
         groupId?: string;
         isFilterable?: boolean;
         isUnique?: boolean;
         labels?: object;
         localizable?: boolean;
+        metadata?: object;
         position?: number;
         scopable?: boolean;
+        sourceData?: object;
+        sourceSyncedAt?: string;
         type?: string;
         usableInGrid?: boolean;
         validation?: object;
@@ -1278,13 +1554,18 @@ declare class ProductsDataModel {
      * @param {object} config - Type-specific settings; which keys apply depends on `type`. The ones this app reads: `units` (the unit list a measure attribute offers) and `reference_entity` (which entity a reference attribute draws its options from). The ones the cockpit edits alongside them: `unit`, `metric_family`, `decimals_allowed`, `asset_family`, `max_file_size`, `allowed_extensions`.
      * @param {string} entityRef - Narrows `entity_type` to ONE reference entity or asset family, by its code — the attributes of `brand` rather than of every reference entity. Null for a plain product attribute.
      * @param {string} entityType - Which kind of record carries this attribute: 'product' for the catalog itself, 'reference_entity', 'asset' or 'category' for the other things in this app that have attributes. Deliberately carries no CHECK — a tenant that models a fifth kind is served on it too.
+     * @param {string} externalId - The key this attribute has in the system that owns the property model — an ETIM feature, an eCl@ss property, a column of a supplier's data sheet. Unique per tenant where set. It is the half that survives a rename of `code`, so an import maps a source property onto an attribute once rather than on every run.
+     * @param {object} externalRefs - Every OTHER system that knows this row, keyed by system name — a second PIM, a supplier's feed, a GTIN register. `external_id` is the system that OWNS the row; this is the rest, so the next identifier standard costs a key in here rather than a column and a migration. It filters the way every jsonb column of this app filters: the WHOLE document is compared, so there is no asking for one key — read the row by `external_id` and take this off the answer.
      * @param {string} groupId - The `attribute_groups` row this attribute is filed under — the form section it appears in. Null is ungrouped, and an ungrouped field is rendered after every section that has a name.
      * @param {boolean} isFilterable - Offer this attribute as a filter in a product list. `GET /products/grid` reports exactly these attributes in its `filters` array, and nothing else reads the flag.
      * @param {boolean} isUnique - Declares that the value identifies the product — an EAN, a manufacturer part number. It is metadata a form and an importer read: no database index enforces it, because the value lives inside jsonb rather than in a column.
      * @param {object} labels - The field label a person sees, keyed by language tag. Resolution falls back to English and then to the code, so an untranslated attribute is still renderable.
      * @param {boolean} localizable - True → the record holds ONE VALUE PER LOCALE, under `attribute_values.locale_specific.<locale>.<code>`. False → one value, under `attribute_values.common.<code>`. This flag is what decides where a write goes.
+     * @param {object} metadata - Free-form jsonb this tenant owns. `validation` and `config` are read by this app and mean something to it; this is the pocket for everything else an integration has to remember about an attribute — a mapping note, an owning team, an export flag. Nothing here reads it.
      * @param {number} position - Where the field sits inside its group. A family may override it for its own form through `family_attributes.position`; this is the attribute's default.
      * @param {boolean} scopable - True → one value PER CHANNEL, under `attribute_values.channel_specific.<channel>.<code>`. Set together with `localizable` it means one value per channel AND locale, in `channel_locale_specific`.
+     * @param {object} sourceData - What the source said about this row, kept as it said it: `{"system": …, "etag": …, "raw": {…}}`. The `etag` is what a write-back has to hand back in `If-Match`, and between two runs there is nowhere else to keep it. `raw` carries the source fields this app does not model, so they survive a round trip instead of being lost the first time somebody edits here. Written by whatever imports the row; nothing in this app reads or maintains it.
+     * @param {string} sourceSyncedAt - When this row was last CONFIRMED against its source — not when it last changed. A delta run asks for everything it has not seen since its last pass, and over 25 000 products that is the difference between an index scan and reading the whole catalog, which is the reason the column is indexed. An edit made here leaves it alone, so a value that has stopped moving says the feed has gone quiet, not that nobody works the record. Null for a row no source owns.
      * @param {string} type - Which editor the value asks for — 'text', 'select', 'metric', 'price', 'asset_collection', 'reference_entity'. Carries no CHECK on purpose: an integrator adds a type, and `GET /products/attribute-schema` maps an unknown one onto a text field rather than refusing to answer.
      * @param {boolean} usableInGrid - Show this attribute as a COLUMN in the product grid. `GET /products/grid` returns a column definition and a per-row value for exactly these.
      * @param {object} validation - Limits a value has to satisfy, as a flat object. The seven keys a client can act on are `min`, `max`, `min_length`, `max_length`, `pattern`, `min_items`, `max_items` — `GET /products/attribute-schema` republishes those and leaves anything else the tenant stored untouched.
@@ -1292,7 +1573,7 @@ declare class ProductsDataModel {
      * @returns {Promise<Models.Attributes>}
      * @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>;
+    productsAttributesUpdate(id: string, code?: string, config?: object, entityRef?: string, entityType?: string, externalId?: string, externalRefs?: object, groupId?: string, isFilterable?: boolean, isUnique?: boolean, labels?: object, localizable?: boolean, metadata?: object, position?: number, scopable?: boolean, sourceData?: object, sourceSyncedAt?: string, type?: string, usableInGrid?: boolean, validation?: object): Promise<Models.Attributes>;
     /**
      * A family decides WHICH attributes a product has — the set is `family_attributes`, and every family-driven surface follows from it. It also names which attribute carries the display name (`label_attribute`) and which carries the main image. A product with no family has no required attributes at all, so its completeness cannot be measured and its name never resolves past the SKU; `POST /products/{id}/family` is the call that ends that state.
      *
@@ -1308,6 +1589,11 @@ declare class ProductsDataModel {
      * @param {string} params.labelAttribute - Exact match on `label_attribute`. Which attribute CODE carries the display name of a product in this family. A product's name is an attribute, not a column, and which attribute it is, is per family. Null falls back to the `default_label_attribute` setting and then to the conventional `name`.
      * @param {string} params.imageAttribute - Exact match on `image_attribute`. Which attribute code carries the product's main image — the one a grid thumbnail and a picker read.
      * @param {string} params.labels - Exact match on `labels`. What the family is called, per language tag — the name an operator picks from, while the code is what everything else joins on. 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.externalId - Exact match on `external_id`. The key this family has in the system that owns the classification — an ETIM class, an eCl@ss class, a supplier's article type. Unique per tenant where set, and what an import joins on to decide which family a delivered article belongs in.
+     * @param {string} params.externalRefs - Exact match on `external_refs`. Every OTHER system that knows this row, keyed by system name — a second PIM, a supplier's feed, a GTIN register. `external_id` is the system that OWNS the row; this is the rest, so the next identifier standard costs a key in here rather than a column and a migration. It filters the way every jsonb column of this app filters: the WHOLE document is compared, so there is no asking for one key — read the row by `external_id` and take this off the answer. 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.sourceSyncedAt - Exact match on `source_synced_at`. When this row was last CONFIRMED against its source — not when it last changed. A delta run asks for everything it has not seen since its last pass, and over 25 000 products that is the difference between an index scan and reading the whole catalog, which is the reason the column is indexed. An edit made here leaves it alone, so a value that has stopped moving says the feed has gone quiet, not that nobody works the record. Null for a row no source owns.
+     * @param {string} params.sourceData - Exact match on `source_data`. What the source said about this row, kept as it said it: `{"system": …, "etag": …, "raw": {…}}`. The `etag` is what a write-back has to hand back in `If-Match`, and between two runs there is nowhere else to keep it. `raw` carries the source fields this app does not model, so they survive a round trip instead of being lost the first time somebody edits here. Written by whatever imports the row; nothing in this app reads or maintains it. 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.metadata - Exact match on `metadata`. Free-form jsonb this tenant owns, for anything about a family this app does not model. `source_data` is the source's account of the row; this one is yours. Nothing here reads it. 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.
      * @throws {RevenexxException}
@@ -1322,6 +1608,11 @@ declare class ProductsDataModel {
         labelAttribute?: string;
         imageAttribute?: string;
         labels?: string;
+        externalId?: string;
+        externalRefs?: string;
+        sourceSyncedAt?: string;
+        sourceData?: string;
+        metadata?: string;
         createdAt?: string;
         updatedAt?: string;
     }): Promise<{}>;
@@ -1340,13 +1631,18 @@ declare class ProductsDataModel {
      * @param {string} labelAttribute - Exact match on `label_attribute`. Which attribute CODE carries the display name of a product in this family. A product's name is an attribute, not a column, and which attribute it is, is per family. Null falls back to the `default_label_attribute` setting and then to the conventional `name`.
      * @param {string} imageAttribute - Exact match on `image_attribute`. Which attribute code carries the product's main image — the one a grid thumbnail and a picker read.
      * @param {string} labels - Exact match on `labels`. What the family is called, per language tag — the name an operator picks from, while the code is what everything else joins on. 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} externalId - Exact match on `external_id`. The key this family has in the system that owns the classification — an ETIM class, an eCl@ss class, a supplier's article type. Unique per tenant where set, and what an import joins on to decide which family a delivered article belongs in.
+     * @param {string} externalRefs - Exact match on `external_refs`. Every OTHER system that knows this row, keyed by system name — a second PIM, a supplier's feed, a GTIN register. `external_id` is the system that OWNS the row; this is the rest, so the next identifier standard costs a key in here rather than a column and a migration. It filters the way every jsonb column of this app filters: the WHOLE document is compared, so there is no asking for one key — read the row by `external_id` and take this off the answer. 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} sourceSyncedAt - Exact match on `source_synced_at`. When this row was last CONFIRMED against its source — not when it last changed. A delta run asks for everything it has not seen since its last pass, and over 25 000 products that is the difference between an index scan and reading the whole catalog, which is the reason the column is indexed. An edit made here leaves it alone, so a value that has stopped moving says the feed has gone quiet, not that nobody works the record. Null for a row no source owns.
+     * @param {string} sourceData - Exact match on `source_data`. What the source said about this row, kept as it said it: `{"system": …, "etag": …, "raw": {…}}`. The `etag` is what a write-back has to hand back in `If-Match`, and between two runs there is nowhere else to keep it. `raw` carries the source fields this app does not model, so they survive a round trip instead of being lost the first time somebody edits here. Written by whatever imports the row; nothing in this app reads or maintains it. 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} metadata - Exact match on `metadata`. Free-form jsonb this tenant owns, for anything about a family this app does not model. `source_data` is the source's account of the row; this one is yours. Nothing here reads it. 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.
      * @throws {RevenexxException}
      * @returns {Promise<{}>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    productsFamiliesList(limit?: number, offset?: number, order?: string, id?: string, code?: string, labelAttribute?: string, imageAttribute?: string, labels?: string, createdAt?: string, updatedAt?: string): Promise<{}>;
+    productsFamiliesList(limit?: number, offset?: number, order?: string, id?: string, code?: string, labelAttribute?: string, imageAttribute?: string, labels?: string, externalId?: string, externalRefs?: string, sourceSyncedAt?: string, sourceData?: string, metadata?: string, createdAt?: string, updatedAt?: string): Promise<{}>;
     /**
      * Creates one family 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.
      *
@@ -1355,17 +1651,27 @@ declare class ProductsDataModel {
      * `code` is the only column the database refuses the row without; everything else has a default or is nullable. A second row with the same `code` answers 409.
      *
      * @param {string} params.code - The family's stable identifier — which set of attributes a product of this family HAS. Unique per tenant, and the value `GET /products/attribute-schema?family_code=` resolves.
+     * @param {string} params.externalId - The key this family has in the system that owns the classification — an ETIM class, an eCl@ss class, a supplier's article type. Unique per tenant where set, and what an import joins on to decide which family a delivered article belongs in.
+     * @param {object} params.externalRefs - Every OTHER system that knows this row, keyed by system name — a second PIM, a supplier's feed, a GTIN register. `external_id` is the system that OWNS the row; this is the rest, so the next identifier standard costs a key in here rather than a column and a migration. It filters the way every jsonb column of this app filters: the WHOLE document is compared, so there is no asking for one key — read the row by `external_id` and take this off the answer.
      * @param {string} params.imageAttribute - Which attribute code carries the product's main image — the one a grid thumbnail and a picker read.
      * @param {string} params.labelAttribute - Which attribute CODE carries the display name of a product in this family. A product's name is an attribute, not a column, and which attribute it is, is per family. Null falls back to the `default_label_attribute` setting and then to the conventional `name`.
      * @param {object} params.labels - What the family is called, per language tag — the name an operator picks from, while the code is what everything else joins on.
+     * @param {object} params.metadata - Free-form jsonb this tenant owns, for anything about a family this app does not model. `source_data` is the source's account of the row; this one is yours. Nothing here reads it.
+     * @param {object} params.sourceData - What the source said about this row, kept as it said it: `{"system": …, "etag": …, "raw": {…}}`. The `etag` is what a write-back has to hand back in `If-Match`, and between two runs there is nowhere else to keep it. `raw` carries the source fields this app does not model, so they survive a round trip instead of being lost the first time somebody edits here. Written by whatever imports the row; nothing in this app reads or maintains it.
+     * @param {string} params.sourceSyncedAt - When this row was last CONFIRMED against its source — not when it last changed. A delta run asks for everything it has not seen since its last pass, and over 25 000 products that is the difference between an index scan and reading the whole catalog, which is the reason the column is indexed. An edit made here leaves it alone, so a value that has stopped moving says the feed has gone quiet, not that nobody works the record. Null for a row no source owns.
      * @throws {RevenexxException}
      * @returns {Promise<Models.Families>}
      */
     productsFamiliesCreate(params: {
         code: string;
+        externalId?: string;
+        externalRefs?: object;
         imageAttribute?: string;
         labelAttribute?: string;
         labels?: object;
+        metadata?: object;
+        sourceData?: object;
+        sourceSyncedAt?: string;
     }): Promise<Models.Families>;
     /**
      * Creates one family 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.
@@ -1375,14 +1681,19 @@ declare class ProductsDataModel {
      * `code` is the only column the database refuses the row without; everything else has a default or is nullable. A second row with the same `code` answers 409.
      *
      * @param {string} code - The family's stable identifier — which set of attributes a product of this family HAS. Unique per tenant, and the value `GET /products/attribute-schema?family_code=` resolves.
+     * @param {string} externalId - The key this family has in the system that owns the classification — an ETIM class, an eCl@ss class, a supplier's article type. Unique per tenant where set, and what an import joins on to decide which family a delivered article belongs in.
+     * @param {object} externalRefs - Every OTHER system that knows this row, keyed by system name — a second PIM, a supplier's feed, a GTIN register. `external_id` is the system that OWNS the row; this is the rest, so the next identifier standard costs a key in here rather than a column and a migration. It filters the way every jsonb column of this app filters: the WHOLE document is compared, so there is no asking for one key — read the row by `external_id` and take this off the answer.
      * @param {string} imageAttribute - Which attribute code carries the product's main image — the one a grid thumbnail and a picker read.
      * @param {string} labelAttribute - Which attribute CODE carries the display name of a product in this family. A product's name is an attribute, not a column, and which attribute it is, is per family. Null falls back to the `default_label_attribute` setting and then to the conventional `name`.
      * @param {object} labels - What the family is called, per language tag — the name an operator picks from, while the code is what everything else joins on.
+     * @param {object} metadata - Free-form jsonb this tenant owns, for anything about a family this app does not model. `source_data` is the source's account of the row; this one is yours. Nothing here reads it.
+     * @param {object} sourceData - What the source said about this row, kept as it said it: `{"system": …, "etag": …, "raw": {…}}`. The `etag` is what a write-back has to hand back in `If-Match`, and between two runs there is nowhere else to keep it. `raw` carries the source fields this app does not model, so they survive a round trip instead of being lost the first time somebody edits here. Written by whatever imports the row; nothing in this app reads or maintains it.
+     * @param {string} sourceSyncedAt - When this row was last CONFIRMED against its source — not when it last changed. A delta run asks for everything it has not seen since its last pass, and over 25 000 products that is the difference between an index scan and reading the whole catalog, which is the reason the column is indexed. An edit made here leaves it alone, so a value that has stopped moving says the feed has gone quiet, not that nobody works the record. Null for a row no source owns.
      * @throws {RevenexxException}
      * @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>;
+    productsFamiliesCreate(code: string, externalId?: string, externalRefs?: object, imageAttribute?: string, labelAttribute?: string, labels?: object, metadata?: object, sourceData?: object, sourceSyncedAt?: string): Promise<Models.Families>;
     /**
      * Deletes one family by id. It is a hard delete — the row is gone, and the answer is a confirmation rather than a result to branch on.
      *
@@ -1450,18 +1761,28 @@ declare class ProductsDataModel {
      *
      * @param {string} params.id - The `families` 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/families`. An id no familie of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
      * @param {string} params.code - The family's stable identifier — which set of attributes a product of this family HAS. Unique per tenant, and the value `GET /products/attribute-schema?family_code=` resolves.
+     * @param {string} params.externalId - The key this family has in the system that owns the classification — an ETIM class, an eCl@ss class, a supplier's article type. Unique per tenant where set, and what an import joins on to decide which family a delivered article belongs in.
+     * @param {object} params.externalRefs - Every OTHER system that knows this row, keyed by system name — a second PIM, a supplier's feed, a GTIN register. `external_id` is the system that OWNS the row; this is the rest, so the next identifier standard costs a key in here rather than a column and a migration. It filters the way every jsonb column of this app filters: the WHOLE document is compared, so there is no asking for one key — read the row by `external_id` and take this off the answer.
      * @param {string} params.imageAttribute - Which attribute code carries the product's main image — the one a grid thumbnail and a picker read.
      * @param {string} params.labelAttribute - Which attribute CODE carries the display name of a product in this family. A product's name is an attribute, not a column, and which attribute it is, is per family. Null falls back to the `default_label_attribute` setting and then to the conventional `name`.
      * @param {object} params.labels - What the family is called, per language tag — the name an operator picks from, while the code is what everything else joins on.
+     * @param {object} params.metadata - Free-form jsonb this tenant owns, for anything about a family this app does not model. `source_data` is the source's account of the row; this one is yours. Nothing here reads it.
+     * @param {object} params.sourceData - What the source said about this row, kept as it said it: `{"system": …, "etag": …, "raw": {…}}`. The `etag` is what a write-back has to hand back in `If-Match`, and between two runs there is nowhere else to keep it. `raw` carries the source fields this app does not model, so they survive a round trip instead of being lost the first time somebody edits here. Written by whatever imports the row; nothing in this app reads or maintains it.
+     * @param {string} params.sourceSyncedAt - When this row was last CONFIRMED against its source — not when it last changed. A delta run asks for everything it has not seen since its last pass, and over 25 000 products that is the difference between an index scan and reading the whole catalog, which is the reason the column is indexed. An edit made here leaves it alone, so a value that has stopped moving says the feed has gone quiet, not that nobody works the record. Null for a row no source owns.
      * @throws {RevenexxException}
      * @returns {Promise<Models.Families>}
      */
     productsFamiliesUpdate(params: {
         id: string;
         code?: string;
+        externalId?: string;
+        externalRefs?: object;
         imageAttribute?: string;
         labelAttribute?: string;
         labels?: object;
+        metadata?: object;
+        sourceData?: object;
+        sourceSyncedAt?: string;
     }): Promise<Models.Families>;
     /**
      * Updates one family 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.
@@ -1472,14 +1793,19 @@ declare class ProductsDataModel {
      *
      * @param {string} id - The `families` 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/families`. An id no familie of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
      * @param {string} code - The family's stable identifier — which set of attributes a product of this family HAS. Unique per tenant, and the value `GET /products/attribute-schema?family_code=` resolves.
+     * @param {string} externalId - The key this family has in the system that owns the classification — an ETIM class, an eCl@ss class, a supplier's article type. Unique per tenant where set, and what an import joins on to decide which family a delivered article belongs in.
+     * @param {object} externalRefs - Every OTHER system that knows this row, keyed by system name — a second PIM, a supplier's feed, a GTIN register. `external_id` is the system that OWNS the row; this is the rest, so the next identifier standard costs a key in here rather than a column and a migration. It filters the way every jsonb column of this app filters: the WHOLE document is compared, so there is no asking for one key — read the row by `external_id` and take this off the answer.
      * @param {string} imageAttribute - Which attribute code carries the product's main image — the one a grid thumbnail and a picker read.
      * @param {string} labelAttribute - Which attribute CODE carries the display name of a product in this family. A product's name is an attribute, not a column, and which attribute it is, is per family. Null falls back to the `default_label_attribute` setting and then to the conventional `name`.
      * @param {object} labels - What the family is called, per language tag — the name an operator picks from, while the code is what everything else joins on.
+     * @param {object} metadata - Free-form jsonb this tenant owns, for anything about a family this app does not model. `source_data` is the source's account of the row; this one is yours. Nothing here reads it.
+     * @param {object} sourceData - What the source said about this row, kept as it said it: `{"system": …, "etag": …, "raw": {…}}`. The `etag` is what a write-back has to hand back in `If-Match`, and between two runs there is nowhere else to keep it. `raw` carries the source fields this app does not model, so they survive a round trip instead of being lost the first time somebody edits here. Written by whatever imports the row; nothing in this app reads or maintains it.
+     * @param {string} sourceSyncedAt - When this row was last CONFIRMED against its source — not when it last changed. A delta run asks for everything it has not seen since its last pass, and over 25 000 products that is the difference between an index scan and reading the whole catalog, which is the reason the column is indexed. An edit made here leaves it alone, so a value that has stopped moving says the feed has gone quiet, not that nobody works the record. Null for a row no source owns.
      * @throws {RevenexxException}
      * @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>;
+    productsFamiliesUpdate(id: string, code?: string, externalId?: string, externalRefs?: object, imageAttribute?: string, labelAttribute?: string, labels?: object, metadata?: object, sourceData?: object, sourceSyncedAt?: string): Promise<Models.Families>;
     /**
      * One link between a family and an attribute — the row that puts an attribute INTO a family's form. It carries the family's own ordering of that attribute, which overrides the attribute's default position, and `is_required`, which is the flag `POST /products/{id}/completeness` measures and nothing else reads. `required_channels` narrows "required" to named channels; null or empty means required EVERYWHERE, not nowhere.
      *
@@ -1497,6 +1823,7 @@ declare class ProductsDataModel {
      * @param {boolean} params.isRequired - Exact match on `is_required`. The attribute has to carry a value for a product of this family to count as complete. `POST /products/{id}/completeness` measures exactly these and nothing else.
      * @param {string} params.requiredChannels - Exact match on `required_channels`. Narrows `is_required` to named channels. NULL or an empty list means required EVERYWHERE, not nowhere — that is how every required link in the wild is stored, and reading an empty list as "nowhere" reports a fully configured family as demanding nothing. 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.
      * @throws {RevenexxException}
      * @returns {Promise<{}>}
      */
@@ -1511,6 +1838,7 @@ declare class ProductsDataModel {
         isRequired?: boolean;
         requiredChannels?: string;
         createdAt?: string;
+        updatedAt?: string;
     }): Promise<{}>;
     /**
      * One link between a family and an attribute — the row that puts an attribute INTO a family's form. It carries the family's own ordering of that attribute, which overrides the attribute's default position, and `is_required`, which is the flag `POST /products/{id}/completeness` measures and nothing else reads. `required_channels` narrows "required" to named channels; null or empty means required EVERYWHERE, not nowhere.
@@ -1529,11 +1857,12 @@ declare class ProductsDataModel {
      * @param {boolean} isRequired - Exact match on `is_required`. The attribute has to carry a value for a product of this family to count as complete. `POST /products/{id}/completeness` measures exactly these and nothing else.
      * @param {string} requiredChannels - Exact match on `required_channels`. Narrows `is_required` to named channels. NULL or an empty list means required EVERYWHERE, not nowhere — that is how every required link in the wild is stored, and reading an empty list as "nowhere" reports a fully configured family as demanding nothing. 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.
      * @throws {RevenexxException}
      * @returns {Promise<{}>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    productsFamilyAttributesList(limit?: number, offset?: number, order?: string, id?: string, familyId?: string, attributeId?: string, position?: number, isRequired?: boolean, requiredChannels?: string, createdAt?: string): Promise<{}>;
+    productsFamilyAttributesList(limit?: number, offset?: number, order?: string, id?: string, familyId?: string, attributeId?: string, position?: number, isRequired?: boolean, requiredChannels?: string, createdAt?: string, updatedAt?: string): Promise<{}>;
     /**
      * Creates one family attribute 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.
      *
@@ -1688,6 +2017,11 @@ declare class ProductsDataModel {
      * @param {string} params.code - Exact match on `code`. The variant structure's stable identifier — how this family splits, not which product it splits. Unique per tenant.
      * @param {string} params.labels - Exact match on `labels`. What the variant structure is called, per language tag. 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.axes - Exact match on `axes`. The attribute codes a product model splits its variants on. Two shapes are in the wild and both are read: a bare list of codes, or one entry per level, outermost first — `[{"level": 1, "axes": ["colour"]}, {"level": 2, "axes": ["size"]}]`. An attribute named here is READ-ONLY on the model and set on each variant, which is what `AttributeField.readonly_reason` reports. 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.externalId - Exact match on `external_id`. The key this variant structure has in the system it came from. Unique per tenant where set, and usually null — few sources model how a family splits, so this is normally a structure somebody built here.
+     * @param {string} params.externalRefs - Exact match on `external_refs`. Every OTHER system that knows this row, keyed by system name — a second PIM, a supplier's feed, a GTIN register. `external_id` is the system that OWNS the row; this is the rest, so the next identifier standard costs a key in here rather than a column and a migration. It filters the way every jsonb column of this app filters: the WHOLE document is compared, so there is no asking for one key — read the row by `external_id` and take this off the answer. 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.sourceSyncedAt - Exact match on `source_synced_at`. When this row was last CONFIRMED against its source — not when it last changed. A delta run asks for everything it has not seen since its last pass, and over 25 000 products that is the difference between an index scan and reading the whole catalog, which is the reason the column is indexed. An edit made here leaves it alone, so a value that has stopped moving says the feed has gone quiet, not that nobody works the record. Null for a row no source owns.
+     * @param {string} params.sourceData - Exact match on `source_data`. What the source said about this row, kept as it said it: `{"system": …, "etag": …, "raw": {…}}`. The `etag` is what a write-back has to hand back in `If-Match`, and between two runs there is nowhere else to keep it. `raw` carries the source fields this app does not model, so they survive a round trip instead of being lost the first time somebody edits here. Written by whatever imports the row; nothing in this app reads or maintains it. 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.metadata - Exact match on `metadata`. Free-form jsonb this tenant owns, for anything about a variant structure this app does not model. Nothing here reads it. 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.
      * @throws {RevenexxException}
@@ -1702,6 +2036,11 @@ declare class ProductsDataModel {
         code?: string;
         labels?: string;
         axes?: string;
+        externalId?: string;
+        externalRefs?: string;
+        sourceSyncedAt?: string;
+        sourceData?: string;
+        metadata?: string;
         createdAt?: string;
         updatedAt?: string;
     }): Promise<{}>;
@@ -1720,13 +2059,18 @@ declare class ProductsDataModel {
      * @param {string} code - Exact match on `code`. The variant structure's stable identifier — how this family splits, not which product it splits. Unique per tenant.
      * @param {string} labels - Exact match on `labels`. What the variant structure is called, per language tag. 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} axes - Exact match on `axes`. The attribute codes a product model splits its variants on. Two shapes are in the wild and both are read: a bare list of codes, or one entry per level, outermost first — `[{"level": 1, "axes": ["colour"]}, {"level": 2, "axes": ["size"]}]`. An attribute named here is READ-ONLY on the model and set on each variant, which is what `AttributeField.readonly_reason` reports. 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} externalId - Exact match on `external_id`. The key this variant structure has in the system it came from. Unique per tenant where set, and usually null — few sources model how a family splits, so this is normally a structure somebody built here.
+     * @param {string} externalRefs - Exact match on `external_refs`. Every OTHER system that knows this row, keyed by system name — a second PIM, a supplier's feed, a GTIN register. `external_id` is the system that OWNS the row; this is the rest, so the next identifier standard costs a key in here rather than a column and a migration. It filters the way every jsonb column of this app filters: the WHOLE document is compared, so there is no asking for one key — read the row by `external_id` and take this off the answer. 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} sourceSyncedAt - Exact match on `source_synced_at`. When this row was last CONFIRMED against its source — not when it last changed. A delta run asks for everything it has not seen since its last pass, and over 25 000 products that is the difference between an index scan and reading the whole catalog, which is the reason the column is indexed. An edit made here leaves it alone, so a value that has stopped moving says the feed has gone quiet, not that nobody works the record. Null for a row no source owns.
+     * @param {string} sourceData - Exact match on `source_data`. What the source said about this row, kept as it said it: `{"system": …, "etag": …, "raw": {…}}`. The `etag` is what a write-back has to hand back in `If-Match`, and between two runs there is nowhere else to keep it. `raw` carries the source fields this app does not model, so they survive a round trip instead of being lost the first time somebody edits here. Written by whatever imports the row; nothing in this app reads or maintains it. 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} metadata - Exact match on `metadata`. Free-form jsonb this tenant owns, for anything about a variant structure this app does not model. Nothing here reads it. 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.
      * @throws {RevenexxException}
      * @returns {Promise<{}>}
      * @deprecated Use the object parameter style method for a better developer experience.
      */
-    productsFamilyVariantsList(limit?: number, offset?: number, order?: string, id?: string, familyId?: string, code?: string, labels?: string, axes?: string, createdAt?: string, updatedAt?: string): Promise<{}>;
+    productsFamilyVariantsList(limit?: number, offset?: number, order?: string, id?: string, familyId?: string, code?: string, labels?: string, axes?: string, externalId?: string, externalRefs?: string, sourceSyncedAt?: string, sourceData?: string, metadata?: string, createdAt?: string, updatedAt?: string): Promise<{}>;
     /**
      * Creates one family variant 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.
      *
@@ -1737,7 +2081,12 @@ declare class ProductsDataModel {
      * @param {string} params.code - The variant structure's stable identifier — how this family splits, not which product it splits. Unique per tenant.
      * @param {string} params.familyId - The family this variant structure belongs to. A family may carry several, and a product names the one it follows through `family_variant_id`.
      * @param {object} params.axes - The attribute codes a product model splits its variants on. Two shapes are in the wild and both are read: a bare list of codes, or one entry per level, outermost first — `[{"level": 1, "axes": ["colour"]}, {"level": 2, "axes": ["size"]}]`. An attribute named here is READ-ONLY on the model and set on each variant, which is what `AttributeField.readonly_reason` reports.
+     * @param {string} params.externalId - The key this variant structure has in the system it came from. Unique per tenant where set, and usually null — few sources model how a family splits, so this is normally a structure somebody built here.
+     * @param {object} params.externalRefs - Every OTHER system that knows this row, keyed by system name — a second PIM, a supplier's feed, a GTIN register. `external_id` is the system that OWNS the row; this is the rest, so the next identifier standard costs a key in here rather than a column and a migration. It filters the way every jsonb column of this app filters: the WHOLE document is compared, so there is no asking for one key — read the row by `external_id` and take this off the answer.
      * @param {object} params.labels - What the variant structure is called, per language tag.
+     * @param {object} params.metadata - Free-form jsonb this tenant owns, for anything about a variant structure this app does not model. Nothing here reads it.
+     * @param {object} params.sourceData - What the source said about this row, kept as it said it: `{"system": …, "etag": …, "raw": {…}}`. The `etag` is what a write-back has to hand back in `If-Match`, and between two runs there is nowhere else to keep it. `raw` carries the source fields this app does not model, so they survive a round trip instead of being lost the first time somebody edits here. Written by whatever imports the row; nothing in this app reads or maintains it.
+     * @param {string} params.sourceSyncedAt - When this row was last CONFIRMED against its source — not when it last changed. A delta run asks for everything it has not seen since its last pass, and over 25 000 products that is the difference between an index scan and reading the whole catalog, which is the reason the column is indexed. An edit made here leaves it alone, so a value that has stopped moving says the feed has gone quiet, not that nobody works the record. Null for a row no source owns.
      * @throws {RevenexxException}
      * @returns {Promise<Models.FamilyVariants>}
      */
@@ -1745,7 +2094,12 @@ declare class ProductsDataModel {
         code: string;
         familyId: string;
         axes?: object;
+        externalId?: string;
+        externalRefs?: object;
         labels?: object;
+        metadata?: object;
+        sourceData?: object;
+        sourceSyncedAt?: string;
     }): Promise<Models.FamilyVariants>;
     /**
      * Creates one family variant 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.
@@ -1757,12 +2111,17 @@ declare class ProductsDataModel {
      * @param {string} code - The variant structure's stable identifier — how this family splits, not which product it splits. Unique per tenant.
      * @param {string} familyId - The family this variant structure belongs to. A family may carry several, and a product names the one it follows through `family_variant_id`.
      * @param {object} axes - The attribute codes a product model splits its variants on. Two shapes are in the wild and both are read: a bare list of codes, or one entry per level, outermost first — `[{"level": 1, "axes": ["colour"]}, {"level": 2, "axes": ["size"]}]`. An attribute named here is READ-ONLY on the model and set on each variant, which is what `AttributeField.readonly_reason` reports.
+     * @param {string} externalId - The key this variant structure has in the system it came from. Unique per tenant where set, and usually null — few sources model how a family splits, so this is normally a structure somebody built here.
+     * @param {object} externalRefs - Every OTHER system that knows this row, keyed by system name — a second PIM, a supplier's feed, a GTIN register. `external_id` is the system that OWNS the row; this is the rest, so the next identifier standard costs a key in here rather than a column and a migration. It filters the way every jsonb column of this app filters: the WHOLE document is compared, so there is no asking for one key — read the row by `external_id` and take this off the answer.
      * @param {object} labels - What the variant structure is called, per language tag.
+     * @param {object} metadata - Free-form jsonb this tenant owns, for anything about a variant structure this app does not model. Nothing here reads it.
+     * @param {object} sourceData - What the source said about this row, kept as it said it: `{"system": …, "etag": …, "raw": {…}}`. The `etag` is what a write-back has to hand back in `If-Match`, and between two runs there is nowhere else to keep it. `raw` carries the source fields this app does not model, so they survive a round trip instead of being lost the first time somebody edits here. Written by whatever imports the row; nothing in this app reads or maintains it.
+     * @param {string} sourceSyncedAt - When this row was last CONFIRMED against its source — not when it last changed. A delta run asks for everything it has not seen since its last pass, and over 25 000 products that is the difference between an index scan and reading the whole catalog, which is the reason the column is indexed. An edit made here leaves it alone, so a value that has stopped moving says the feed has gone quiet, not that nobody works the record. Null for a row no source owns.
      * @throws {RevenexxException}
      * @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>;
+    productsFamilyVariantsCreate(code: string, familyId: string, axes?: object, externalId?: string, externalRefs?: object, labels?: object, metadata?: object, sourceData?: object, sourceSyncedAt?: string): Promise<Models.FamilyVariants>;
     /**
      * Deletes one family variant by id. It is a hard delete — the row is gone, and the answer is a confirmation rather than a result to branch on.
      *
@@ -1831,8 +2190,13 @@ declare class ProductsDataModel {
      * @param {string} params.id - The `family_variants` 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/family_variants`. An id no family variant of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
      * @param {object} params.axes - The attribute codes a product model splits its variants on. Two shapes are in the wild and both are read: a bare list of codes, or one entry per level, outermost first — `[{"level": 1, "axes": ["colour"]}, {"level": 2, "axes": ["size"]}]`. An attribute named here is READ-ONLY on the model and set on each variant, which is what `AttributeField.readonly_reason` reports.
      * @param {string} params.code - The variant structure's stable identifier — how this family splits, not which product it splits. Unique per tenant.
+     * @param {string} params.externalId - The key this variant structure has in the system it came from. Unique per tenant where set, and usually null — few sources model how a family splits, so this is normally a structure somebody built here.
+     * @param {object} params.externalRefs - Every OTHER system that knows this row, keyed by system name — a second PIM, a supplier's feed, a GTIN register. `external_id` is the system that OWNS the row; this is the rest, so the next identifier standard costs a key in here rather than a column and a migration. It filters the way every jsonb column of this app filters: the WHOLE document is compared, so there is no asking for one key — read the row by `external_id` and take this off the answer.
      * @param {string} params.familyId - The family this variant structure belongs to. A family may carry several, and a product names the one it follows through `family_variant_id`.
      * @param {object} params.labels - What the variant structure is called, per language tag.
+     * @param {object} params.metadata - Free-form jsonb this tenant owns, for anything about a variant structure this app does not model. Nothing here reads it.
+     * @param {object} params.sourceData - What the source said about this row, kept as it said it: `{"system": …, "etag": …, "raw": {…}}`. The `etag` is what a write-back has to hand back in `If-Match`, and between two runs there is nowhere else to keep it. `raw` carries the source fields this app does not model, so they survive a round trip instead of being lost the first time somebody edits here. Written by whatever imports the row; nothing in this app reads or maintains it.
+     * @param {string} params.sourceSyncedAt - When this row was last CONFIRMED against its source — not when it last changed. A delta run asks for everything it has not seen since its last pass, and over 25 000 products that is the difference between an index scan and reading the whole catalog, which is the reason the column is indexed. An edit made here leaves it alone, so a value that has stopped moving says the feed has gone quiet, not that nobody works the record. Null for a row no source owns.
      * @throws {RevenexxException}
      * @returns {Promise<Models.FamilyVariants>}
      */
@@ -1840,8 +2204,13 @@ declare class ProductsDataModel {
         id: string;
         axes?: object;
         code?: string;
+        externalId?: string;
+        externalRefs?: object;
         familyId?: string;
         labels?: object;
+        metadata?: object;
+        sourceData?: object;
+        sourceSyncedAt?: string;
     }): Promise<Models.FamilyVariants>;
     /**
      * Updates one family variant 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.
@@ -1853,13 +2222,18 @@ declare class ProductsDataModel {
      * @param {string} id - The `family_variants` 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/family_variants`. An id no family variant of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
      * @param {object} axes - The attribute codes a product model splits its variants on. Two shapes are in the wild and both are read: a bare list of codes, or one entry per level, outermost first — `[{"level": 1, "axes": ["colour"]}, {"level": 2, "axes": ["size"]}]`. An attribute named here is READ-ONLY on the model and set on each variant, which is what `AttributeField.readonly_reason` reports.
      * @param {string} code - The variant structure's stable identifier — how this family splits, not which product it splits. Unique per tenant.
+     * @param {string} externalId - The key this variant structure has in the system it came from. Unique per tenant where set, and usually null — few sources model how a family splits, so this is normally a structure somebody built here.
+     * @param {object} externalRefs - Every OTHER system that knows this row, keyed by system name — a second PIM, a supplier's feed, a GTIN register. `external_id` is the system that OWNS the row; this is the rest, so the next identifier standard costs a key in here rather than a column and a migration. It filters the way every jsonb column of this app filters: the WHOLE document is compared, so there is no asking for one key — read the row by `external_id` and take this off the answer.
      * @param {string} familyId - The family this variant structure belongs to. A family may carry several, and a product names the one it follows through `family_variant_id`.
      * @param {object} labels - What the variant structure is called, per language tag.
+     * @param {object} metadata - Free-form jsonb this tenant owns, for anything about a variant structure this app does not model. Nothing here reads it.
+     * @param {object} sourceData - What the source said about this row, kept as it said it: `{"system": …, "etag": …, "raw": {…}}`. The `etag` is what a write-back has to hand back in `If-Match`, and between two runs there is nowhere else to keep it. `raw` carries the source fields this app does not model, so they survive a round trip instead of being lost the first time somebody edits here. Written by whatever imports the row; nothing in this app reads or maintains it.
+     * @param {string} sourceSyncedAt - When this row was last CONFIRMED against its source — not when it last changed. A delta run asks for everything it has not seen since its last pass, and over 25 000 products that is the difference between an index scan and reading the whole catalog, which is the reason the column is indexed. An edit made here leaves it alone, so a value that has stopped moving says the feed has gone quiet, not that nobody works the record. Null for a row no source owns.
      * @throws {RevenexxException}
      * @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>;
+    productsFamilyVariantsUpdate(id: string, axes?: object, code?: string, externalId?: string, externalRefs?: object, familyId?: string, labels?: object, metadata?: object, sourceData?: object, sourceSyncedAt?: string): Promise<Models.FamilyVariants>;
     /**
      * A family of units and the standard one they all convert to — weight in kilograms, length in metres. A `measure` attribute names one and then offers exactly that family's units, and each unit's `convert_factor` is what makes two values recorded in different units comparable at all.
      *