@revenexx/node 0.0.2 → 0.1.1

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

@@ -0,0 +1,2052 @@
+import { Client } from '../client.mjs';
+import { Models } from '../models.mjs';
+import { EntityType } from '../enums/entity-type.mjs';
+import { Kind } from '../enums/kind.mjs';
+import '../query.mjs';
+import '../enums/address-type-row-tone.mjs';
+import '../enums/address-type-row-create-request-tone.mjs';
+import '../enums/address-type-row-update-request-tone.mjs';
+import '../enums/approval-rule-approver-type.mjs';
+import '../enums/approval-rule-condition.mjs';
+import '../enums/approval-rule-effect.mjs';
+import '../enums/approval-rule-create-request-approver-type.mjs';
+import '../enums/approval-rule-create-request-condition.mjs';
+import '../enums/approval-rule-create-request-effect.mjs';
+import '../enums/approval-rule-update-request-approver-type.mjs';
+import '../enums/approval-rule-update-request-condition.mjs';
+import '../enums/approval-rule-update-request-effect.mjs';
+import '../enums/assets-source.mjs';
+import '../enums/attribute-value-bucket.mjs';
+import '../enums/auth-mail-source.mjs';
+import '../enums/recovery-mail-source.mjs';
+import '../enums/registration-status.mjs';
+import '../enums/budget-change-reason.mjs';
+import '../enums/budget-movement-result-status.mjs';
+import '../enums/cart-status.mjs';
+import '../enums/cart-merge-strategy.mjs';
+import '../enums/cart-price-snapshot-mode.mjs';
+import '../enums/cart-io-format.mjs';
+import '../enums/cart-export-format.mjs';
+import '../enums/cart-item-type.mjs';
+import '../enums/cart-vocabulary-tone.mjs';
+import '../enums/cart-vocabulary-name.mjs';
+import '../enums/cart-vocabulary-source.mjs';
+import '../enums/cart-vocabulary-ref-name.mjs';
+import '../enums/categories-rule-match.mjs';
+import '../enums/category-rule-operator.mjs';
+import '../enums/category-rule-match.mjs';
+import '../enums/channel-status.mjs';
+import '../enums/channel-unassigned-visibility.mjs';
+import '../enums/channel-unresolved-reason.mjs';
+import '../enums/channel-context-source.mjs';
+import '../enums/channel-inactive-behavior.mjs';
+import '../enums/channel-policy-source.mjs';
+import '../enums/channel-policy-tenant-default.mjs';
+import '../enums/channel-unassigned-policy.mjs';
+import '../enums/channel-type-tone.mjs';
+import '../enums/channel-visibility-reason.mjs';
+import '../enums/channel-vocabulary-tone.mjs';
+import '../enums/channel-vocabulary-name.mjs';
+import '../enums/channel-vocabulary-source.mjs';
+import '../enums/channel-vocabulary-ref-name.mjs';
+import '../enums/contact-registration-status.mjs';
+import '../enums/contact-status.mjs';
+import '../enums/contact-activity-kind.mjs';
+import '../enums/contact-create-request-registration-status.mjs';
+import '../enums/contact-event-kind-tone.mjs';
+import '../enums/contact-event-kind-create-request-tone.mjs';
+import '../enums/contact-event-kind-update-request-tone.mjs';
+import '../enums/contact-update-request-registration-status.mjs';
+import '../enums/cost-center-budget-type.mjs';
+import '../enums/cost-center-restriction-type.mjs';
+import '../enums/cost-center-restriction-create-request-type.mjs';
+import '../enums/cost-center-restriction-update-request-type.mjs';
+import '../enums/payment-fee-type.mjs';
+import '../enums/payment-method-kind.mjs';
+import '../enums/form-status.mjs';
+import '../enums/form-submission-status.mjs';
+import '../enums/form-notify-source.mjs';
+import '../enums/form-submission-prune-request-status.mjs';
+import '../enums/forms-vocabulary-tone.mjs';
+import '../enums/forms-vocabulary-name.mjs';
+import '../enums/forms-vocabulary-summary-name.mjs';
+import '../enums/inventory-vocabulary-default-tone.mjs';
+import '../enums/inventory-vocabulary-source.mjs';
+import '../enums/cart-io-apply-mode.mjs';
+import '../enums/cart-io-direction.mjs';
+import '../enums/cart-io-entity.mjs';
+import '../enums/io-profile-resource-apply-mode.mjs';
+import '../enums/io-profile-resource-direction.mjs';
+import '../enums/lifecycle-stage-tone.mjs';
+import '../enums/lifecycle-stage-create-request-tone.mjs';
+import '../enums/lifecycle-stage-update-request-tone.mjs';
+import '../enums/location-type.mjs';
+import '../enums/market-status.mjs';
+import '../enums/market-default-locale-source.mjs';
+import '../enums/market-locale-fallback.mjs';
+import '../enums/market-locale-granularity.mjs';
+import '../enums/market-pricing-source.mjs';
+import '../enums/market-tax-basis.mjs';
+import '../enums/market-readiness-check-id.mjs';
+import '../enums/market-readiness-severity.mjs';
+import '../enums/markets-vocabulary-tone.mjs';
+import '../enums/markets-vocabulary-name.mjs';
+import '../enums/markets-vocabulary-source.mjs';
+import '../enums/markets-vocabulary-summary-name.mjs';
+import '../enums/order-fulfillment-status.mjs';
+import '../enums/order-payment-status.mjs';
+import '../enums/order-status.mjs';
+import '../enums/order-cancellation-scope.mjs';
+import '../enums/order-comment-visibility.mjs';
+import '../enums/order-item-type.mjs';
+import '../enums/order-list-kind-tone.mjs';
+import '../enums/order-list-kind-row-tone.mjs';
+import '../enums/order-list-cart-mode.mjs';
+import '../enums/order-list-vocabulary-default-tone.mjs';
+import '../enums/order-list-vocabulary-name.mjs';
+import '../enums/order-list-vocabulary-source.mjs';
+import '../enums/order-list-vocabulary-tone.mjs';
+import '../enums/order-return-status.mjs';
+import '../enums/order-return-settlement.mjs';
+import '../enums/order-return-refusal.mjs';
+import '../enums/order-vocabulary-tone.mjs';
+import '../enums/order-vocabulary-name.mjs';
+import '../enums/order-vocabulary-source.mjs';
+import '../enums/order-vocabulary-summary-name.mjs';
+import '../enums/order-resolution-stage.mjs';
+import '../enums/organization-status.mjs';
+import '../enums/page-status.mjs';
+import '../enums/pages-vocabulary-app.mjs';
+import '../enums/pages-vocabulary-tone.mjs';
+import '../enums/pages-vocabulary-name.mjs';
+import '../enums/pages-vocabulary-source.mjs';
+import '../enums/pages-vocabulary-index-app.mjs';
+import '../enums/payment-dunning-stage.mjs';
+import '../enums/payment-failure-code.mjs';
+import '../enums/payment-status.mjs';
+import '../enums/payment-term-tone.mjs';
+import '../enums/payment-term-create-request-tone.mjs';
+import '../enums/payment-term-update-request-tone.mjs';
+import '../enums/payment-vocabulary-tone.mjs';
+import '../enums/pending-approval-approver-type.mjs';
+import '../enums/pending-approval-status.mjs';
+import '../enums/price-ending-rule.mjs';
+import '../enums/price-entries-adjust-response-rounding.mjs';
+import '../enums/price-entries-adjust-response-rounding-mode.mjs';
+import '../enums/price-entries-bulk-mode.mjs';
+import '../enums/price-rounding-mode.mjs';
+import '../enums/price-entry-type.mjs';
+import '../enums/price-list-status.mjs';
+import '../enums/price-list-tax-basis.mjs';
+import '../enums/price-currency-source.mjs';
+import '../enums/price-list-tiebreak.mjs';
+import '../enums/price-tax-inclusive-default.mjs';
+import '../enums/price-tax-unresolved-reason.mjs';
+import '../enums/price-tax-market-source.mjs';
+import '../enums/price-vocabulary-tone.mjs';
+import '../enums/price-vocabulary-name.mjs';
+import '../enums/price-vocabulary-source.mjs';
+import '../enums/price-vocabulary-ref-name.mjs';
+import '../enums/product-categories-source.mjs';
+import '../enums/product-grid-column-source.mjs';
+import '../enums/product-label-source.mjs';
+import '../enums/product-label-attribute-source.mjs';
+import '../enums/products-kind.mjs';
+import '../enums/purchase-request-status.mjs';
+import '../enums/purchase-request-event-name.mjs';
+import '../enums/purchase-request-item-type.mjs';
+import '../enums/purchase-request-item-create-request-type.mjs';
+import '../enums/purchase-request-item-update-request-type.mjs';
+import '../enums/reorder-point-source.mjs';
+import '../enums/reservation-status.mjs';
+import '../enums/price-on-request-reason.mjs';
+import '../enums/price-tax-basis.mjs';
+import '../enums/price-tax-basis-source.mjs';
+import '../enums/role-catalog-response-source.mjs';
+import '../enums/segment-rule-match.mjs';
+import '../enums/segment-member-source.mjs';
+import '../enums/segment-rule-operator.mjs';
+import '../enums/segment-rule-preview-request-rule-match.mjs';
+import '../enums/segment-rule-preview-request-target.mjs';
+import '../enums/segment-rule-preview-response-rule-match.mjs';
+import '../enums/segment-rule-preview-response-target.mjs';
+import '../enums/segment-rules-target.mjs';
+import '../enums/shipping-carrier-status.mjs';
+import '../enums/shipping-method-matrix-basis.mjs';
+import '../enums/shipping-method-pricing-type.mjs';
+import '../enums/shipping-carrier-source.mjs';
+import '../enums/shipping-rate-pricing-type.mjs';
+import '../enums/shipping-tax-source.mjs';
+import '../enums/shipping-free-above-basis.mjs';
+import '../enums/shipping-rates-basis-matrix-basis-default.mjs';
+import '../enums/shipping-service-level-create-request-tone.mjs';
+import '../enums/shipping-service-level-row-tone.mjs';
+import '../enums/shipping-service-level-update-request-tone.mjs';
+import '../enums/shipping-tax-unresolved-reason.mjs';
+import '../enums/shipping-tax-market-source.mjs';
+import '../enums/shipping-tax-context-via.mjs';
+import '../enums/shipping-tracking-carrier-status.mjs';
+import '../enums/shipping-vocabulary-default-tone.mjs';
+import '../enums/shipping-vocabulary-source.mjs';
+import '../enums/shipping-vocabulary-tone.mjs';
+import '../enums/shipping-weight-unit-create-request-tone.mjs';
+import '../enums/shipping-weight-unit-row-tone.mjs';
+import '../enums/shipping-weight-unit-update-request-tone.mjs';
+import '../enums/stock-movement-type.mjs';
+import '../enums/store-asset-request-visibility.mjs';
+import '../enums/submit-item-type.mjs';
+import '../enums/submit-result-outcome.mjs';
+import '../enums/validation-failed-response-status.mjs';
+import '../enums/vocabulary-default-tone.mjs';
+import '../enums/vocabulary-source.mjs';
+import '../enums/vocabulary-tone.mjs';
+import '../enums/attribute-boolean-status.mjs';
+import '../enums/attribute-datetime-status.mjs';
+import '../enums/attribute-email-status.mjs';
+import '../enums/attribute-enum-status.mjs';
+import '../enums/attribute-float-status.mjs';
+import '../enums/attribute-integer-status.mjs';
+import '../enums/attribute-ip-status.mjs';
+import '../enums/attribute-line-status.mjs';
+import '../enums/attribute-longtext-status.mjs';
+import '../enums/attribute-mediumtext-status.mjs';
+import '../enums/attribute-point-status.mjs';
+import '../enums/attribute-polygon-status.mjs';
+import '../enums/attribute-relationship-status.mjs';
+import '../enums/attribute-string-status.mjs';
+import '../enums/attribute-text-status.mjs';
+import '../enums/attribute-url-status.mjs';
+import '../enums/attribute-varchar-status.mjs';
+import '../enums/column-boolean-status.mjs';
+import '../enums/column-datetime-status.mjs';
+import '../enums/column-email-status.mjs';
+import '../enums/column-enum-status.mjs';
+import '../enums/column-float-status.mjs';
+import '../enums/column-integer-status.mjs';
+import '../enums/column-ip-status.mjs';
+import '../enums/column-line-status.mjs';
+import '../enums/column-longtext-status.mjs';
+import '../enums/column-mediumtext-status.mjs';
+import '../enums/column-point-status.mjs';
+import '../enums/column-polygon-status.mjs';
+import '../enums/column-relationship-status.mjs';
+import '../enums/column-string-status.mjs';
+import '../enums/column-text-status.mjs';
+import '../enums/column-url-status.mjs';
+import '../enums/column-varchar-status.mjs';
+import '../enums/database-type.mjs';
+import '../enums/deployment-status.mjs';
+import '../enums/execution-status.mjs';
+import '../enums/execution-trigger.mjs';
+import '../enums/health-antivirus-status.mjs';
+import '../enums/health-status-status.mjs';
+import '../enums/index-status.mjs';
+import '../enums/message-2-status.mjs';
+
+declare class ProductsDataModel {
+    client: Client;
+    constructor(client: Client);
+    /**
+     * A class of media with one shared shape — packshots, datasheets, line drawings. The family decides which attributes an asset of it carries (alt text, copyright, an expiry date) and, through `naming_convention`, how a file of it is named — which is what lets an import bind a file to a product with no mapping table.
+     *
+     * Every column of `asset_families` 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 asset family's stable identifier — a class of media with one shared shape. Unique per tenant.
+     * @param {string} params.labels - Exact match on `labels`. What the asset family 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.namingConvention - Exact match on `naming_convention`. How a file of this family is named, so an import can bind a file to a product without a mapping table. `source` is the product value the file name is built from, `pattern` how it is assembled, `allowed_extensions` what may be uploaded. 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<{}>}
+     */
+    productsAssetFamiliesList(params?: {
+        limit?: number;
+        offset?: number;
+        order?: string;
+        id?: string;
+        code?: string;
+        labels?: string;
+        namingConvention?: string;
+        createdAt?: string;
+        updatedAt?: string;
+    }): Promise<{}>;
+    /**
+     * A class of media with one shared shape — packshots, datasheets, line drawings. The family decides which attributes an asset of it carries (alt text, copyright, an expiry date) and, through `naming_convention`, how a file of it is named — which is what lets an import bind a file to a product with no mapping table.
+     *
+     * Every column of `asset_families` 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 asset family's stable identifier — a class of media with one shared shape. Unique per tenant.
+     * @param {string} labels - Exact match on `labels`. What the asset family 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} namingConvention - Exact match on `naming_convention`. How a file of this family is named, so an import can bind a file to a product without a mapping table. `source` is the product value the file name is built from, `pattern` how it is assembled, `allowed_extensions` what may be uploaded. 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.
+     */
+    productsAssetFamiliesList(limit?: number, offset?: number, order?: string, id?: string, code?: string, labels?: string, namingConvention?: string, createdAt?: string, updatedAt?: string): Promise<{}>;
+    /**
+     * Creates one asset 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.
+     *
+     * A class of media with one shared shape — packshots, datasheets, line drawings. The family decides which attributes an asset of it carries (alt text, copyright, an expiry date) and, through `naming_convention`, how a file of it is named — which is what lets an import bind a file to a product with no mapping table.
+     *
+     * `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 asset family's stable identifier — a class of media with one shared shape. Unique per tenant.
+     * @param {object} params.labels - What the asset family is called, per language tag.
+     * @param {object} params.namingConvention - How a file of this family is named, so an import can bind a file to a product without a mapping table. `source` is the product value the file name is built from, `pattern` how it is assembled, `allowed_extensions` what may be uploaded.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.AssetFamilies>}
+     */
+    productsAssetFamiliesCreate(params: {
+        code: string;
+        labels?: object;
+        namingConvention?: object;
+    }): Promise<Models.AssetFamilies>;
+    /**
+     * Creates one asset 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.
+     *
+     * A class of media with one shared shape — packshots, datasheets, line drawings. The family decides which attributes an asset of it carries (alt text, copyright, an expiry date) and, through `naming_convention`, how a file of it is named — which is what lets an import bind a file to a product with no mapping table.
+     *
+     * `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 asset family's stable identifier — a class of media with one shared shape. Unique per tenant.
+     * @param {object} labels - What the asset family is called, per language tag.
+     * @param {object} namingConvention - How a file of this family is named, so an import can bind a file to a product without a mapping table. `source` is the product value the file name is built from, `pattern` how it is assembled, `allowed_extensions` what may be uploaded.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.AssetFamilies>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    productsAssetFamiliesCreate(code: string, labels?: object, namingConvention?: object): Promise<Models.AssetFamilies>;
+    /**
+     * Deletes one asset 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.
+     *
+     * It takes what hangs off it: assets (`asset_family_id`) are deleted with it.
+     *
+     * An id no asset family 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 `asset_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/asset_families`. An id no asset familie of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<{}>}
+     */
+    productsAssetFamiliesDelete(params: {
+        id: string;
+    }): Promise<{}>;
+    /**
+     * Deletes one asset 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.
+     *
+     * It takes what hangs off it: assets (`asset_family_id`) are deleted with it.
+     *
+     * An id no asset family 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 `asset_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/asset_families`. An id no asset familie of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<{}>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    productsAssetFamiliesDelete(id: string): Promise<{}>;
+    /**
+     * Reads one asset family by its id — the whole row, every column, as it is stored.
+     *
+     * A class of media with one shared shape — packshots, datasheets, line drawings. The family decides which attributes an asset of it carries (alt text, copyright, an expiry date) and, through `naming_convention`, how a file of it is named — which is what lets an import bind a file to a product with no mapping table.
+     *
+     * An id no asset family 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 `asset_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/asset_families`. An id no asset familie of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.AssetFamilies>}
+     */
+    productsAssetFamiliesGet(params: {
+        id: string;
+    }): Promise<Models.AssetFamilies>;
+    /**
+     * Reads one asset family by its id — the whole row, every column, as it is stored.
+     *
+     * A class of media with one shared shape — packshots, datasheets, line drawings. The family decides which attributes an asset of it carries (alt text, copyright, an expiry date) and, through `naming_convention`, how a file of it is named — which is what lets an import bind a file to a product with no mapping table.
+     *
+     * An id no asset family 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 `asset_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/asset_families`. An id no asset familie of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.AssetFamilies>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    productsAssetFamiliesGet(id: string): Promise<Models.AssetFamilies>;
+    /**
+     * Updates one asset 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.
+     *
+     * A class of media with one shared shape — packshots, datasheets, line drawings. The family decides which attributes an asset of it carries (alt text, copyright, an expiry date) and, through `naming_convention`, how a file of it is named — which is what lets an import bind a file to a product with no mapping table.
+     *
+     * 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 `asset_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/asset_families`. An id no asset familie of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @param {string} params.code - The asset family's stable identifier — a class of media with one shared shape. Unique per tenant.
+     * @param {object} params.labels - What the asset family is called, per language tag.
+     * @param {object} params.namingConvention - How a file of this family is named, so an import can bind a file to a product without a mapping table. `source` is the product value the file name is built from, `pattern` how it is assembled, `allowed_extensions` what may be uploaded.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.AssetFamilies>}
+     */
+    productsAssetFamiliesUpdate(params: {
+        id: string;
+        code?: string;
+        labels?: object;
+        namingConvention?: object;
+    }): Promise<Models.AssetFamilies>;
+    /**
+     * Updates one asset 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.
+     *
+     * A class of media with one shared shape — packshots, datasheets, line drawings. The family decides which attributes an asset of it carries (alt text, copyright, an expiry date) and, through `naming_convention`, how a file of it is named — which is what lets an import bind a file to a product with no mapping table.
+     *
+     * 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 `asset_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/asset_families`. An id no asset familie of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @param {string} code - The asset family's stable identifier — a class of media with one shared shape. Unique per tenant.
+     * @param {object} labels - What the asset family is called, per language tag.
+     * @param {object} namingConvention - How a file of this family is named, so an import can bind a file to a product without a mapping table. `source` is the product value the file name is built from, `pattern` how it is assembled, `allowed_extensions` what may be uploaded.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.AssetFamilies>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    productsAssetFamiliesUpdate(id: string, code?: string, labels?: object, namingConvention?: object): Promise<Models.AssetFamilies>;
+    /**
+     * 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.
+     *
+     * Every column of `association_types` 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 kind of relation between two products. Unique per tenant.
+     * @param {boolean} params.isTwoWay - Exact match on `is_two_way`. Declares the relation symmetric — an accessory of A is an accessory of B. It is a declaration a client reads: this app stores one row per direction and does not create the mirror for you.
+     * @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.
+     * @throws {RevenexxException}
+     * @returns {Promise<{}>}
+     */
+    productsAssociationTypesList(params?: {
+        limit?: number;
+        offset?: number;
+        order?: string;
+        id?: string;
+        code?: string;
+        isTwoWay?: boolean;
+        isQuantified?: boolean;
+        labels?: string;
+        createdAt?: 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.
+     *
+     * Every column of `association_types` 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 kind of relation between two products. Unique per tenant.
+     * @param {boolean} isTwoWay - Exact match on `is_two_way`. Declares the relation symmetric — an accessory of A is an accessory of B. It is a declaration a client reads: this app stores one row per direction and does not create the mirror for you.
+     * @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.
+     * @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<{}>;
+    /**
+     * 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.
+     *
+     * 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.
+     *
+     * `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 kind of relation between two products. Unique per tenant.
+     * @param {boolean} params.isQuantified - 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 {boolean} params.isTwoWay - Declares the relation symmetric — an accessory of A is an accessory of B. It is a declaration a client reads: this app stores one row per direction and does not create the mirror for you.
+     * @param {object} params.labels - What the relation is called in a product form, per language tag.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.AssociationTypes>}
+     */
+    productsAssociationTypesCreate(params: {
+        code: string;
+        isQuantified?: boolean;
+        isTwoWay?: boolean;
+        labels?: object;
+    }): Promise<Models.AssociationTypes>;
+    /**
+     * 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.
+     *
+     * 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.
+     *
+     * `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 kind of relation between two products. Unique per tenant.
+     * @param {boolean} isQuantified - 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 {boolean} isTwoWay - Declares the relation symmetric — an accessory of A is an accessory of B. It is a declaration a client reads: this app stores one row per direction and does not create the mirror for you.
+     * @param {object} labels - What the relation is called in a product form, per language tag.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.AssociationTypes>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    productsAssociationTypesCreate(code: string, isQuantified?: boolean, isTwoWay?: boolean, labels?: object): Promise<Models.AssociationTypes>;
+    /**
+     * Deletes one association type by id. It is a hard delete — the row is gone, and the answer is a confirmation rather than a result to branch on.
+     *
+     * It takes what hangs off it: product associations (`association_type_id`) are deleted with it.
+     *
+     * An id no association type 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 `association_types` 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/association_types`. An id no association type of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<{}>}
+     */
+    productsAssociationTypesDelete(params: {
+        id: string;
+    }): Promise<{}>;
+    /**
+     * Deletes one association type by id. It is a hard delete — the row is gone, and the answer is a confirmation rather than a result to branch on.
+     *
+     * It takes what hangs off it: product associations (`association_type_id`) are deleted with it.
+     *
+     * An id no association type 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 `association_types` 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/association_types`. An id no association type of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<{}>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    productsAssociationTypesDelete(id: string): Promise<{}>;
+    /**
+     * Reads one association type by its id — the whole row, every column, as it is stored.
+     *
+     * 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.
+     *
+     * An id no association type 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 `association_types` 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/association_types`. An id no association type of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.AssociationTypes>}
+     */
+    productsAssociationTypesGet(params: {
+        id: string;
+    }): Promise<Models.AssociationTypes>;
+    /**
+     * Reads one association type by its id — the whole row, every column, as it is stored.
+     *
+     * 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.
+     *
+     * An id no association type 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 `association_types` 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/association_types`. An id no association type of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.AssociationTypes>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    productsAssociationTypesGet(id: string): Promise<Models.AssociationTypes>;
+    /**
+     * Updates one association type 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.
+     *
+     * 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.
+     *
+     * 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 `association_types` 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/association_types`. An id no association type of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @param {string} params.code - The kind of relation between two products. Unique per tenant.
+     * @param {boolean} params.isQuantified - 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 {boolean} params.isTwoWay - Declares the relation symmetric — an accessory of A is an accessory of B. It is a declaration a client reads: this app stores one row per direction and does not create the mirror for you.
+     * @param {object} params.labels - What the relation is called in a product form, per language tag.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.AssociationTypes>}
+     */
+    productsAssociationTypesUpdate(params: {
+        id: string;
+        code?: string;
+        isQuantified?: boolean;
+        isTwoWay?: boolean;
+        labels?: object;
+    }): Promise<Models.AssociationTypes>;
+    /**
+     * Updates one association type 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.
+     *
+     * 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.
+     *
+     * 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 `association_types` 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/association_types`. An id no association type of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @param {string} code - The kind of relation between two products. Unique per tenant.
+     * @param {boolean} isQuantified - 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 {boolean} isTwoWay - Declares the relation symmetric — an accessory of A is an accessory of B. It is a declaration a client reads: this app stores one row per direction and does not create the mirror for you.
+     * @param {object} labels - What the relation is called in a product form, per language tag.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.AssociationTypes>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    productsAssociationTypesUpdate(id: string, code?: string, isQuantified?: boolean, isTwoWay?: boolean, labels?: object): Promise<Models.AssociationTypes>;
+    /**
+     * 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.
+     *
+     * @param {string} params.familyId - The family whose fields to describe. A family that does not exist answers 404 — it is not silently ignored.
+     * @param {string} params.familyCode - Alternative to family_id — a `families.code` THIS TENANT holds, from `GET /products/families`. Wins nothing over family_id: when both are sent, family_id is resolved and family_code ignored. A code no family carries answers 404, so this parameter carries no example — every value is somebody's 404.
+     * @param {EntityType} params.entityType - Attribute entity when no family is named. Default 'product'. The four this app's own model is built on; the column carries no CHECK, so a tenant that has invented a fifth is answered on it too.
+     * @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.
+     * @throws {RevenexxException}
+     * @returns {Promise<{}>}
+     */
+    productsAttributeSchema(params?: {
+        familyId?: string;
+        familyCode?: string;
+        entityType?: EntityType;
+        entityRef?: string;
+        locale?: string;
+        channel?: string;
+        kind?: Kind;
+    }): 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.
+     *
+     * @param {string} familyId - The family whose fields to describe. A family that does not exist answers 404 — it is not silently ignored.
+     * @param {string} familyCode - Alternative to family_id — a `families.code` THIS TENANT holds, from `GET /products/families`. Wins nothing over family_id: when both are sent, family_id is resolved and family_code ignored. A code no family carries answers 404, so this parameter carries no example — every value is somebody's 404.
+     * @param {EntityType} entityType - Attribute entity when no family is named. Default 'product'. The four this app's own model is built on; the column carries no CHECK, so a tenant that has invented a fifth is answered on it too.
+     * @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.
+     * @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<{}>;
+    /**
+     * 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.
+     *
+     * Every column of `attribute_groups` 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 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.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<{}>}
+     */
+    productsAttributeGroupsList(params?: {
+        limit?: number;
+        offset?: number;
+        order?: string;
+        id?: string;
+        code?: string;
+        position?: number;
+        labels?: string;
+        createdAt?: string;
+        updatedAt?: string;
+    }): 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.
+     *
+     * Every column of `attribute_groups` 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 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} 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<{}>;
+    /**
+     * 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.
+     *
+     * 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.
+     *
+     * `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 {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 {number} params.position - Where this section sits in a form, ascending. Sections that tie keep the order the database returns them in.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.AttributeGroups>}
+     */
+    productsAttributeGroupsCreate(params: {
+        code: string;
+        labels?: object;
+        position?: number;
+    }): 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.
+     *
+     * 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.
+     *
+     * `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 {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 {number} position - Where this section sits in a form, ascending. Sections that tie keep the order the database returns them in.
+     * @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>;
+    /**
+     * 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.
+     *
+     * `attributes.group_id` is set to null instead, so the rows that pointed at it survive the delete rather than going with it.
+     *
+     * An id no attribute group 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 `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.
+     * @throws {RevenexxException}
+     * @returns {Promise<{}>}
+     */
+    productsAttributeGroupsDelete(params: {
+        id: string;
+    }): Promise<{}>;
+    /**
+     * 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.
+     *
+     * `attributes.group_id` is set to null instead, so the rows that pointed at it survive the delete rather than going with it.
+     *
+     * An id no attribute group 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 `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.
+     * @throws {RevenexxException}
+     * @returns {Promise<{}>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    productsAttributeGroupsDelete(id: string): Promise<{}>;
+    /**
+     * Reads one attribute group by its id — the whole row, every column, as it is stored.
+     *
+     * 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.
+     *
+     * An id no attribute group 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 `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.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.AttributeGroups>}
+     */
+    productsAttributeGroupsGet(params: {
+        id: string;
+    }): Promise<Models.AttributeGroups>;
+    /**
+     * Reads one attribute group by its id — the whole row, every column, as it is stored.
+     *
+     * 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.
+     *
+     * An id no attribute group 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 `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.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.AttributeGroups>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    productsAttributeGroupsGet(id: 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.
+     *
+     * 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.
+     *
+     * 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 `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 {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 {number} params.position - Where this section sits in a form, ascending. Sections that tie keep the order the database returns them in.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.AttributeGroups>}
+     */
+    productsAttributeGroupsUpdate(params: {
+        id: string;
+        code?: string;
+        labels?: object;
+        position?: number;
+    }): 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.
+     *
+     * 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.
+     *
+     * 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 `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 {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 {number} position - Where this section sits in a form, ascending. Sections that tie keep the order the database returns them in.
+     * @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>;
+    /**
+     * 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.
+     *
+     * Every column of `attribute_options` 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.attributeId - Exact match on `attribute_id`. The select / multi-select attribute these are the permitted values of. Deleting the attribute deletes its options with it.
+     * @param {string} params.code - Exact match on `code`. The value actually STORED in a record's `attribute_values` when this option is picked — never the label. Unique within the attribute.
+     * @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.createdAt - Exact match on `created_at`. When the row was created. Server-set — it is not part of any request body.
+     * @throws {RevenexxException}
+     * @returns {Promise<{}>}
+     */
+    productsAttributeOptionsList(params?: {
+        limit?: number;
+        offset?: number;
+        order?: string;
+        id?: string;
+        attributeId?: string;
+        code?: string;
+        position?: number;
+        swatch?: string;
+        labels?: string;
+        createdAt?: 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.
+     *
+     * Every column of `attribute_options` 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} attributeId - Exact match on `attribute_id`. The select / multi-select attribute these are the permitted values of. Deleting the attribute deletes its options with it.
+     * @param {string} code - Exact match on `code`. The value actually STORED in a record's `attribute_values` when this option is picked — never the label. Unique within the attribute.
+     * @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} createdAt - Exact match on `created_at`. When the row was created. Server-set — it is not part of any request body.
+     * @throws {RevenexxException}
+     * @returns {Promise<{}>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    productsAttributeOptionsList(limit?: number, offset?: number, order?: string, id?: string, attributeId?: string, code?: string, position?: number, swatch?: string, labels?: string, createdAt?: 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.
+     *
+     * 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.
+     *
+     * `attribute_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 `attribute_id` and `code` answers 409.
+     *
+     * @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 {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 {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.swatch - A colour or texture chip for the picker. Null for an option that is not visual.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.AttributeOptions>}
+     */
+    productsAttributeOptionsCreate(params: {
+        attributeId: string;
+        code: string;
+        labels?: object;
+        position?: number;
+        swatch?: object;
+    }): Promise<Models.AttributeOptions>;
+    /**
+     * 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.
+     *
+     * 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.
+     *
+     * `attribute_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 `attribute_id` and `code` answers 409.
+     *
+     * @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 {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 {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} 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>;
+    /**
+     * 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.
+     *
+     * Nothing in this schema references it, so nothing else changes.
+     *
+     * An id no attribute option 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 `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.
+     * @throws {RevenexxException}
+     * @returns {Promise<{}>}
+     */
+    productsAttributeOptionsDelete(params: {
+        id: string;
+    }): Promise<{}>;
+    /**
+     * 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.
+     *
+     * Nothing in this schema references it, so nothing else changes.
+     *
+     * An id no attribute option 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 `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.
+     * @throws {RevenexxException}
+     * @returns {Promise<{}>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    productsAttributeOptionsDelete(id: string): Promise<{}>;
+    /**
+     * Reads one attribute option by its id — the whole row, every column, as it is stored.
+     *
+     * 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.
+     *
+     * An id no attribute option 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 `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.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.AttributeOptions>}
+     */
+    productsAttributeOptionsGet(params: {
+        id: string;
+    }): Promise<Models.AttributeOptions>;
+    /**
+     * Reads one attribute option by its id — the whole row, every column, as it is stored.
+     *
+     * 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.
+     *
+     * An id no attribute option 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 `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.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.AttributeOptions>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    productsAttributeOptionsGet(id: string): Promise<Models.AttributeOptions>;
+    /**
+     * Updates one attribute option 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.
+     *
+     * 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.
+     *
+     * 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 `attribute_id` and `code` answers 409.
+     *
+     * @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 {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 {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.swatch - A colour or texture chip for the picker. Null for an option that is not visual.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.AttributeOptions>}
+     */
+    productsAttributeOptionsUpdate(params: {
+        id: string;
+        attributeId?: string;
+        code?: string;
+        labels?: object;
+        position?: number;
+        swatch?: object;
+    }): Promise<Models.AttributeOptions>;
+    /**
+     * Updates one attribute option 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.
+     *
+     * 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.
+     *
+     * 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 `attribute_id` and `code` answers 409.
+     *
+     * @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 {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 {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} 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>;
+    /**
+     * 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.
+     *
+     * Every column of `attributes` 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 attribute's stable identifier — the KEY its value is stored under inside `attribute_values`, and the name a category rule addresses as `attribute:<code>`. Unique per (`entity_type`, `entity_ref`) in this tenant.
+     * @param {string} params.entityType - Exact match on `entity_type`. 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.entityRef - Exact match on `entity_ref`. 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.type - Exact match on `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 {string} params.groupId - Exact match on `group_id`. 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.localizable - Exact match on `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 {boolean} params.scopable - Exact match on `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 {boolean} params.isUnique - Exact match on `is_unique`. 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 {boolean} params.isFilterable - Exact match on `is_filterable`. 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.usableInGrid - Exact match on `usable_in_grid`. 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 {string} params.validation - Exact match on `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. 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.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.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<{}>}
+     */
+    productsAttributesList(params?: {
+        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<{}>;
+    /**
+     * 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.
+     *
+     * Every column of `attributes` 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 attribute's stable identifier — the KEY its value is stored under inside `attribute_values`, and the name a category rule addresses as `attribute:<code>`. Unique per (`entity_type`, `entity_ref`) in this tenant.
+     * @param {string} entityType - Exact match on `entity_type`. 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} entityRef - Exact match on `entity_ref`. 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} type - Exact match on `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 {string} groupId - Exact match on `group_id`. 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} localizable - Exact match on `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 {boolean} scopable - Exact match on `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 {boolean} isUnique - Exact match on `is_unique`. 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 {boolean} isFilterable - Exact match on `is_filterable`. 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} usableInGrid - Exact match on `usable_in_grid`. 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 {string} validation - Exact match on `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. 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} 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} 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<{}>;
+    /**
+     * 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.
+     *
+     * 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.
+     *
+     * `code` and `type` are the only columns the database refuses the row without; everything else has a default or is nullable. A second row with the same `entity_type`, `entity_ref`, `code` answers 409.
+     *
+     * @param {string} params.code - The attribute's stable identifier — the KEY its value is stored under inside `attribute_values`, and the name a category rule addresses as `attribute:<code>`. Unique per (`entity_type`, `entity_ref`) in this tenant.
+     * @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 {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.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 {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 {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}
+     * @returns {Promise<Models.Attributes>}
+     */
+    productsAttributesCreate(params: {
+        code: string;
+        type: string;
+        config?: object;
+        entityRef?: string;
+        entityType?: string;
+        groupId?: string;
+        isFilterable?: boolean;
+        isUnique?: boolean;
+        labels?: object;
+        localizable?: boolean;
+        position?: number;
+        scopable?: boolean;
+        usableInGrid?: boolean;
+        validation?: object;
+    }): Promise<Models.Attributes>;
+    /**
+     * 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.
+     *
+     * 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.
+     *
+     * `code` and `type` are the only columns the database refuses the row without; everything else has a default or is nullable. A second row with the same `entity_type`, `entity_ref`, `code` answers 409.
+     *
+     * @param {string} code - The attribute's stable identifier — the KEY its value is stored under inside `attribute_values`, and the name a category rule addresses as `attribute:<code>`. Unique per (`entity_type`, `entity_ref`) in this tenant.
+     * @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 {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} 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 {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 {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>;
+    /**
+     * 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.
+     *
+     * It takes what hangs off it: attribute options (`attribute_id`), family attributes (`attribute_id`) are deleted with it.
+     *
+     * An id no attribute 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 `attributes` 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/attributes`. An id no attribute of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<{}>}
+     */
+    productsAttributesDelete(params: {
+        id: string;
+    }): Promise<{}>;
+    /**
+     * 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.
+     *
+     * It takes what hangs off it: attribute options (`attribute_id`), family attributes (`attribute_id`) are deleted with it.
+     *
+     * An id no attribute 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 `attributes` 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/attributes`. An id no attribute of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<{}>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    productsAttributesDelete(id: string): Promise<{}>;
+    /**
+     * Reads one attribute by its id — the whole row, every column, as it is stored.
+     *
+     * 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.
+     *
+     * An id no attribute 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 `attributes` 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/attributes`. An id no attribute of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Attributes>}
+     */
+    productsAttributesGet(params: {
+        id: string;
+    }): Promise<Models.Attributes>;
+    /**
+     * Reads one attribute by its id — the whole row, every column, as it is stored.
+     *
+     * 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.
+     *
+     * An id no attribute 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 `attributes` 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/attributes`. An id no attribute of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Attributes>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    productsAttributesGet(id: string): Promise<Models.Attributes>;
+    /**
+     * Updates one attribute 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.
+     *
+     * 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.
+     *
+     * 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 `entity_type`, `entity_ref`, `code` answers 409.
+     *
+     * @param {string} params.id - The `attributes` 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/attributes`. An id no attribute of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @param {string} params.code - The attribute's stable identifier — the KEY its value is stored under inside `attribute_values`, and the name a category rule addresses as `attribute:<code>`. Unique per (`entity_type`, `entity_ref`) in this tenant.
+     * @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.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 {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 {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.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Attributes>}
+     */
+    productsAttributesUpdate(params: {
+        id: string;
+        code?: string;
+        config?: object;
+        entityRef?: string;
+        entityType?: string;
+        groupId?: string;
+        isFilterable?: boolean;
+        isUnique?: boolean;
+        labels?: object;
+        localizable?: boolean;
+        position?: number;
+        scopable?: boolean;
+        type?: string;
+        usableInGrid?: boolean;
+        validation?: object;
+    }): Promise<Models.Attributes>;
+    /**
+     * Updates one attribute 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.
+     *
+     * 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.
+     *
+     * 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 `entity_type`, `entity_ref`, `code` answers 409.
+     *
+     * @param {string} id - The `attributes` 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/attributes`. An id no attribute of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @param {string} code - The attribute's stable identifier — the KEY its value is stored under inside `attribute_values`, and the name a category rule addresses as `attribute:<code>`. Unique per (`entity_type`, `entity_ref`) in this tenant.
+     * @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} 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 {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 {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.
+     * @throws {RevenexxException}
+     * @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>;
+    /**
+     * 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.
+     *
+     * Every column of `families` 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 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.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.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<{}>}
+     */
+    productsFamiliesList(params?: {
+        limit?: number;
+        offset?: number;
+        order?: string;
+        id?: string;
+        code?: string;
+        labelAttribute?: string;
+        imageAttribute?: string;
+        labels?: string;
+        createdAt?: string;
+        updatedAt?: string;
+    }): Promise<{}>;
+    /**
+     * 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.
+     *
+     * Every column of `families` 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 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} 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} 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<{}>;
+    /**
+     * 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.
+     *
+     * 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.
+     *
+     * `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.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.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Families>}
+     */
+    productsFamiliesCreate(params: {
+        code: string;
+        imageAttribute?: string;
+        labelAttribute?: string;
+        labels?: object;
+    }): 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.
+     *
+     * 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.
+     *
+     * `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} 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.
+     * @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>;
+    /**
+     * 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.
+     *
+     * It takes what hangs off it: family attributes (`family_id`), family variants (`family_id`) are deleted with it. `products.family_id` is set to null instead, so the rows that pointed at it survive the delete rather than going with it.
+     *
+     * An id no family 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 `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.
+     * @throws {RevenexxException}
+     * @returns {Promise<{}>}
+     */
+    productsFamiliesDelete(params: {
+        id: string;
+    }): Promise<{}>;
+    /**
+     * 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.
+     *
+     * It takes what hangs off it: family attributes (`family_id`), family variants (`family_id`) are deleted with it. `products.family_id` is set to null instead, so the rows that pointed at it survive the delete rather than going with it.
+     *
+     * An id no family 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 `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.
+     * @throws {RevenexxException}
+     * @returns {Promise<{}>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    productsFamiliesDelete(id: string): Promise<{}>;
+    /**
+     * Reads one family by its id — the whole row, every column, as it is stored.
+     *
+     * 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.
+     *
+     * An id no family 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 `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.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Families>}
+     */
+    productsFamiliesGet(params: {
+        id: string;
+    }): Promise<Models.Families>;
+    /**
+     * Reads one family by its id — the whole row, every column, as it is stored.
+     *
+     * 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.
+     *
+     * An id no family 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 `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.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Families>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    productsFamiliesGet(id: 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.
+     *
+     * 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.
+     *
+     * 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 `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.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.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.Families>}
+     */
+    productsFamiliesUpdate(params: {
+        id: string;
+        code?: string;
+        imageAttribute?: string;
+        labelAttribute?: string;
+        labels?: object;
+    }): 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.
+     *
+     * 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.
+     *
+     * 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 `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} 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.
+     * @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>;
+    /**
+     * 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.
+     *
+     * Every column of `family_attributes` 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.familyId - Exact match on `family_id`. The family this link belongs to — one side of the pair that makes an attribute part of a family's form.
+     * @param {string} params.attributeId - Exact match on `attribute_id`. The attribute the family carries. One row per (family, attribute); deleting either side deletes the link.
+     * @param {number} params.position - Exact match on `position`. The family's own ordering of this attribute, which overrides the attribute's default `position` in this family's form.
+     * @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.
+     * @throws {RevenexxException}
+     * @returns {Promise<{}>}
+     */
+    productsFamilyAttributesList(params?: {
+        limit?: number;
+        offset?: number;
+        order?: string;
+        id?: string;
+        familyId?: string;
+        attributeId?: string;
+        position?: number;
+        isRequired?: boolean;
+        requiredChannels?: string;
+        createdAt?: 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.
+     *
+     * Every column of `family_attributes` 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} familyId - Exact match on `family_id`. The family this link belongs to — one side of the pair that makes an attribute part of a family's form.
+     * @param {string} attributeId - Exact match on `attribute_id`. The attribute the family carries. One row per (family, attribute); deleting either side deletes the link.
+     * @param {number} position - Exact match on `position`. The family's own ordering of this attribute, which overrides the attribute's default `position` in this family's form.
+     * @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.
+     * @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<{}>;
+    /**
+     * 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.
+     *
+     * 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.
+     *
+     * `family_id` and `attribute_id` are the only columns the database refuses the row without; everything else has a default or is nullable. A second row with the same `family_id` and `attribute_id` answers 409.
+     *
+     * @param {string} params.attributeId - The attribute the family carries. One row per (family, attribute); deleting either side deletes the link.
+     * @param {string} params.familyId - The family this link belongs to — one side of the pair that makes an attribute part of a family's form.
+     * @param {boolean} params.isRequired - 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 {number} params.position - The family's own ordering of this attribute, which overrides the attribute's default `position` in this family's form.
+     * @param {object} params.requiredChannels - 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.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.FamilyAttributes>}
+     */
+    productsFamilyAttributesCreate(params: {
+        attributeId: string;
+        familyId: string;
+        isRequired?: boolean;
+        position?: number;
+        requiredChannels?: object;
+    }): Promise<Models.FamilyAttributes>;
+    /**
+     * 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.
+     *
+     * 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.
+     *
+     * `family_id` and `attribute_id` are the only columns the database refuses the row without; everything else has a default or is nullable. A second row with the same `family_id` and `attribute_id` answers 409.
+     *
+     * @param {string} attributeId - The attribute the family carries. One row per (family, attribute); deleting either side deletes the link.
+     * @param {string} familyId - The family this link belongs to — one side of the pair that makes an attribute part of a family's form.
+     * @param {boolean} isRequired - 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 {number} position - The family's own ordering of this attribute, which overrides the attribute's default `position` in this family's form.
+     * @param {object} requiredChannels - 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.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.FamilyAttributes>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    productsFamilyAttributesCreate(attributeId: string, familyId: string, isRequired?: boolean, position?: number, requiredChannels?: object): Promise<Models.FamilyAttributes>;
+    /**
+     * Deletes one family 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.
+     *
+     * Nothing in this schema references it, so nothing else changes.
+     *
+     * An id no family attribute 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 `family_attributes` 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_attributes`. An id no family attribute of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<{}>}
+     */
+    productsFamilyAttributesDelete(params: {
+        id: string;
+    }): Promise<{}>;
+    /**
+     * Deletes one family 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.
+     *
+     * Nothing in this schema references it, so nothing else changes.
+     *
+     * An id no family attribute 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 `family_attributes` 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_attributes`. An id no family attribute of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<{}>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    productsFamilyAttributesDelete(id: string): Promise<{}>;
+    /**
+     * Reads one family attribute by its id — the whole row, every column, as it is stored.
+     *
+     * 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.
+     *
+     * An id no family attribute 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 `family_attributes` 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_attributes`. An id no family attribute of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.FamilyAttributes>}
+     */
+    productsFamilyAttributesGet(params: {
+        id: string;
+    }): Promise<Models.FamilyAttributes>;
+    /**
+     * Reads one family attribute by its id — the whole row, every column, as it is stored.
+     *
+     * 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.
+     *
+     * An id no family attribute 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 `family_attributes` 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_attributes`. An id no family attribute of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.FamilyAttributes>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    productsFamilyAttributesGet(id: string): Promise<Models.FamilyAttributes>;
+    /**
+     * Updates one family attribute 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 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.
+     *
+     * 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 `family_id` and `attribute_id` answers 409.
+     *
+     * @param {string} params.id - The `family_attributes` 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_attributes`. An id no family attribute of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @param {string} params.attributeId - The attribute the family carries. One row per (family, attribute); deleting either side deletes the link.
+     * @param {string} params.familyId - The family this link belongs to — one side of the pair that makes an attribute part of a family's form.
+     * @param {boolean} params.isRequired - 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 {number} params.position - The family's own ordering of this attribute, which overrides the attribute's default `position` in this family's form.
+     * @param {object} params.requiredChannels - 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.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.FamilyAttributes>}
+     */
+    productsFamilyAttributesUpdate(params: {
+        id: string;
+        attributeId?: string;
+        familyId?: string;
+        isRequired?: boolean;
+        position?: number;
+        requiredChannels?: object;
+    }): Promise<Models.FamilyAttributes>;
+    /**
+     * Updates one family attribute 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 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.
+     *
+     * 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 `family_id` and `attribute_id` answers 409.
+     *
+     * @param {string} id - The `family_attributes` 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_attributes`. An id no family attribute of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @param {string} attributeId - The attribute the family carries. One row per (family, attribute); deleting either side deletes the link.
+     * @param {string} familyId - The family this link belongs to — one side of the pair that makes an attribute part of a family's form.
+     * @param {boolean} isRequired - 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 {number} position - The family's own ordering of this attribute, which overrides the attribute's default `position` in this family's form.
+     * @param {object} requiredChannels - 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.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.FamilyAttributes>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    productsFamilyAttributesUpdate(id: string, attributeId?: string, familyId?: string, isRequired?: boolean, position?: number, requiredChannels?: object): Promise<Models.FamilyAttributes>;
+    /**
+     * A variant structure of a family: the attribute axes a product model splits its variants on — colour, then size. A product follows one through `family_variant_id`, and an attribute named as an axis becomes read-only on the model and is set on each variant instead, which is what `GET /products/attribute-schema` reports as `readonly_reason`. Two axis shapes are in the wild and both are read: a bare list of codes, or one entry per level.
+     *
+     * Every column of `family_variants` 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.familyId - Exact match on `family_id`. 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 {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.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<{}>}
+     */
+    productsFamilyVariantsList(params?: {
+        limit?: number;
+        offset?: number;
+        order?: string;
+        id?: string;
+        familyId?: string;
+        code?: string;
+        labels?: string;
+        axes?: string;
+        createdAt?: string;
+        updatedAt?: string;
+    }): Promise<{}>;
+    /**
+     * A variant structure of a family: the attribute axes a product model splits its variants on — colour, then size. A product follows one through `family_variant_id`, and an attribute named as an axis becomes read-only on the model and is set on each variant instead, which is what `GET /products/attribute-schema` reports as `readonly_reason`. Two axis shapes are in the wild and both are read: a bare list of codes, or one entry per level.
+     *
+     * Every column of `family_variants` 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} familyId - Exact match on `family_id`. 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 {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} 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<{}>;
+    /**
+     * 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.
+     *
+     * A variant structure of a family: the attribute axes a product model splits its variants on — colour, then size. A product follows one through `family_variant_id`, and an attribute named as an axis becomes read-only on the model and is set on each variant instead, which is what `GET /products/attribute-schema` reports as `readonly_reason`. Two axis shapes are in the wild and both are read: a bare list of codes, or one entry per level.
+     *
+     * `family_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 `code` answers 409.
+     *
+     * @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 {object} params.labels - What the variant structure is called, per language tag.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.FamilyVariants>}
+     */
+    productsFamilyVariantsCreate(params: {
+        code: string;
+        familyId: string;
+        axes?: object;
+        labels?: object;
+    }): 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.
+     *
+     * A variant structure of a family: the attribute axes a product model splits its variants on — colour, then size. A product follows one through `family_variant_id`, and an attribute named as an axis becomes read-only on the model and is set on each variant instead, which is what `GET /products/attribute-schema` reports as `readonly_reason`. Two axis shapes are in the wild and both are read: a bare list of codes, or one entry per level.
+     *
+     * `family_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 `code` answers 409.
+     *
+     * @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 {object} labels - What the variant structure is called, per language tag.
+     * @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>;
+    /**
+     * 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.
+     *
+     * `products.family_variant_id` is set to null instead, so the rows that pointed at it survive the delete rather than going with it.
+     *
+     * An id no family variant 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 `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.
+     * @throws {RevenexxException}
+     * @returns {Promise<{}>}
+     */
+    productsFamilyVariantsDelete(params: {
+        id: string;
+    }): Promise<{}>;
+    /**
+     * 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.
+     *
+     * `products.family_variant_id` is set to null instead, so the rows that pointed at it survive the delete rather than going with it.
+     *
+     * An id no family variant 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 `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.
+     * @throws {RevenexxException}
+     * @returns {Promise<{}>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    productsFamilyVariantsDelete(id: string): Promise<{}>;
+    /**
+     * Reads one family variant by its id — the whole row, every column, as it is stored.
+     *
+     * A variant structure of a family: the attribute axes a product model splits its variants on — colour, then size. A product follows one through `family_variant_id`, and an attribute named as an axis becomes read-only on the model and is set on each variant instead, which is what `GET /products/attribute-schema` reports as `readonly_reason`. Two axis shapes are in the wild and both are read: a bare list of codes, or one entry per level.
+     *
+     * An id no family variant 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 `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.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.FamilyVariants>}
+     */
+    productsFamilyVariantsGet(params: {
+        id: string;
+    }): Promise<Models.FamilyVariants>;
+    /**
+     * Reads one family variant by its id — the whole row, every column, as it is stored.
+     *
+     * A variant structure of a family: the attribute axes a product model splits its variants on — colour, then size. A product follows one through `family_variant_id`, and an attribute named as an axis becomes read-only on the model and is set on each variant instead, which is what `GET /products/attribute-schema` reports as `readonly_reason`. Two axis shapes are in the wild and both are read: a bare list of codes, or one entry per level.
+     *
+     * An id no family variant 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 `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.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.FamilyVariants>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    productsFamilyVariantsGet(id: 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.
+     *
+     * A variant structure of a family: the attribute axes a product model splits its variants on — colour, then size. A product follows one through `family_variant_id`, and an attribute named as an axis becomes read-only on the model and is set on each variant instead, which is what `GET /products/attribute-schema` reports as `readonly_reason`. Two axis shapes are in the wild and both are read: a bare list of codes, or one entry per level.
+     *
+     * 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 `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.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.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.FamilyVariants>}
+     */
+    productsFamilyVariantsUpdate(params: {
+        id: string;
+        axes?: object;
+        code?: string;
+        familyId?: string;
+        labels?: object;
+    }): 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.
+     *
+     * A variant structure of a family: the attribute axes a product model splits its variants on — colour, then size. A product follows one through `family_variant_id`, and an attribute named as an axis becomes read-only on the model and is set on each variant instead, which is what `GET /products/attribute-schema` reports as `readonly_reason`. Two axis shapes are in the wild and both are read: a bare list of codes, or one entry per level.
+     *
+     * 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 `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} 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.
+     * @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>;
+    /**
+     * 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.
+     *
+     * Every column of `measurement_families` 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 measurement family's stable identifier. A `measure` attribute names one and then offers that family's units.
+     * @param {string} params.standardUnit - Exact match on `standard_unit`. The unit every value of this family is converted to before it is compared or sorted — the unit each `convert_factor` is relative to.
+     * @param {string} params.units - Exact match on `units`. The units this family offers. `convert_factor` multiplies a value into `standard_unit`, so a gram is 0.001 kilograms; `symbol` is what a form prints next to the number. 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 measurement family 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.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<{}>}
+     */
+    productsMeasurementFamiliesList(params?: {
+        limit?: number;
+        offset?: number;
+        order?: string;
+        id?: string;
+        code?: string;
+        standardUnit?: string;
+        units?: string;
+        labels?: string;
+        createdAt?: string;
+        updatedAt?: string;
+    }): Promise<{}>;
+    /**
+     * 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.
+     *
+     * Every column of `measurement_families` 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 measurement family's stable identifier. A `measure` attribute names one and then offers that family's units.
+     * @param {string} standardUnit - Exact match on `standard_unit`. The unit every value of this family is converted to before it is compared or sorted — the unit each `convert_factor` is relative to.
+     * @param {string} units - Exact match on `units`. The units this family offers. `convert_factor` multiplies a value into `standard_unit`, so a gram is 0.001 kilograms; `symbol` is what a form prints next to the number. 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 measurement family 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} 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.
+     */
+    productsMeasurementFamiliesList(limit?: number, offset?: number, order?: string, id?: string, code?: string, standardUnit?: string, units?: string, labels?: string, createdAt?: string, updatedAt?: string): Promise<{}>;
+    /**
+     * Creates one measurement 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.
+     *
+     * 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.
+     *
+     * `code` and `standard_unit` are the only columns 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 measurement family's stable identifier. A `measure` attribute names one and then offers that family's units.
+     * @param {string} params.standardUnit - The unit every value of this family is converted to before it is compared or sorted — the unit each `convert_factor` is relative to.
+     * @param {object} params.labels - What the measurement family is called, per language tag.
+     * @param {object} params.units - The units this family offers. `convert_factor` multiplies a value into `standard_unit`, so a gram is 0.001 kilograms; `symbol` is what a form prints next to the number.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.MeasurementFamilies>}
+     */
+    productsMeasurementFamiliesCreate(params: {
+        code: string;
+        standardUnit: string;
+        labels?: object;
+        units?: object;
+    }): Promise<Models.MeasurementFamilies>;
+    /**
+     * Creates one measurement 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.
+     *
+     * 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.
+     *
+     * `code` and `standard_unit` are the only columns 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 measurement family's stable identifier. A `measure` attribute names one and then offers that family's units.
+     * @param {string} standardUnit - The unit every value of this family is converted to before it is compared or sorted — the unit each `convert_factor` is relative to.
+     * @param {object} labels - What the measurement family is called, per language tag.
+     * @param {object} units - The units this family offers. `convert_factor` multiplies a value into `standard_unit`, so a gram is 0.001 kilograms; `symbol` is what a form prints next to the number.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.MeasurementFamilies>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    productsMeasurementFamiliesCreate(code: string, standardUnit: string, labels?: object, units?: object): Promise<Models.MeasurementFamilies>;
+    /**
+     * Deletes one measurement 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.
+     *
+     * Nothing in this schema references it, so nothing else changes.
+     *
+     * An id no measurement family 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 `measurement_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/measurement_families`. An id no measurement familie of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<{}>}
+     */
+    productsMeasurementFamiliesDelete(params: {
+        id: string;
+    }): Promise<{}>;
+    /**
+     * Deletes one measurement 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.
+     *
+     * Nothing in this schema references it, so nothing else changes.
+     *
+     * An id no measurement family 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 `measurement_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/measurement_families`. An id no measurement familie of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<{}>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    productsMeasurementFamiliesDelete(id: string): Promise<{}>;
+    /**
+     * Reads one measurement family by its id — the whole row, every column, as it is stored.
+     *
+     * 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.
+     *
+     * An id no measurement family 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 `measurement_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/measurement_families`. An id no measurement familie of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.MeasurementFamilies>}
+     */
+    productsMeasurementFamiliesGet(params: {
+        id: string;
+    }): Promise<Models.MeasurementFamilies>;
+    /**
+     * Reads one measurement family by its id — the whole row, every column, as it is stored.
+     *
+     * 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.
+     *
+     * An id no measurement family 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 `measurement_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/measurement_families`. An id no measurement familie of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.MeasurementFamilies>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    productsMeasurementFamiliesGet(id: string): Promise<Models.MeasurementFamilies>;
+    /**
+     * Updates one measurement 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.
+     *
+     * 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.
+     *
+     * 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 `measurement_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/measurement_families`. An id no measurement familie of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @param {string} params.code - The measurement family's stable identifier. A `measure` attribute names one and then offers that family's units.
+     * @param {object} params.labels - What the measurement family is called, per language tag.
+     * @param {string} params.standardUnit - The unit every value of this family is converted to before it is compared or sorted — the unit each `convert_factor` is relative to.
+     * @param {object} params.units - The units this family offers. `convert_factor` multiplies a value into `standard_unit`, so a gram is 0.001 kilograms; `symbol` is what a form prints next to the number.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.MeasurementFamilies>}
+     */
+    productsMeasurementFamiliesUpdate(params: {
+        id: string;
+        code?: string;
+        labels?: object;
+        standardUnit?: string;
+        units?: object;
+    }): Promise<Models.MeasurementFamilies>;
+    /**
+     * Updates one measurement 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.
+     *
+     * 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.
+     *
+     * 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 `measurement_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/measurement_families`. An id no measurement familie of this tenant carries answers 404; a malformed one answers 400 before the route is reached.
+     * @param {string} code - The measurement family's stable identifier. A `measure` attribute names one and then offers that family's units.
+     * @param {object} labels - What the measurement family is called, per language tag.
+     * @param {string} standardUnit - The unit every value of this family is converted to before it is compared or sorted — the unit each `convert_factor` is relative to.
+     * @param {object} units - The units this family offers. `convert_factor` multiplies a value into `standard_unit`, so a gram is 0.001 kilograms; `symbol` is what a form prints next to the number.
+     * @throws {RevenexxException}
+     * @returns {Promise<Models.MeasurementFamilies>}
+     * @deprecated Use the object parameter style method for a better developer experience.
+     */
+    productsMeasurementFamiliesUpdate(id: string, code?: string, labels?: object, standardUnit?: string, units?: object): Promise<Models.MeasurementFamilies>;
+}
+
+export { ProductsDataModel };