@revenexx/node 0.0.1 → 0.1.0

package/dist/services/products-references.d.ts

@@ -0,0 +1,672 @@
+import { Client } from '../client.js';
+import { Models } from '../models.js';
+import '../query.js';
+import '../enums/address-type-row-tone.js';
+import '../enums/address-type-row-create-request-tone.js';
+import '../enums/address-type-row-update-request-tone.js';
+import '../enums/assets-source.js';
+import '../enums/attribute-value-bucket.js';
+import '../enums/auth-mail-source.js';
+import '../enums/recovery-mail-source.js';
+import '../enums/registration-status.js';
+import '../enums/budget-change-reason.js';
+import '../enums/budget-movement-result-status.js';
+import '../enums/cart-status.js';
+import '../enums/cart-merge-strategy.js';
+import '../enums/cart-price-snapshot-mode.js';
+import '../enums/cart-io-format.js';
+import '../enums/cart-export-format.js';
+import '../enums/cart-item-type.js';
+import '../enums/cart-vocabulary-tone.js';
+import '../enums/cart-vocabulary-name.js';
+import '../enums/cart-vocabulary-source.js';
+import '../enums/cart-vocabulary-ref-name.js';
+import '../enums/categories-rule-match.js';
+import '../enums/category-rule-operator.js';
+import '../enums/category-rule-match.js';
+import '../enums/channel-status.js';
+import '../enums/channel-unassigned-visibility.js';
+import '../enums/channel-unresolved-reason.js';
+import '../enums/channel-context-source.js';
+import '../enums/channel-inactive-behavior.js';
+import '../enums/channel-policy-source.js';
+import '../enums/channel-policy-tenant-default.js';
+import '../enums/channel-unassigned-policy.js';
+import '../enums/channel-type-tone.js';
+import '../enums/channel-visibility-reason.js';
+import '../enums/channel-vocabulary-tone.js';
+import '../enums/channel-vocabulary-name.js';
+import '../enums/channel-vocabulary-source.js';
+import '../enums/channel-vocabulary-ref-name.js';
+import '../enums/contact-registration-status.js';
+import '../enums/contact-status.js';
+import '../enums/contact-activity-kind.js';
+import '../enums/contact-create-request-registration-status.js';
+import '../enums/contact-event-kind-tone.js';
+import '../enums/contact-event-kind-create-request-tone.js';
+import '../enums/contact-event-kind-update-request-tone.js';
+import '../enums/contact-update-request-registration-status.js';
+import '../enums/cost-center-budget-type.js';
+import '../enums/cost-center-restriction-type.js';
+import '../enums/cost-center-restriction-create-request-type.js';
+import '../enums/cost-center-restriction-update-request-type.js';
+import '../enums/payment-fee-type.js';
+import '../enums/payment-method-kind.js';
+import '../enums/form-status.js';
+import '../enums/form-submission-status.js';
+import '../enums/form-notify-source.js';
+import '../enums/form-submission-prune-request-status.js';
+import '../enums/forms-vocabulary-tone.js';
+import '../enums/forms-vocabulary-name.js';
+import '../enums/forms-vocabulary-summary-name.js';
+import '../enums/inventory-vocabulary-default-tone.js';
+import '../enums/inventory-vocabulary-source.js';
+import '../enums/cart-io-apply-mode.js';
+import '../enums/cart-io-direction.js';
+import '../enums/cart-io-entity.js';
+import '../enums/io-profile-resource-apply-mode.js';
+import '../enums/io-profile-resource-direction.js';
+import '../enums/lifecycle-stage-tone.js';
+import '../enums/lifecycle-stage-create-request-tone.js';
+import '../enums/lifecycle-stage-update-request-tone.js';
+import '../enums/location-type.js';
+import '../enums/market-status.js';
+import '../enums/market-default-locale-source.js';
+import '../enums/market-locale-fallback.js';
+import '../enums/market-locale-granularity.js';
+import '../enums/market-pricing-source.js';
+import '../enums/market-tax-basis.js';
+import '../enums/market-readiness-check-id.js';
+import '../enums/market-readiness-severity.js';
+import '../enums/markets-vocabulary-tone.js';
+import '../enums/markets-vocabulary-name.js';
+import '../enums/markets-vocabulary-source.js';
+import '../enums/markets-vocabulary-summary-name.js';
+import '../enums/order-fulfillment-status.js';
+import '../enums/order-payment-status.js';
+import '../enums/order-status.js';
+import '../enums/order-cancellation-scope.js';
+import '../enums/order-comment-visibility.js';
+import '../enums/order-item-type.js';
+import '../enums/order-list-kind-tone.js';
+import '../enums/order-list-kind-row-tone.js';
+import '../enums/order-list-cart-mode.js';
+import '../enums/order-list-vocabulary-default-tone.js';
+import '../enums/order-list-vocabulary-name.js';
+import '../enums/order-list-vocabulary-source.js';
+import '../enums/order-list-vocabulary-tone.js';
+import '../enums/order-return-status.js';
+import '../enums/order-return-settlement.js';
+import '../enums/order-return-refusal.js';
+import '../enums/order-vocabulary-tone.js';
+import '../enums/order-vocabulary-name.js';
+import '../enums/order-vocabulary-source.js';
+import '../enums/order-vocabulary-summary-name.js';
+import '../enums/order-resolution-stage.js';
+import '../enums/organization-status.js';
+import '../enums/page-status.js';
+import '../enums/pages-vocabulary-app.js';
+import '../enums/pages-vocabulary-tone.js';
+import '../enums/pages-vocabulary-name.js';
+import '../enums/pages-vocabulary-source.js';
+import '../enums/pages-vocabulary-index-app.js';
+import '../enums/payment-dunning-stage.js';
+import '../enums/payment-failure-code.js';
+import '../enums/payment-status.js';
+import '../enums/payment-term-tone.js';
+import '../enums/payment-term-create-request-tone.js';
+import '../enums/payment-term-update-request-tone.js';
+import '../enums/payment-vocabulary-tone.js';
+import '../enums/price-ending-rule.js';
+import '../enums/price-entries-adjust-response-rounding.js';
+import '../enums/price-entries-adjust-response-rounding-mode.js';
+import '../enums/price-entries-bulk-mode.js';
+import '../enums/price-rounding-mode.js';
+import '../enums/price-entry-type.js';
+import '../enums/price-list-status.js';
+import '../enums/price-list-tax-basis.js';
+import '../enums/price-currency-source.js';
+import '../enums/price-list-tiebreak.js';
+import '../enums/price-tax-inclusive-default.js';
+import '../enums/price-tax-unresolved-reason.js';
+import '../enums/price-tax-market-source.js';
+import '../enums/price-vocabulary-tone.js';
+import '../enums/price-vocabulary-name.js';
+import '../enums/price-vocabulary-source.js';
+import '../enums/price-vocabulary-ref-name.js';
+import '../enums/product-categories-source.js';
+import '../enums/product-grid-column-source.js';
+import '../enums/product-label-source.js';
+import '../enums/product-label-attribute-source.js';
+import '../enums/products-kind.js';
+import '../enums/reorder-point-source.js';
+import '../enums/reservation-status.js';
+import '../enums/price-on-request-reason.js';
+import '../enums/price-tax-basis.js';
+import '../enums/price-tax-basis-source.js';
+import '../enums/role-catalog-response-source.js';
+import '../enums/segment-rule-match.js';
+import '../enums/segment-member-source.js';
+import '../enums/segment-rule-operator.js';
+import '../enums/segment-rule-preview-request-rule-match.js';
+import '../enums/segment-rule-preview-request-target.js';
+import '../enums/segment-rule-preview-response-rule-match.js';
+import '../enums/segment-rule-preview-response-target.js';
+import '../enums/segment-rules-target.js';
+import '../enums/shipping-carrier-status.js';
+import '../enums/shipping-method-matrix-basis.js';
+import '../enums/shipping-method-pricing-type.js';
+import '../enums/shipping-carrier-source.js';
+import '../enums/shipping-rate-pricing-type.js';
+import '../enums/shipping-tax-source.js';
+import '../enums/shipping-free-above-basis.js';
+import '../enums/shipping-rates-basis-matrix-basis-default.js';
+import '../enums/shipping-service-level-create-request-tone.js';
+import '../enums/shipping-service-level-row-tone.js';
+import '../enums/shipping-service-level-update-request-tone.js';
+import '../enums/shipping-tax-unresolved-reason.js';
+import '../enums/shipping-tax-market-source.js';
+import '../enums/shipping-tax-context-via.js';
+import '../enums/shipping-tracking-carrier-status.js';
+import '../enums/shipping-vocabulary-default-tone.js';
+import '../enums/shipping-vocabulary-source.js';
+import '../enums/shipping-vocabulary-tone.js';
+import '../enums/shipping-weight-unit-create-request-tone.js';
+import '../enums/shipping-weight-unit-row-tone.js';
+import '../enums/shipping-weight-unit-update-request-tone.js';
+import '../enums/stock-movement-type.js';
+import '../enums/store-asset-request-visibility.js';
+import '../enums/validation-failed-response-status.js';
+import '../enums/vocabulary-default-tone.js';
+import '../enums/vocabulary-source.js';
+import '../enums/vocabulary-tone.js';
+import '../enums/attribute-boolean-status.js';
+import '../enums/attribute-datetime-status.js';
+import '../enums/attribute-email-status.js';
+import '../enums/attribute-enum-status.js';
+import '../enums/attribute-float-status.js';
+import '../enums/attribute-integer-status.js';
+import '../enums/attribute-ip-status.js';
+import '../enums/attribute-line-status.js';
+import '../enums/attribute-longtext-status.js';
+import '../enums/attribute-mediumtext-status.js';
+import '../enums/attribute-point-status.js';
+import '../enums/attribute-polygon-status.js';
+import '../enums/attribute-relationship-status.js';
+import '../enums/attribute-string-status.js';
+import '../enums/attribute-text-status.js';
+import '../enums/attribute-url-status.js';
+import '../enums/attribute-varchar-status.js';
+import '../enums/column-boolean-status.js';
+import '../enums/column-datetime-status.js';
+import '../enums/column-email-status.js';
+import '../enums/column-enum-status.js';
+import '../enums/column-float-status.js';
+import '../enums/column-integer-status.js';
+import '../enums/column-ip-status.js';
+import '../enums/column-line-status.js';
+import '../enums/column-longtext-status.js';
+import '../enums/column-mediumtext-status.js';
+import '../enums/column-point-status.js';
+import '../enums/column-polygon-status.js';
+import '../enums/column-relationship-status.js';
+import '../enums/column-string-status.js';
+import '../enums/column-text-status.js';
+import '../enums/column-url-status.js';
+import '../enums/column-varchar-status.js';
+import '../enums/database-type.js';
+import '../enums/deployment-status.js';
+import '../enums/execution-status.js';
+import '../enums/execution-trigger.js';
+import '../enums/health-antivirus-status.js';
+import '../enums/health-status-status.js';
+import '../enums/index-status.js';
+import '../enums/message-2-status.js';
+
+declare class ProductsReferences {
+    client: Client;
+    constructor(client: Client);
+    /**
+     * A domain of records the catalog POINTS AT instead of duplicating — brands, manufacturers, care instructions. Declaring one is how a brand comes to be edited in one place rather than on nine thousand products. A reference entity has attributes of its own (`attributes` rows with `entity_type: "reference_entity"` and this entity's code as `entity_ref`), which is what makes its records more than a label.
+     *
+     * Every column of `reference_entities` is an exact-match query parameter, `order` sorts by one column, and `limit`/`offset` page through `page.total`. A query key that is NOT a column is dropped rather than refused, and the `filter` object echoes the ones that were understood — that echo is the only way to tell an unfiltered answer from an empty one. It reads rows exactly as they are stored: no join is resolved, no jsonb value is unpacked.
+     *
+     * Answered from the gateway's tenant cache for up to 30 minutes and dropped the moment this entity is written, because the data model changes weekly at most and every product page asks the same question.
+     *
+     * @param {number} params.limit - Page size (default 50, max 200). A larger value is clamped rather than refused.
+     * @param {number} params.offset - Row offset for pagination (default 0). Page with `page.total` and `page.hasMore`.
+     * @param {string} params.order - Sort by one column: 'column' | 'column.asc' | 'column.desc'. A bare column sorts ascending. Anything else is refused with 400.
+     * @param {string} params.id - Exact match on `id`. The row's own id, generated by the database. A client never sends one; it reads one back and uses it in the path of every later call.
+     * @param {string} params.code - Exact match on `code`. The entity's stable identifier — a domain of records the catalog POINTS AT instead of duplicating, so a brand is edited once and not on nine thousand products. Unique per tenant.
+     * @param {string} params.labels - Exact match on `labels`. What the entity is called, per language tag — the heading over its record list. 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.image - Exact match on `image`. A delivery path or URL for the entity's own icon. Cosmetic — nothing in this app resolves it.
+     * @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<{}>}
+     */
+    productsReferenceEntitiesList(params?: {
+        limit?: number;
+        offset?: number;
+        order?: string;
+        id?: string;
+        code?: string;
+        labels?: string;
+        image?: string;
+        createdAt?: string;
+        updatedAt?: string;
+    }): Promise<{}>;
+    /**
+     * A domain of records the catalog POINTS AT instead of duplicating — brands, manufacturers, care instructions. Declaring one is how a brand comes to be edited in one place rather than on nine thousand products. A reference entity has attributes of its own (`attributes` rows with `entity_type: "reference_entity"` and this entity's code as `entity_ref`), which is what makes its records more than a label.
+     *
+     * Every column of `reference_entities` is an exact-match query parameter, `order` sorts by one column, and `limit`/`offset` page through `page.total`. A query key that is NOT a column is dropped rather than refused, and the `filter` object echoes the ones that were understood — that echo is the only way to tell an unfiltered answer from an empty one. It reads rows exactly as they are stored: no join is resolved, no jsonb value is unpacked.
+     *
+     * Answered from the gateway's tenant cache for up to 30 minutes and dropped the moment this entity is written, because the data model changes weekly at most and every product page asks the same question.
+     *
+     * @param {number} limit - Page size (default 50, max 200). A larger value is clamped rather than refused.
+     * @param {number} offset - Row offset for pagination (default 0). Page with `page.total` and `page.hasMore`.
+     * @param {string} order - Sort by one column: 'column' | 'column.asc' | 'column.desc'. A bare column sorts ascending. Anything else is refused with 400.
+     * @param {string} id - Exact match on `id`. The row's own id, generated by the database. A client never sends one; it reads one back and uses it in the path of every later call.
+     * @param {string} code - Exact match on `code`. The entity's stable identifier — a domain of records the catalog POINTS AT instead of duplicating, so a brand is edited once and not on nine thousand products. Unique per tenant.
+     * @param {string} labels - Exact match on `labels`. What the entity is called, per language tag — the heading over its record list. 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} image - Exact match on `image`. A delivery path or URL for the entity's own icon. Cosmetic — nothing in this app resolves it.
+     * @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.
+     */
+    productsReferenceEntitiesList(limit?: number, offset?: number, order?: string, id?: string, code?: string, labels?: string, image?: string, createdAt?: string, updatedAt?: string): Promise<{}>;
+    /**
+     * Creates one reference entity 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.
+     *
+     * A domain of records the catalog POINTS AT instead of duplicating — brands, manufacturers, care instructions. Declaring one is how a brand comes to be edited in one place rather than on nine thousand products. A reference entity has attributes of its own (`attributes` rows with `entity_type: "reference_entity"` and this entity's code as `entity_ref`), which is what makes its records more than a label.
+     *
+     * `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 entity's stable identifier — a domain of records the catalog POINTS AT instead of duplicating, so a brand is edited once and not on nine thousand products. Unique per tenant.
+     * @param {string} params.image - A delivery path or URL for the entity's own icon. Cosmetic — nothing in this app resolves it.
+     * @param {object} params.labels - What the entity is called, per language tag — the heading over its record list.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     */
+    productsReferenceEntitiesCreate(params: {
+        code: string;
+        image?: string;
+        labels?: object;
+    }): Promise<Models.Error>;
+    /**
+     * Creates one reference entity 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.
+     *
+     * A domain of records the catalog POINTS AT instead of duplicating — brands, manufacturers, care instructions. Declaring one is how a brand comes to be edited in one place rather than on nine thousand products. A reference entity has attributes of its own (`attributes` rows with `entity_type: "reference_entity"` and this entity's code as `entity_ref`), which is what makes its records more than a label.
+     *
+     * `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 entity's stable identifier — a domain of records the catalog POINTS AT instead of duplicating, so a brand is edited once and not on nine thousand products. Unique per tenant.
+     * @param {string} image - A delivery path or URL for the entity's own icon. Cosmetic — nothing in this app resolves it.
+     * @param {object} labels - What the entity is called, per language tag — the heading over its record list.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    productsReferenceEntitiesCreate(code: string, image?: string, labels?: object): Promise<Models.Error>;
+    /**
+     * Deletes one reference entity by id. It is a hard delete — the row is gone, and the answer is a confirmation rather than a result to branch on.
+     *
+     * It takes what hangs off it: reference entity records (`reference_entity_id`) are deleted with it.
+     *
+     * An id no reference entity of this tenant carries answers 404; there is no 409, because every foreign key pointing at this entity resolves itself on delete rather than blocking one.
+     *
+     * @param {string} params.id - The `reference_entities` 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/reference_entities`. An id no reference entitie of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     */
+    productsReferenceEntitiesDelete(params: {
+        id: string;
+    }): Promise<Models.Error>;
+    /**
+     * Deletes one reference entity by id. It is a hard delete — the row is gone, and the answer is a confirmation rather than a result to branch on.
+     *
+     * It takes what hangs off it: reference entity records (`reference_entity_id`) are deleted with it.
+     *
+     * An id no reference entity of this tenant carries answers 404; there is no 409, because every foreign key pointing at this entity resolves itself on delete rather than blocking one.
+     *
+     * @param {string} id - The `reference_entities` 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/reference_entities`. An id no reference entitie of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    productsReferenceEntitiesDelete(id: string): Promise<Models.Error>;
+    /**
+     * Reads one reference entity by its id — the whole row, every column, as it is stored.
+     *
+     * A domain of records the catalog POINTS AT instead of duplicating — brands, manufacturers, care instructions. Declaring one is how a brand comes to be edited in one place rather than on nine thousand products. A reference entity has attributes of its own (`attributes` rows with `entity_type: "reference_entity"` and this entity's code as `entity_ref`), which is what makes its records more than a label.
+     *
+     * An id no reference entity of this tenant carries answers 404, and so does one belonging to another tenant: row-level security makes that row invisible rather than forbidden. A malformed id answers 400 before the route is reached.
+     *
+     * Answered from the gateway's tenant cache for up to 30 minutes and dropped the moment this entity is written, because the data model changes weekly at most and every product page asks the same question.
+     *
+     * @param {string} params.id - The `reference_entities` 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/reference_entities`. An id no reference entitie of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     */
+    productsReferenceEntitiesGet(params: {
+        id: string;
+    }): Promise<Models.Error>;
+    /**
+     * Reads one reference entity by its id — the whole row, every column, as it is stored.
+     *
+     * A domain of records the catalog POINTS AT instead of duplicating — brands, manufacturers, care instructions. Declaring one is how a brand comes to be edited in one place rather than on nine thousand products. A reference entity has attributes of its own (`attributes` rows with `entity_type: "reference_entity"` and this entity's code as `entity_ref`), which is what makes its records more than a label.
+     *
+     * An id no reference entity of this tenant carries answers 404, and so does one belonging to another tenant: row-level security makes that row invisible rather than forbidden. A malformed id answers 400 before the route is reached.
+     *
+     * Answered from the gateway's tenant cache for up to 30 minutes and dropped the moment this entity is written, because the data model changes weekly at most and every product page asks the same question.
+     *
+     * @param {string} id - The `reference_entities` 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/reference_entities`. An id no reference entitie of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    productsReferenceEntitiesGet(id: string): Promise<Models.Error>;
+    /**
+     * Updates one reference entity 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.
+     *
+     * A domain of records the catalog POINTS AT instead of duplicating — brands, manufacturers, care instructions. Declaring one is how a brand comes to be edited in one place rather than on nine thousand products. A reference entity has attributes of its own (`attributes` rows with `entity_type: "reference_entity"` and this entity's code as `entity_ref`), which is what makes its records more than a label.
+     *
+     * A body that names nothing writable is refused with 400 rather than answered as a no-op, an id nobody carries answers 404, and a value that collides on `code` answers 409.
+     *
+     * @param {string} params.id - The `reference_entities` 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/reference_entities`. An id no reference entitie of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @param {string} params.code - The entity's stable identifier — a domain of records the catalog POINTS AT instead of duplicating, so a brand is edited once and not on nine thousand products. Unique per tenant.
+     * @param {string} params.image - A delivery path or URL for the entity's own icon. Cosmetic — nothing in this app resolves it.
+     * @param {object} params.labels - What the entity is called, per language tag — the heading over its record list.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     */
+    productsReferenceEntitiesUpdate(params: {
+        id: string;
+        code?: string;
+        image?: string;
+        labels?: object;
+    }): Promise<Models.Error>;
+    /**
+     * Updates one reference entity 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.
+     *
+     * A domain of records the catalog POINTS AT instead of duplicating — brands, manufacturers, care instructions. Declaring one is how a brand comes to be edited in one place rather than on nine thousand products. A reference entity has attributes of its own (`attributes` rows with `entity_type: "reference_entity"` and this entity's code as `entity_ref`), which is what makes its records more than a label.
+     *
+     * A body that names nothing writable is refused with 400 rather than answered as a no-op, an id nobody carries answers 404, and a value that collides on `code` answers 409.
+     *
+     * @param {string} id - The `reference_entities` 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/reference_entities`. An id no reference entitie of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @param {string} code - The entity's stable identifier — a domain of records the catalog POINTS AT instead of duplicating, so a brand is edited once and not on nine thousand products. Unique per tenant.
+     * @param {string} image - A delivery path or URL for the entity's own icon. Cosmetic — nothing in this app resolves it.
+     * @param {object} labels - What the entity is called, per language tag — the heading over its record list.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    productsReferenceEntitiesUpdate(id: string, code?: string, image?: string, labels?: object): Promise<Models.Error>;
+    /**
+     * One record of a reference entity — one brand, one manufacturer. A product that points at it stores this record's CODE, exactly the way a select stores an option code, and the record's own properties live in its scoped `attribute_values` document. `GET /products/attribute-schema` offers these records as the `options` of any attribute that points at their entity, so a picker needs no second call.
+     *
+     * Every column of `reference_entity_records` is an exact-match query parameter, `order` sorts by one column, and `limit`/`offset` page through `page.total`. A query key that is NOT a column is dropped rather than refused, and the `filter` object echoes the ones that were understood — that echo is the only way to tell an unfiltered answer from an empty one. It reads rows exactly as they are stored: no join is resolved, no jsonb value is unpacked.
+     *
+     * Answered from the gateway's tenant cache for up to 30 minutes and dropped the moment this entity is written, because the data model changes weekly at most and every product page asks the same question.
+     *
+     * @param {number} params.limit - Page size (default 50, max 200). A larger value is clamped rather than refused.
+     * @param {number} params.offset - Row offset for pagination (default 0). Page with `page.total` and `page.hasMore`.
+     * @param {string} params.order - Sort by one column: 'column' | 'column.asc' | 'column.desc'. A bare column sorts ascending. Anything else is refused with 400.
+     * @param {string} params.id - Exact match on `id`. The row's own id, generated by the database. A client never sends one; it reads one back and uses it in the path of every later call.
+     * @param {string} params.referenceEntityId - Exact match on `reference_entity_id`. Which reference entity this record belongs to.
+     * @param {string} params.code - Exact match on `code`. The record's stable identifier — the value a product stores when it points at this record, the same way a select stores an option code. Unique within the entity.
+     * @param {string} params.labels - Exact match on `labels`. What the record is called, per language tag — the text a picker shows while the code is what gets written. 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.attributeValues - Exact match on `attribute_values`. Every attribute value the record carries, in ONE jsonb document — the core of an attribute-driven PIM. A record's properties are not columns here: they are rows in `attributes`, selected per family by `family_attributes`, and their values live under their attribute CODE inside this object. The whole jsonb document is compared, serialized as JSON — this is equality, not a path or containment query, and `null` cannot be matched this way. A value that does not parse as JSON is refused with 400 `invalid_value`, naming this filter, before the request reaches the data plane.
+     * @param {string} params.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<{}>}
+     */
+    productsReferenceEntityRecordsList(params?: {
+        limit?: number;
+        offset?: number;
+        order?: string;
+        id?: string;
+        referenceEntityId?: string;
+        code?: string;
+        labels?: string;
+        attributeValues?: string;
+        createdAt?: string;
+        updatedAt?: string;
+    }): Promise<{}>;
+    /**
+     * One record of a reference entity — one brand, one manufacturer. A product that points at it stores this record's CODE, exactly the way a select stores an option code, and the record's own properties live in its scoped `attribute_values` document. `GET /products/attribute-schema` offers these records as the `options` of any attribute that points at their entity, so a picker needs no second call.
+     *
+     * Every column of `reference_entity_records` is an exact-match query parameter, `order` sorts by one column, and `limit`/`offset` page through `page.total`. A query key that is NOT a column is dropped rather than refused, and the `filter` object echoes the ones that were understood — that echo is the only way to tell an unfiltered answer from an empty one. It reads rows exactly as they are stored: no join is resolved, no jsonb value is unpacked.
+     *
+     * Answered from the gateway's tenant cache for up to 30 minutes and dropped the moment this entity is written, because the data model changes weekly at most and every product page asks the same question.
+     *
+     * @param {number} limit - Page size (default 50, max 200). A larger value is clamped rather than refused.
+     * @param {number} offset - Row offset for pagination (default 0). Page with `page.total` and `page.hasMore`.
+     * @param {string} order - Sort by one column: 'column' | 'column.asc' | 'column.desc'. A bare column sorts ascending. Anything else is refused with 400.
+     * @param {string} id - Exact match on `id`. The row's own id, generated by the database. A client never sends one; it reads one back and uses it in the path of every later call.
+     * @param {string} referenceEntityId - Exact match on `reference_entity_id`. Which reference entity this record belongs to.
+     * @param {string} code - Exact match on `code`. The record's stable identifier — the value a product stores when it points at this record, the same way a select stores an option code. Unique within the entity.
+     * @param {string} labels - Exact match on `labels`. What the record is called, per language tag — the text a picker shows while the code is what gets written. 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} attributeValues - Exact match on `attribute_values`. Every attribute value the record carries, in ONE jsonb document — the core of an attribute-driven PIM. A record's properties are not columns here: they are rows in `attributes`, selected per family by `family_attributes`, and their values live under their attribute CODE inside this object. The whole jsonb document is compared, serialized as JSON — this is equality, not a path or containment query, and `null` cannot be matched this way. A value that does not parse as JSON is refused with 400 `invalid_value`, naming this filter, before the request reaches the data plane.
+     * @param {string} 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.
+     */
+    productsReferenceEntityRecordsList(limit?: number, offset?: number, order?: string, id?: string, referenceEntityId?: string, code?: string, labels?: string, attributeValues?: string, createdAt?: string, updatedAt?: string): Promise<{}>;
+    /**
+     * Creates one reference entity record 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.
+     *
+     * One record of a reference entity — one brand, one manufacturer. A product that points at it stores this record's CODE, exactly the way a select stores an option code, and the record's own properties live in its scoped `attribute_values` document. `GET /products/attribute-schema` offers these records as the `options` of any attribute that points at their entity, so a picker needs no second call.
+     *
+     * `reference_entity_id` and `code` are the only columns the database refuses the row without; everything else has a default or is nullable. A second row with the same `reference_entity_id` and `code` answers 409.
+     *
+     * @param {string} params.code - The record's stable identifier — the value a product stores when it points at this record, the same way a select stores an option code. Unique within the entity.
+     * @param {string} params.referenceEntityId - Which reference entity this record belongs to.
+     * @param {object} params.attributeValues - Every attribute value the record carries, in ONE jsonb document — the core of an attribute-driven PIM. A record's properties are not columns here: they are rows in `attributes`, selected per family by `family_attributes`, and their values live under their attribute CODE inside this object.
+
+Four buckets, and an attribute's own flags decide which one it writes to:
+
+  `common`                    the attribute is neither localizable nor scopable — one value, full stop.
+                              `{"common": {"net_weight": 2.4, "colour": "black"}}`
+  `locale_specific`           `localizable`: one value per language tag.
+                              `{"locale_specific": {"de_DE": {"name": "Akku-Bohrschrauber"}}}`
+  `channel_specific`          `scopable`: one value per channel.
+                              `{"channel_specific": {"b2b": {"minimum_order_quantity": 6}}}`
+  `channel_locale_specific`   both: one value per channel AND language tag.
+                              `{"channel_locale_specific": {"b2b": {"de_DE": {"description": "…"}}}}`
+
+A reader takes the most specific bucket that carries the code and falls back through locale, then channel, then `common`. `common` is always last and always consulted, because early imports wrote everything there whatever an attribute's flags said — a reader that skipped it reports an imported catalog as empty. `GET /products/attribute-schema` answers, per field, the exact path a value belongs at (`storage.path`) and that full fallback order (`from`), so no client has to re-derive any of this.
+
+The value itself is whatever the attribute's `type` implies: a string, a number, a boolean, an option CODE for a select (never its label), a list of codes for a multi-select, `{"amount": …, "unit": …}` for a measure, a list of `{"amount": …, "currency": …}` for a price, an asset code for media.
+
+Defaults to `{}`, and an empty object is a normal state — a record nobody has enriched yet. The declared type also admits an array only because every jsonb column of this app shares one mapping; an array is not meaningful here and every reader in this app treats a non-object as empty.
+
+Which attributes a record of this entity has comes from `attributes` rows with `entity_type: "reference_entity"` and `entity_ref` equal to the entity's code — `GET /products/attribute-schema?entity_type=reference_entity&entity_ref=brand` answers it in one call.
+     * @param {object} params.labels - What the record is called, per language tag — the text a picker shows while the code is what gets written.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     */
+    productsReferenceEntityRecordsCreate(params: {
+        code: string;
+        referenceEntityId: string;
+        attributeValues?: object;
+        labels?: object;
+    }): Promise<Models.Error>;
+    /**
+     * Creates one reference entity record 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.
+     *
+     * One record of a reference entity — one brand, one manufacturer. A product that points at it stores this record's CODE, exactly the way a select stores an option code, and the record's own properties live in its scoped `attribute_values` document. `GET /products/attribute-schema` offers these records as the `options` of any attribute that points at their entity, so a picker needs no second call.
+     *
+     * `reference_entity_id` and `code` are the only columns the database refuses the row without; everything else has a default or is nullable. A second row with the same `reference_entity_id` and `code` answers 409.
+     *
+     * @param {string} code - The record's stable identifier — the value a product stores when it points at this record, the same way a select stores an option code. Unique within the entity.
+     * @param {string} referenceEntityId - Which reference entity this record belongs to.
+     * @param {object} attributeValues - Every attribute value the record carries, in ONE jsonb document — the core of an attribute-driven PIM. A record's properties are not columns here: they are rows in `attributes`, selected per family by `family_attributes`, and their values live under their attribute CODE inside this object.
+
+Four buckets, and an attribute's own flags decide which one it writes to:
+
+  `common`                    the attribute is neither localizable nor scopable — one value, full stop.
+                              `{"common": {"net_weight": 2.4, "colour": "black"}}`
+  `locale_specific`           `localizable`: one value per language tag.
+                              `{"locale_specific": {"de_DE": {"name": "Akku-Bohrschrauber"}}}`
+  `channel_specific`          `scopable`: one value per channel.
+                              `{"channel_specific": {"b2b": {"minimum_order_quantity": 6}}}`
+  `channel_locale_specific`   both: one value per channel AND language tag.
+                              `{"channel_locale_specific": {"b2b": {"de_DE": {"description": "…"}}}}`
+
+A reader takes the most specific bucket that carries the code and falls back through locale, then channel, then `common`. `common` is always last and always consulted, because early imports wrote everything there whatever an attribute's flags said — a reader that skipped it reports an imported catalog as empty. `GET /products/attribute-schema` answers, per field, the exact path a value belongs at (`storage.path`) and that full fallback order (`from`), so no client has to re-derive any of this.
+
+The value itself is whatever the attribute's `type` implies: a string, a number, a boolean, an option CODE for a select (never its label), a list of codes for a multi-select, `{"amount": …, "unit": …}` for a measure, a list of `{"amount": …, "currency": …}` for a price, an asset code for media.
+
+Defaults to `{}`, and an empty object is a normal state — a record nobody has enriched yet. The declared type also admits an array only because every jsonb column of this app shares one mapping; an array is not meaningful here and every reader in this app treats a non-object as empty.
+
+Which attributes a record of this entity has comes from `attributes` rows with `entity_type: "reference_entity"` and `entity_ref` equal to the entity's code — `GET /products/attribute-schema?entity_type=reference_entity&entity_ref=brand` answers it in one call.
+     * @param {object} labels - What the record is called, per language tag — the text a picker shows while the code is what gets written.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    productsReferenceEntityRecordsCreate(code: string, referenceEntityId: string, attributeValues?: object, labels?: object): Promise<Models.Error>;
+    /**
+     * Deletes one reference entity record by id. It is a hard delete — the row is gone, and the answer is a confirmation rather than a result to branch on.
+     *
+     * Nothing in this schema references it, so nothing else changes.
+     *
+     * An id no reference entity record of this tenant carries answers 404; there is no 409, because every foreign key pointing at this entity resolves itself on delete rather than blocking one.
+     *
+     * @param {string} params.id - The `reference_entity_records` 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/reference_entity_records`. An id no reference entity record of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     */
+    productsReferenceEntityRecordsDelete(params: {
+        id: string;
+    }): Promise<Models.Error>;
+    /**
+     * Deletes one reference entity record by id. It is a hard delete — the row is gone, and the answer is a confirmation rather than a result to branch on.
+     *
+     * Nothing in this schema references it, so nothing else changes.
+     *
+     * An id no reference entity record of this tenant carries answers 404; there is no 409, because every foreign key pointing at this entity resolves itself on delete rather than blocking one.
+     *
+     * @param {string} id - The `reference_entity_records` 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/reference_entity_records`. An id no reference entity record of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    productsReferenceEntityRecordsDelete(id: string): Promise<Models.Error>;
+    /**
+     * Reads one reference entity record by its id — the whole row, every column, as it is stored.
+     *
+     * One record of a reference entity — one brand, one manufacturer. A product that points at it stores this record's CODE, exactly the way a select stores an option code, and the record's own properties live in its scoped `attribute_values` document. `GET /products/attribute-schema` offers these records as the `options` of any attribute that points at their entity, so a picker needs no second call.
+     *
+     * An id no reference entity record of this tenant carries answers 404, and so does one belonging to another tenant: row-level security makes that row invisible rather than forbidden. A malformed id answers 400 before the route is reached.
+     *
+     * Answered from the gateway's tenant cache for up to 30 minutes and dropped the moment this entity is written, because the data model changes weekly at most and every product page asks the same question.
+     *
+     * @param {string} params.id - The `reference_entity_records` 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/reference_entity_records`. An id no reference entity record of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     */
+    productsReferenceEntityRecordsGet(params: {
+        id: string;
+    }): Promise<Models.Error>;
+    /**
+     * Reads one reference entity record by its id — the whole row, every column, as it is stored.
+     *
+     * One record of a reference entity — one brand, one manufacturer. A product that points at it stores this record's CODE, exactly the way a select stores an option code, and the record's own properties live in its scoped `attribute_values` document. `GET /products/attribute-schema` offers these records as the `options` of any attribute that points at their entity, so a picker needs no second call.
+     *
+     * An id no reference entity record of this tenant carries answers 404, and so does one belonging to another tenant: row-level security makes that row invisible rather than forbidden. A malformed id answers 400 before the route is reached.
+     *
+     * Answered from the gateway's tenant cache for up to 30 minutes and dropped the moment this entity is written, because the data model changes weekly at most and every product page asks the same question.
+     *
+     * @param {string} id - The `reference_entity_records` 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/reference_entity_records`. An id no reference entity record of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    productsReferenceEntityRecordsGet(id: string): Promise<Models.Error>;
+    /**
+     * Updates one reference entity record by id. A partial patch: the body names only the columns to change and every column it leaves out keeps its current value, so there is no read-modify-write and no way to blank a field by forgetting it.
+     *
+     * One record of a reference entity — one brand, one manufacturer. A product that points at it stores this record's CODE, exactly the way a select stores an option code, and the record's own properties live in its scoped `attribute_values` document. `GET /products/attribute-schema` offers these records as the `options` of any attribute that points at their entity, so a picker needs no second call.
+     *
+     * A body that names nothing writable is refused with 400 rather than answered as a no-op, an id nobody carries answers 404, and a value that collides on `reference_entity_id` and `code` answers 409.
+     *
+     * @param {string} params.id - The `reference_entity_records` 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/reference_entity_records`. An id no reference entity record of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @param {object} params.attributeValues - Every attribute value the record carries, in ONE jsonb document — the core of an attribute-driven PIM. A record's properties are not columns here: they are rows in `attributes`, selected per family by `family_attributes`, and their values live under their attribute CODE inside this object.
+
+Four buckets, and an attribute's own flags decide which one it writes to:
+
+  `common`                    the attribute is neither localizable nor scopable — one value, full stop.
+                              `{"common": {"net_weight": 2.4, "colour": "black"}}`
+  `locale_specific`           `localizable`: one value per language tag.
+                              `{"locale_specific": {"de_DE": {"name": "Akku-Bohrschrauber"}}}`
+  `channel_specific`          `scopable`: one value per channel.
+                              `{"channel_specific": {"b2b": {"minimum_order_quantity": 6}}}`
+  `channel_locale_specific`   both: one value per channel AND language tag.
+                              `{"channel_locale_specific": {"b2b": {"de_DE": {"description": "…"}}}}`
+
+A reader takes the most specific bucket that carries the code and falls back through locale, then channel, then `common`. `common` is always last and always consulted, because early imports wrote everything there whatever an attribute's flags said — a reader that skipped it reports an imported catalog as empty. `GET /products/attribute-schema` answers, per field, the exact path a value belongs at (`storage.path`) and that full fallback order (`from`), so no client has to re-derive any of this.
+
+The value itself is whatever the attribute's `type` implies: a string, a number, a boolean, an option CODE for a select (never its label), a list of codes for a multi-select, `{"amount": …, "unit": …}` for a measure, a list of `{"amount": …, "currency": …}` for a price, an asset code for media.
+
+Defaults to `{}`, and an empty object is a normal state — a record nobody has enriched yet. The declared type also admits an array only because every jsonb column of this app shares one mapping; an array is not meaningful here and every reader in this app treats a non-object as empty.
+
+Which attributes a record of this entity has comes from `attributes` rows with `entity_type: "reference_entity"` and `entity_ref` equal to the entity's code — `GET /products/attribute-schema?entity_type=reference_entity&entity_ref=brand` answers it in one call.
+     * @param {string} params.code - The record's stable identifier — the value a product stores when it points at this record, the same way a select stores an option code. Unique within the entity.
+     * @param {object} params.labels - What the record is called, per language tag — the text a picker shows while the code is what gets written.
+     * @param {string} params.referenceEntityId - Which reference entity this record belongs to.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     */
+    productsReferenceEntityRecordsUpdate(params: {
+        id: string;
+        attributeValues?: object;
+        code?: string;
+        labels?: object;
+        referenceEntityId?: string;
+    }): Promise<Models.Error>;
+    /**
+     * Updates one reference entity record by id. A partial patch: the body names only the columns to change and every column it leaves out keeps its current value, so there is no read-modify-write and no way to blank a field by forgetting it.
+     *
+     * One record of a reference entity — one brand, one manufacturer. A product that points at it stores this record's CODE, exactly the way a select stores an option code, and the record's own properties live in its scoped `attribute_values` document. `GET /products/attribute-schema` offers these records as the `options` of any attribute that points at their entity, so a picker needs no second call.
+     *
+     * A body that names nothing writable is refused with 400 rather than answered as a no-op, an id nobody carries answers 404, and a value that collides on `reference_entity_id` and `code` answers 409.
+     *
+     * @param {string} id - The `reference_entity_records` 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/reference_entity_records`. An id no reference entity record of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @param {object} attributeValues - Every attribute value the record carries, in ONE jsonb document — the core of an attribute-driven PIM. A record's properties are not columns here: they are rows in `attributes`, selected per family by `family_attributes`, and their values live under their attribute CODE inside this object.
+
+Four buckets, and an attribute's own flags decide which one it writes to:
+
+  `common`                    the attribute is neither localizable nor scopable — one value, full stop.
+                              `{"common": {"net_weight": 2.4, "colour": "black"}}`
+  `locale_specific`           `localizable`: one value per language tag.
+                              `{"locale_specific": {"de_DE": {"name": "Akku-Bohrschrauber"}}}`
+  `channel_specific`          `scopable`: one value per channel.
+                              `{"channel_specific": {"b2b": {"minimum_order_quantity": 6}}}`
+  `channel_locale_specific`   both: one value per channel AND language tag.
+                              `{"channel_locale_specific": {"b2b": {"de_DE": {"description": "…"}}}}`
+
+A reader takes the most specific bucket that carries the code and falls back through locale, then channel, then `common`. `common` is always last and always consulted, because early imports wrote everything there whatever an attribute's flags said — a reader that skipped it reports an imported catalog as empty. `GET /products/attribute-schema` answers, per field, the exact path a value belongs at (`storage.path`) and that full fallback order (`from`), so no client has to re-derive any of this.
+
+The value itself is whatever the attribute's `type` implies: a string, a number, a boolean, an option CODE for a select (never its label), a list of codes for a multi-select, `{"amount": …, "unit": …}` for a measure, a list of `{"amount": …, "currency": …}` for a price, an asset code for media.
+
+Defaults to `{}`, and an empty object is a normal state — a record nobody has enriched yet. The declared type also admits an array only because every jsonb column of this app shares one mapping; an array is not meaningful here and every reader in this app treats a non-object as empty.
+
+Which attributes a record of this entity has comes from `attributes` rows with `entity_type: "reference_entity"` and `entity_ref` equal to the entity's code — `GET /products/attribute-schema?entity_type=reference_entity&entity_ref=brand` answers it in one call.
+     * @param {string} code - The record's stable identifier — the value a product stores when it points at this record, the same way a select stores an option code. Unique within the entity.
+     * @param {object} labels - What the record is called, per language tag — the text a picker shows while the code is what gets written.
+     * @param {string} referenceEntityId - Which reference entity this record belongs to.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Error>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    productsReferenceEntityRecordsUpdate(id: string, attributeValues?: object, code?: string, labels?: object, referenceEntityId?: string): Promise<Models.Error>;
+}
+
+export { ProductsReferences };