@endora-commerce/contracts 0.100.0

package/dist/catalog.d.ts

@@ -0,0 +1,2855 @@
+import { z } from 'zod';
+import { type ProductVisibility } from './common.js';
+import type { FulfilmentStrategy } from './inventory.js';
+import type { BulkImportReport } from './import-export.js';
+import type { AttributeScope } from './product-value-resolver.js';
+/**
+ * Catalog module contracts — Source of truth per Principle V.
+ * See specs/001-b2b-platform-foundation/contracts/catalog.contract.md.
+ */
+/**
+ * Product types. Foundation 001 used `simple | variant | grouped |
+ * virtual`; feature 002 (data-model.md §1.1) renames `variant` →
+ * `configurable` and adds `bundle`. The application enum is the only
+ * source of truth — the DB column is `varchar(16)` with no CHECK
+ * constraint (research.md R-1).
+ */
+export declare const productTypeSchema: z.ZodEnum<{
+    simple: "simple";
+    configurable: "configurable";
+    grouped: "grouped";
+    bundle: "bundle";
+    virtual: "virtual";
+}>;
+export type ProductType = z.infer<typeof productTypeSchema>;
+export declare const productStatusSchema: z.ZodEnum<{
+    active: "active";
+    inactive: "inactive";
+    draft: "draft";
+}>;
+export type ProductStatus = z.infer<typeof productStatusSchema>;
+/** Maps legacy `archived` writes to `inactive` (feature 032). */
+export declare function coerceProductStatusWrite(value: unknown): 'draft' | 'active' | 'inactive' | unknown;
+export declare const productStatusWriteSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodEnum<{
+    active: "active";
+    inactive: "inactive";
+    draft: "draft";
+}>>;
+export declare const stockModeSchema: z.ZodEnum<{
+    categorical: "categorical";
+    numeric: "numeric";
+}>;
+export type StockMode = z.infer<typeof stockModeSchema>;
+export declare const stockIndicatorSchema: z.ZodEnum<{
+    available: "available";
+    out_of_stock: "out_of_stock";
+    to_order: "to_order";
+}>;
+export type StockIndicator = z.infer<typeof stockIndicatorSchema>;
+/**
+ * DB-level attribute value types. Foundation 001 introduced the original
+ * 5-element enum (`string | number | boolean | enum | date`). Feature 002
+ * adds `multiselect` and `price` per data-model.md §1.2.
+ *
+ * The API-facing presentation form (`apiAttributeTypeSchema` below)
+ * surfaces additional affordances (`input`, `select`, `slider`) that
+ * map to this DB enum + the sibling `displayAsSlider` flag — see
+ * research.md R-4 / R-7.
+ */
+export declare const attributeValueTypeSchema: z.ZodEnum<{
+    string: "string";
+    number: "number";
+    boolean: "boolean";
+    date: "date";
+    enum: "enum";
+    select: "select";
+    price: "price";
+    multiselect: "multiselect";
+}>;
+export type AttributeValueType = z.infer<typeof attributeValueTypeSchema>;
+/**
+ * API-facing attribute type form for feature 002 contracts. Maps onto
+ * `attributeValueTypeSchema` + `displayAsSlider` in the service layer.
+ */
+export declare const apiAttributeTypeSchema: z.ZodEnum<{
+    number: "number";
+    input: "input";
+    select: "select";
+    price: "price";
+    multiselect: "multiselect";
+    slider: "slider";
+}>;
+export type ApiAttributeType = z.infer<typeof apiAttributeTypeSchema>;
+/**
+ * The API-form type of a stored attribute, derived from the pair the catalogue
+ * persists (`valueType`, `displayAsSlider`). This is the single definition:
+ * the catalogue reports every attribute's `type` through it, and a connector
+ * that binds a source attribute to an existing one compares against it — two
+ * derivations of one rule drift, and a drift creates attributes the catalogue
+ * then reports as another kind.
+ *
+ * A slider flag only means something on a numeric type (`number`, `price`);
+ * elsewhere it is ignored. `string`, `boolean` and `date` have no richer API
+ * form and surface as `input`; `enum` and `select` share one affordance.
+ */
+export declare function apiAttributeTypeOf(valueType: AttributeValueType, displayAsSlider: boolean): ApiAttributeType;
+export declare const assetKindSchema: z.ZodEnum<{
+    image: "image";
+    video: "video";
+    pdf: "pdf";
+    certificate: "certificate";
+    other: "other";
+}>;
+export type AssetKind = z.infer<typeof assetKindSchema>;
+export declare const attributeOptionSchema: z.ZodObject<{
+    id: z.ZodString;
+    attributeId: z.ZodString;
+    value: z.ZodString;
+    label: z.ZodRecord<z.ZodString, z.ZodString>;
+    labelDefault: z.ZodString;
+    isDefault: z.ZodBoolean;
+    sortOrder: z.ZodNumber;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type AttributeOption = z.infer<typeof attributeOptionSchema>;
+export declare const createAttributeOptionRequestSchema: z.ZodObject<{
+    value: z.ZodString;
+    label: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    labelDefault: z.ZodString;
+    isDefault: z.ZodOptional<z.ZodBoolean>;
+    sortOrder: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type CreateAttributeOptionRequest = z.infer<typeof createAttributeOptionRequestSchema>;
+export declare const replaceAttributeOptionsRequestSchema: z.ZodObject<{
+    options: z.ZodArray<z.ZodObject<{
+        value: z.ZodString;
+        label: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        labelDefault: z.ZodString;
+        isDefault: z.ZodOptional<z.ZodBoolean>;
+        sortOrder: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ReplaceAttributeOptionsRequest = z.infer<typeof replaceAttributeOptionsRequestSchema>;
+export declare const patchAttributeOptionRequestSchema: z.ZodObject<{
+    label: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    labelDefault: z.ZodOptional<z.ZodString>;
+    isDefault: z.ZodOptional<z.ZodBoolean>;
+    sortOrder: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type PatchAttributeOptionRequest = z.infer<typeof patchAttributeOptionRequestSchema>;
+export declare const productAssetSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        image: "image";
+        video: "video";
+        pdf: "pdf";
+        certificate: "certificate";
+        other: "other";
+    }>;
+    url: z.ZodString;
+    altText: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type ProductAsset = z.infer<typeof productAssetSchema>;
+/**
+ * Availability indication mirrored from the inventory display bands the
+ * storefront shows (`available` = stock not managed for the product).
+ */
+export declare const productAvailabilityBandSchema: z.ZodEnum<{
+    available: "available";
+    out_of_stock: "out_of_stock";
+    high: "high";
+    medium: "medium";
+    low: "low";
+}>;
+export type ProductAvailabilityBand = z.infer<typeof productAvailabilityBandSchema>;
+export declare const productAvailabilitySchema: z.ZodObject<{
+    band: z.ZodEnum<{
+        available: "available";
+        out_of_stock: "out_of_stock";
+        high: "high";
+        medium: "medium";
+        low: "low";
+    }>;
+    inStock: z.ZodBoolean;
+}, z.core.$strip>;
+export type ProductAvailability = z.infer<typeof productAvailabilitySchema>;
+/**
+ * One rung of the bound Organization's resolved quantity-bracket price
+ * ladder (external product detail only).
+ */
+export declare const productPriceTierSchema: z.ZodObject<{
+    minQuantity: z.ZodNumber;
+    amount: z.ZodNumber;
+    currency: z.ZodString;
+    isSale: z.ZodBoolean;
+}, z.core.$strip>;
+export type ProductPriceTier = z.infer<typeof productPriceTierSchema>;
+export declare const productSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    sku: z.ZodString;
+    type: z.ZodEnum<{
+        simple: "simple";
+        configurable: "configurable";
+        grouped: "grouped";
+        bundle: "bundle";
+        virtual: "virtual";
+    }>;
+    name: z.ZodString;
+    slug: z.ZodString;
+    categorySlugs: z.ZodArray<z.ZodString>;
+    primaryAssetUrl: z.ZodNullable<z.ZodString>;
+    price: z.ZodNullable<z.ZodObject<{
+        amount: z.ZodNumber;
+        currency: z.ZodString;
+    }, z.core.$strip>>;
+    stockIndicator: z.ZodNullable<z.ZodEnum<{
+        available: "available";
+        out_of_stock: "out_of_stock";
+        to_order: "to_order";
+    }>>;
+    stockLevel: z.ZodNullable<z.ZodNumber>;
+    priceUnavailable: z.ZodOptional<z.ZodBoolean>;
+    availability: z.ZodOptional<z.ZodObject<{
+        band: z.ZodEnum<{
+            available: "available";
+            out_of_stock: "out_of_stock";
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>;
+        inStock: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ProductSummary = z.infer<typeof productSummarySchema>;
+export declare const productVariantSchema: z.ZodObject<{
+    id: z.ZodString;
+    sku: z.ZodString;
+    variantAttributeValues: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    priceOverride: z.ZodNullable<z.ZodNumber>;
+    stockLevel: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type ProductVariant = z.infer<typeof productVariantSchema>;
+export declare const seoMetaSchema: z.ZodObject<{
+    metaTitle: z.ZodString;
+    metaDescription: z.ZodString;
+    openGraph: z.ZodObject<{
+        title: z.ZodString;
+        description: z.ZodString;
+        imageUrl: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type SeoMeta = z.infer<typeof seoMetaSchema>;
+export declare const productDetailSchema: z.ZodObject<{
+    id: z.ZodString;
+    sku: z.ZodString;
+    type: z.ZodEnum<{
+        simple: "simple";
+        configurable: "configurable";
+        grouped: "grouped";
+        bundle: "bundle";
+        virtual: "virtual";
+    }>;
+    name: z.ZodString;
+    slug: z.ZodString;
+    categorySlugs: z.ZodArray<z.ZodString>;
+    primaryAssetUrl: z.ZodNullable<z.ZodString>;
+    price: z.ZodNullable<z.ZodObject<{
+        amount: z.ZodNumber;
+        currency: z.ZodString;
+    }, z.core.$strip>>;
+    stockIndicator: z.ZodNullable<z.ZodEnum<{
+        available: "available";
+        out_of_stock: "out_of_stock";
+        to_order: "to_order";
+    }>>;
+    stockLevel: z.ZodNullable<z.ZodNumber>;
+    priceUnavailable: z.ZodOptional<z.ZodBoolean>;
+    availability: z.ZodOptional<z.ZodObject<{
+        band: z.ZodEnum<{
+            available: "available";
+            out_of_stock: "out_of_stock";
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>;
+        inStock: z.ZodBoolean;
+    }, z.core.$strip>>;
+    description: z.ZodString;
+    attributeValues: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    assets: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            image: "image";
+            video: "video";
+            pdf: "pdf";
+            certificate: "certificate";
+            other: "other";
+        }>;
+        url: z.ZodString;
+        altText: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    variants: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        sku: z.ZodString;
+        variantAttributeValues: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        priceOverride: z.ZodNullable<z.ZodNumber>;
+        stockLevel: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+    categories: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        slug: z.ZodString;
+    }, z.core.$strip>>;
+    seo: z.ZodObject<{
+        metaTitle: z.ZodString;
+        metaDescription: z.ZodString;
+        openGraph: z.ZodObject<{
+            title: z.ZodString;
+            description: z.ZodString;
+            imageUrl: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    structuredDataJsonLd: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    attributeSet: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        code: z.ZodString;
+        name: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strip>>;
+    gallery: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        position: z.ZodNumber;
+        labels: z.ZodArray<z.ZodEnum<{
+            base_image: "base_image";
+            small_image: "small_image";
+            thumbnail: "thumbnail";
+        }>>;
+        asset: z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodString;
+            url: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+    groupedItems: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        position: z.ZodNumber;
+        quantity: z.ZodNumber;
+        product: z.ZodObject<{
+            id: z.ZodString;
+            sku: z.ZodString;
+            slug: z.ZodString;
+            name: z.ZodString;
+            primaryAssetUrl: z.ZodNullable<z.ZodString>;
+            price: z.ZodNullable<z.ZodObject<{
+                amount: z.ZodNumber;
+                currency: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+    bundleSlots: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodRecord<z.ZodString, z.ZodString>;
+        minQuantity: z.ZodNumber;
+        maxQuantity: z.ZodNumber;
+        position: z.ZodNumber;
+        options: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            defaultQuantity: z.ZodNumber;
+            position: z.ZodNumber;
+            product: z.ZodObject<{
+                id: z.ZodString;
+                sku: z.ZodString;
+                slug: z.ZodString;
+                name: z.ZodString;
+                primaryAssetUrl: z.ZodNullable<z.ZodString>;
+                price: z.ZodNullable<z.ZodObject<{
+                    amount: z.ZodNumber;
+                    currency: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    virtual: z.ZodOptional<z.ZodObject<{
+        downloadAssetId: z.ZodNullable<z.ZodString>;
+        downloadUrl: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    links: z.ZodOptional<z.ZodObject<{
+        related: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                related: "related";
+                up_sell: "up_sell";
+                cross_sell: "cross_sell";
+            }>;
+            position: z.ZodNumber;
+            product: z.ZodObject<{
+                id: z.ZodString;
+                sku: z.ZodString;
+                slug: z.ZodString;
+                name: z.ZodString;
+                primaryAssetUrl: z.ZodNullable<z.ZodString>;
+                price: z.ZodNullable<z.ZodObject<{
+                    amount: z.ZodNumber;
+                    currency: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        upSell: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                related: "related";
+                up_sell: "up_sell";
+                cross_sell: "cross_sell";
+            }>;
+            position: z.ZodNumber;
+            product: z.ZodObject<{
+                id: z.ZodString;
+                sku: z.ZodString;
+                slug: z.ZodString;
+                name: z.ZodString;
+                primaryAssetUrl: z.ZodNullable<z.ZodString>;
+                price: z.ZodNullable<z.ZodObject<{
+                    amount: z.ZodNumber;
+                    currency: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        crossSell: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                related: "related";
+                up_sell: "up_sell";
+                cross_sell: "cross_sell";
+            }>;
+            position: z.ZodNumber;
+            product: z.ZodObject<{
+                id: z.ZodString;
+                sku: z.ZodString;
+                slug: z.ZodString;
+                name: z.ZodString;
+                primaryAssetUrl: z.ZodNullable<z.ZodString>;
+                price: z.ZodNullable<z.ZodObject<{
+                    amount: z.ZodNumber;
+                    currency: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        position: z.ZodNumber;
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        type: z.ZodObject<{
+            id: z.ZodString;
+            code: z.ZodString;
+            name: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, z.core.$strip>;
+        asset: z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodString;
+            url: z.ZodString;
+            filename: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            mimeType: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+    visibleAttributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        valueType: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            date: "date";
+            enum: "enum";
+            select: "select";
+            price: "price";
+            multiselect: "multiselect";
+        }>;
+        valueRendered: z.ZodString;
+    }, z.core.$strip>>>;
+    packagingUnits: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        baseQuantity: z.ZodNumber;
+        position: z.ZodNumber;
+        isDefault: z.ZodBoolean;
+    }, z.core.$strip>>>;
+    priceTiers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        minQuantity: z.ZodNumber;
+        amount: z.ZodNumber;
+        currency: z.ZodString;
+        isSale: z.ZodBoolean;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type ProductDetail = z.infer<typeof productDetailSchema>;
+export declare const catalogBulkPriceRequestSchema: z.ZodObject<{
+    lines: z.ZodArray<z.ZodObject<{
+        sku: z.ZodString;
+        quantity: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CatalogBulkPriceRequest = z.infer<typeof catalogBulkPriceRequestSchema>;
+export declare const catalogBulkPriceMissReasonSchema: z.ZodEnum<{
+    sku_not_in_assortment: "sku_not_in_assortment";
+    price_unavailable: "price_unavailable";
+}>;
+export type CatalogBulkPriceMissReason = z.infer<typeof catalogBulkPriceMissReasonSchema>;
+/**
+ * Per-line result, order-preserving. Misses are data, not errors — the
+ * partner needs a total answer for a basket. `amount` is the exact decimal
+ * string the pricing resolver charges the bound org on the bound channel at
+ * that quantity (SC-001 parity with cart pricing).
+ */
+export declare const catalogBulkPriceLineSchema: z.ZodUnion<readonly [z.ZodObject<{
+    sku: z.ZodString;
+    quantity: z.ZodNumber;
+    price: z.ZodObject<{
+        amount: z.ZodString;
+        currency: z.ZodString;
+        isSale: z.ZodBoolean;
+        bracketStartQuantity: z.ZodNumber;
+        priceListId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    sku: z.ZodString;
+    quantity: z.ZodNumber;
+    price: z.ZodNull;
+    reason: z.ZodEnum<{
+        sku_not_in_assortment: "sku_not_in_assortment";
+        price_unavailable: "price_unavailable";
+    }>;
+}, z.core.$strip>]>;
+export type CatalogBulkPriceLine = z.infer<typeof catalogBulkPriceLineSchema>;
+export declare const catalogBulkPriceResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        sku: z.ZodString;
+        quantity: z.ZodNumber;
+        price: z.ZodObject<{
+            amount: z.ZodString;
+            currency: z.ZodString;
+            isSale: z.ZodBoolean;
+            bracketStartQuantity: z.ZodNumber;
+            priceListId: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        sku: z.ZodString;
+        quantity: z.ZodNumber;
+        price: z.ZodNull;
+        reason: z.ZodEnum<{
+            sku_not_in_assortment: "sku_not_in_assortment";
+            price_unavailable: "price_unavailable";
+        }>;
+    }, z.core.$strip>]>>;
+}, z.core.$strip>;
+export type CatalogBulkPriceResponse = z.infer<typeof catalogBulkPriceResponseSchema>;
+export interface CategoryNode {
+    id: string;
+    name: string;
+    slug: string;
+    sortOrder: number;
+    productCount: number;
+    children: CategoryNode[];
+}
+export declare const categoryNodeSchema: z.ZodType<CategoryNode>;
+export declare const filterOptionSchema: z.ZodObject<{
+    value: z.ZodString;
+    label: z.ZodString;
+    count: z.ZodNumber;
+}, z.core.$strip>;
+export type FilterOption = z.infer<typeof filterOptionSchema>;
+export declare const filterRangeSchema: z.ZodObject<{
+    min: z.ZodNumber;
+    max: z.ZodNumber;
+}, z.core.$strip>;
+export type FilterRange = z.infer<typeof filterRangeSchema>;
+export declare const filterDefinitionSchema: z.ZodObject<{
+    attributeKey: z.ZodString;
+    label: z.ZodString;
+    valueType: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        date: "date";
+        enum: "enum";
+        select: "select";
+        price: "price";
+        multiselect: "multiselect";
+    }>;
+    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        value: z.ZodString;
+        label: z.ZodString;
+        count: z.ZodNumber;
+    }, z.core.$strip>>>;
+    range: z.ZodOptional<z.ZodObject<{
+        min: z.ZodNumber;
+        max: z.ZodNumber;
+    }, z.core.$strip>>;
+    filterPosition: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type FilterDefinition = z.infer<typeof filterDefinitionSchema>;
+export declare const createProductRequestSchema: z.ZodObject<{
+    sku: z.ZodString;
+    type: z.ZodEnum<{
+        simple: "simple";
+        configurable: "configurable";
+        grouped: "grouped";
+        bundle: "bundle";
+        virtual: "virtual";
+    }>;
+    name: z.ZodRecord<z.ZodString, z.ZodString>;
+    description: z.ZodRecord<z.ZodString, z.ZodString>;
+    categoryIds: z.ZodArray<z.ZodString>;
+    attributeValues: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    stockMode: z.ZodOptional<z.ZodEnum<{
+        categorical: "categorical";
+        numeric: "numeric";
+    }>>;
+    visibility: z.ZodEnum<{
+        public: "public";
+        logged_in_only: "logged_in_only";
+        organization_restricted: "organization_restricted";
+    }>;
+    status: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodEnum<{
+        active: "active";
+        inactive: "inactive";
+        draft: "draft";
+    }>>>;
+    allowedOrganizationIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    assetIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    initialStock: z.ZodOptional<z.ZodNumber>;
+    attributeSetId: z.ZodOptional<z.ZodString>;
+    downloadAssetId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    downloadUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    manageStock: z.ZodOptional<z.ZodBoolean>;
+    backorderEnabled: z.ZodOptional<z.ZodBoolean>;
+    lowStockThreshold: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    lowStockThresholdMode: z.ZodOptional<z.ZodEnum<{
+        cumulative: "cumulative";
+        per_warehouse: "per_warehouse";
+    }>>;
+    fulfilmentStrategy: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        any: "any";
+        default_first: "default_first";
+        lowest_stock_first: "lowest_stock_first";
+        highest_stock_first: "highest_stock_first";
+        defined_order: "defined_order";
+    }>>>;
+    fulfilmentStrategyWarehouseOrder: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+export type CreateProductRequest = z.infer<typeof createProductRequestSchema>;
+export declare const updateProductRequestSchema: z.ZodObject<{
+    description: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    name: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    status: z.ZodOptional<z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodEnum<{
+        active: "active";
+        inactive: "inactive";
+        draft: "draft";
+    }>>>>;
+    visibility: z.ZodOptional<z.ZodEnum<{
+        public: "public";
+        logged_in_only: "logged_in_only";
+        organization_restricted: "organization_restricted";
+    }>>;
+    assetIds: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    categoryIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    sku: z.ZodOptional<z.ZodString>;
+    manageStock: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+    backorderEnabled: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+    lowStockThreshold: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodNumber>>>;
+    lowStockThresholdMode: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
+        cumulative: "cumulative";
+        per_warehouse: "per_warehouse";
+    }>>>;
+    attributeValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    downloadAssetId: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+    downloadUrl: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+    stockMode: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
+        categorical: "categorical";
+        numeric: "numeric";
+    }>>>;
+    allowedOrganizationIds: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    initialStock: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    attributeSetId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    fulfilmentStrategy: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        any: "any";
+        default_first: "default_first";
+        lowest_stock_first: "lowest_stock_first";
+        highest_stock_first: "highest_stock_first";
+        defined_order: "defined_order";
+    }>>>>;
+    fulfilmentStrategyWarehouseOrder: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>>;
+}, z.core.$strip>;
+export type UpdateProductRequest = z.infer<typeof updateProductRequestSchema>;
+export declare const batchByIdProductsRequestSchema: z.ZodObject<{
+    ids: z.ZodArray<z.ZodString>;
+    page: z.ZodOptional<z.ZodNumber>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type BatchByIdProductsRequest = z.infer<typeof batchByIdProductsRequestSchema>;
+export declare const MAX_RESOLVE_SELECTION_SIZE = 10000;
+export declare const resolveProductIdsRequestSchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        inactive: "inactive";
+        draft: "draft";
+    }>>;
+    type: z.ZodOptional<z.ZodEnum<{
+        simple: "simple";
+        configurable: "configurable";
+        grouped: "grouped";
+        bundle: "bundle";
+        virtual: "virtual";
+    }>>;
+    q: z.ZodOptional<z.ZodString>;
+    includeArchived: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ResolveProductIdsRequest = z.infer<typeof resolveProductIdsRequestSchema>;
+export declare const resolveProductIdsResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        productIds: z.ZodArray<z.ZodString>;
+        total: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ResolveProductIdsResponse = z.infer<typeof resolveProductIdsResponseSchema>;
+export declare const bulkUpdateProductsRequestSchema: z.ZodObject<{
+    productIds: z.ZodArray<z.ZodString>;
+    fields: z.ZodObject<{
+        status: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodEnum<{
+            active: "active";
+            inactive: "inactive";
+            draft: "draft";
+        }>>>;
+        visibility: z.ZodOptional<z.ZodEnum<{
+            public: "public";
+            logged_in_only: "logged_in_only";
+            organization_restricted: "organization_restricted";
+        }>>;
+        salesChannels: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodEnum<{
+                replace: "replace";
+                add: "add";
+            }>;
+            channelIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        categories: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodEnum<{
+                replace: "replace";
+                add: "add";
+                remove: "remove";
+            }>;
+            categoryIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        attributeSetId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        attributeValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type BulkUpdateProductsRequest = z.infer<typeof bulkUpdateProductsRequestSchema>;
+export declare const bulkUpdateProductResultSchema: z.ZodObject<{
+    productId: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        skipped: "skipped";
+        succeeded: "succeeded";
+    }>;
+    reason: z.ZodOptional<z.ZodEnum<{
+        product_not_found: "product_not_found";
+        attribute_not_in_set: "attribute_not_in_set";
+        validation_failed: "validation_failed";
+        permission_denied: "permission_denied";
+        concurrent_modification: "concurrent_modification";
+    }>>;
+    details: z.ZodOptional<z.ZodObject<{
+        code: z.ZodOptional<z.ZodString>;
+        message: z.ZodOptional<z.ZodString>;
+        attribute: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    changedFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type BulkUpdateProductResult = z.infer<typeof bulkUpdateProductResultSchema>;
+export declare const bulkUpdateProductsResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        bulkOperationId: z.ZodString;
+        summary: z.ZodObject<{
+            succeeded: z.ZodNumber;
+            skipped: z.ZodNumber;
+            failed: z.ZodNumber;
+            total: z.ZodNumber;
+        }, z.core.$strip>;
+        results: z.ZodArray<z.ZodObject<{
+            productId: z.ZodString;
+            status: z.ZodEnum<{
+                failed: "failed";
+                skipped: "skipped";
+                succeeded: "succeeded";
+            }>;
+            reason: z.ZodOptional<z.ZodEnum<{
+                product_not_found: "product_not_found";
+                attribute_not_in_set: "attribute_not_in_set";
+                validation_failed: "validation_failed";
+                permission_denied: "permission_denied";
+                concurrent_modification: "concurrent_modification";
+            }>>;
+            details: z.ZodOptional<z.ZodObject<{
+                code: z.ZodOptional<z.ZodString>;
+                message: z.ZodOptional<z.ZodString>;
+                attribute: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            changedFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type BulkUpdateProductsResponse = z.infer<typeof bulkUpdateProductsResponseSchema>;
+export declare const bulkUpdateQueuedResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        queued: z.ZodLiteral<true>;
+        bulkOperationId: z.ZodString;
+        total: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type BulkUpdateQueuedResponse = z.infer<typeof bulkUpdateQueuedResponseSchema>;
+export declare const bulkOperationStatusSchema: z.ZodEnum<{
+    pending: "pending";
+    completed: "completed";
+    failed: "failed";
+    running: "running";
+}>;
+export type BulkOperationStatus = z.infer<typeof bulkOperationStatusSchema>;
+/**
+ * One timestamped lifecycle event in a bulk operation's log trail, surfaced
+ * in the bulk-operations detail view next to the per-element results.
+ */
+export declare const bulkOperationLogEntrySchema: z.ZodObject<{
+    ts: z.ZodString;
+    level: z.ZodEnum<{
+        error: "error";
+        info: "info";
+        warn: "warn";
+    }>;
+    message: z.ZodString;
+}, z.core.$strip>;
+export type BulkOperationLogEntry = z.infer<typeof bulkOperationLogEntrySchema>;
+/**
+ * Known bulk-operation kinds. `type` on the record is an open string (the
+ * queue is generic), but these are the kinds the platform ships:
+ *   - `product_bulk_update` — the queued large product bulk-edit (feature 022).
+ *   - `search_reindex`       — a full Meilisearch reindex (the `search:reindex`
+ *      CLI equivalent), enqueued when an attribute's `searchable` flag changes.
+ */
+export declare const BULK_OPERATION_TYPES: {
+    readonly PRODUCT_BULK_UPDATE: "product_bulk_update";
+    readonly SEARCH_REINDEX: "search_reindex";
+};
+export type BulkOperationType = (typeof BULK_OPERATION_TYPES)[keyof typeof BULK_OPERATION_TYPES];
+export declare const bulkOperationSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodString;
+    status: z.ZodEnum<{
+        pending: "pending";
+        completed: "completed";
+        failed: "failed";
+        running: "running";
+    }>;
+    requestedByAdminUserId: z.ZodString;
+    total: z.ZodNumber;
+    processed: z.ZodNumber;
+    succeeded: z.ZodNumber;
+    skipped: z.ZodNumber;
+    failed: z.ZodNumber;
+    touchedFields: z.ZodArray<z.ZodString>;
+    results: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        productId: z.ZodString;
+        status: z.ZodEnum<{
+            failed: "failed";
+            skipped: "skipped";
+            succeeded: "succeeded";
+        }>;
+        reason: z.ZodOptional<z.ZodEnum<{
+            product_not_found: "product_not_found";
+            attribute_not_in_set: "attribute_not_in_set";
+            validation_failed: "validation_failed";
+            permission_denied: "permission_denied";
+            concurrent_modification: "concurrent_modification";
+        }>>;
+        details: z.ZodOptional<z.ZodObject<{
+            code: z.ZodOptional<z.ZodString>;
+            message: z.ZodOptional<z.ZodString>;
+            attribute: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        changedFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    logs: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        ts: z.ZodString;
+        level: z.ZodEnum<{
+            error: "error";
+            info: "info";
+            warn: "warn";
+        }>;
+        message: z.ZodString;
+    }, z.core.$strip>>>;
+    error: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+    startedAt: z.ZodNullable<z.ZodString>;
+    finishedAt: z.ZodNullable<z.ZodString>;
+    reversible: z.ZodBoolean;
+    undoStatus: z.ZodEnum<{
+        none: "none";
+        reverted: "reverted";
+        partially_reverted: "partially_reverted";
+    }>;
+    undoneAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type BulkOperation = z.infer<typeof bulkOperationSchema>;
+/** Response of POST /admin/catalog/bulk-operations/:id/undo. */
+export declare const bulkOperationUndoResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        undoStatus: z.ZodEnum<{
+            none: "none";
+            reverted: "reverted";
+            partially_reverted: "partially_reverted";
+        }>;
+        reverted: z.ZodNumber;
+        conflicts: z.ZodArray<z.ZodObject<{
+            recordId: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type BulkOperationUndoResponse = z.infer<typeof bulkOperationUndoResponseSchema>;
+export declare const bulkOperationsListResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+        status: z.ZodEnum<{
+            pending: "pending";
+            completed: "completed";
+            failed: "failed";
+            running: "running";
+        }>;
+        requestedByAdminUserId: z.ZodString;
+        total: z.ZodNumber;
+        processed: z.ZodNumber;
+        succeeded: z.ZodNumber;
+        skipped: z.ZodNumber;
+        failed: z.ZodNumber;
+        touchedFields: z.ZodArray<z.ZodString>;
+        results: z.ZodNullable<z.ZodArray<z.ZodObject<{
+            productId: z.ZodString;
+            status: z.ZodEnum<{
+                failed: "failed";
+                skipped: "skipped";
+                succeeded: "succeeded";
+            }>;
+            reason: z.ZodOptional<z.ZodEnum<{
+                product_not_found: "product_not_found";
+                attribute_not_in_set: "attribute_not_in_set";
+                validation_failed: "validation_failed";
+                permission_denied: "permission_denied";
+                concurrent_modification: "concurrent_modification";
+            }>>;
+            details: z.ZodOptional<z.ZodObject<{
+                code: z.ZodOptional<z.ZodString>;
+                message: z.ZodOptional<z.ZodString>;
+                attribute: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            changedFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        logs: z.ZodNullable<z.ZodArray<z.ZodObject<{
+            ts: z.ZodString;
+            level: z.ZodEnum<{
+                error: "error";
+                info: "info";
+                warn: "warn";
+            }>;
+            message: z.ZodString;
+        }, z.core.$strip>>>;
+        error: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodString;
+        startedAt: z.ZodNullable<z.ZodString>;
+        finishedAt: z.ZodNullable<z.ZodString>;
+        reversible: z.ZodBoolean;
+        undoStatus: z.ZodEnum<{
+            none: "none";
+            reverted: "reverted";
+            partially_reverted: "partially_reverted";
+        }>;
+        undoneAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    pagination: z.ZodObject<{
+        total: z.ZodNumber;
+        limit: z.ZodNumber;
+        offset: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type BulkOperationsListResponse = z.infer<typeof bulkOperationsListResponseSchema>;
+export declare const bulkOperationResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+        status: z.ZodEnum<{
+            pending: "pending";
+            completed: "completed";
+            failed: "failed";
+            running: "running";
+        }>;
+        requestedByAdminUserId: z.ZodString;
+        total: z.ZodNumber;
+        processed: z.ZodNumber;
+        succeeded: z.ZodNumber;
+        skipped: z.ZodNumber;
+        failed: z.ZodNumber;
+        touchedFields: z.ZodArray<z.ZodString>;
+        results: z.ZodNullable<z.ZodArray<z.ZodObject<{
+            productId: z.ZodString;
+            status: z.ZodEnum<{
+                failed: "failed";
+                skipped: "skipped";
+                succeeded: "succeeded";
+            }>;
+            reason: z.ZodOptional<z.ZodEnum<{
+                product_not_found: "product_not_found";
+                attribute_not_in_set: "attribute_not_in_set";
+                validation_failed: "validation_failed";
+                permission_denied: "permission_denied";
+                concurrent_modification: "concurrent_modification";
+            }>>;
+            details: z.ZodOptional<z.ZodObject<{
+                code: z.ZodOptional<z.ZodString>;
+                message: z.ZodOptional<z.ZodString>;
+                attribute: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            changedFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        logs: z.ZodNullable<z.ZodArray<z.ZodObject<{
+            ts: z.ZodString;
+            level: z.ZodEnum<{
+                error: "error";
+                info: "info";
+                warn: "warn";
+            }>;
+            message: z.ZodString;
+        }, z.core.$strip>>>;
+        error: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodString;
+        startedAt: z.ZodNullable<z.ZodString>;
+        finishedAt: z.ZodNullable<z.ZodString>;
+        reversible: z.ZodBoolean;
+        undoStatus: z.ZodEnum<{
+            none: "none";
+            reverted: "reverted";
+            partially_reverted: "partially_reverted";
+        }>;
+        undoneAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type BulkOperationResponse = z.infer<typeof bulkOperationResponseSchema>;
+export declare const createVariantRequestSchema: z.ZodObject<{
+    sku: z.ZodString;
+    variantAttributeValues: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    priceOverride: z.ZodOptional<z.ZodNumber>;
+    stockLevel: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type CreateVariantRequest = z.infer<typeof createVariantRequestSchema>;
+export declare const updateVariantRequestSchema: z.ZodObject<{
+    stockLevel: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    variantAttributeValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    priceOverride: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>;
+export type UpdateVariantRequest = z.infer<typeof updateVariantRequestSchema>;
+/**
+ * Slider-numeric-kind discriminant (feature 002 T013/T021/T022). The API
+ * `type=slider` form needs an extra hint so the service knows whether the
+ * underlying DB `valueType` is `number` or `price`.
+ */
+export declare const numericKindSchema: z.ZodEnum<{
+    number: "number";
+    price: "price";
+}>;
+export type NumericKind = z.infer<typeof numericKindSchema>;
+export declare const createAttributeRequestSchema: z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodRecord<z.ZodString, z.ZodString>;
+    type: z.ZodOptional<z.ZodEnum<{
+        number: "number";
+        input: "input";
+        select: "select";
+        price: "price";
+        multiselect: "multiselect";
+        slider: "slider";
+    }>>;
+    numericKind: z.ZodOptional<z.ZodEnum<{
+        number: "number";
+        price: "price";
+    }>>;
+    valueType: z.ZodOptional<z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        date: "date";
+        enum: "enum";
+        select: "select";
+        price: "price";
+        multiselect: "multiselect";
+    }>>;
+    enumValues: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    isSearchable: z.ZodBoolean;
+    isFilterable: z.ZodBoolean;
+    isVariantAxis: z.ZodBoolean;
+    displayAsSlider: z.ZodOptional<z.ZodBoolean>;
+    isComparable: z.ZodOptional<z.ZodBoolean>;
+    labelDefault: z.ZodOptional<z.ZodString>;
+    isRequired: z.ZodOptional<z.ZodBoolean>;
+    isPromoRule: z.ZodOptional<z.ZodBoolean>;
+    filterPosition: z.ZodOptional<z.ZodNumber>;
+    isVisibleOnProductPage: z.ZodOptional<z.ZodBoolean>;
+    channelScoped: z.ZodOptional<z.ZodBoolean>;
+    languageScoped: z.ZodOptional<z.ZodBoolean>;
+    massEditable: z.ZodOptional<z.ZodBoolean>;
+    quickSearchable: z.ZodOptional<z.ZodBoolean>;
+    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        value: z.ZodString;
+        label: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        labelDefault: z.ZodString;
+        isDefault: z.ZodOptional<z.ZodBoolean>;
+        sortOrder: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type CreateAttributeRequest = z.infer<typeof createAttributeRequestSchema>;
+export declare const updateAttributeRequestSchema: z.ZodObject<{
+    label: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    type: z.ZodOptional<z.ZodEnum<{
+        number: "number";
+        input: "input";
+        select: "select";
+        price: "price";
+        multiselect: "multiselect";
+        slider: "slider";
+    }>>;
+    numericKind: z.ZodOptional<z.ZodEnum<{
+        number: "number";
+        price: "price";
+    }>>;
+    enumValues: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    isSearchable: z.ZodOptional<z.ZodBoolean>;
+    isFilterable: z.ZodOptional<z.ZodBoolean>;
+    isVariantAxis: z.ZodOptional<z.ZodBoolean>;
+    displayAsSlider: z.ZodOptional<z.ZodBoolean>;
+    isComparable: z.ZodOptional<z.ZodBoolean>;
+    labelDefault: z.ZodOptional<z.ZodString>;
+    isRequired: z.ZodOptional<z.ZodBoolean>;
+    isPromoRule: z.ZodOptional<z.ZodBoolean>;
+    filterPosition: z.ZodOptional<z.ZodNumber>;
+    isVisibleOnProductPage: z.ZodOptional<z.ZodBoolean>;
+    channelScoped: z.ZodOptional<z.ZodBoolean>;
+    languageScoped: z.ZodOptional<z.ZodBoolean>;
+    massEditable: z.ZodOptional<z.ZodBoolean>;
+    quickSearchable: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type UpdateAttributeRequest = z.infer<typeof updateAttributeRequestSchema>;
+/**
+ * Feature 061 — admin attribute payload returned by
+ * `GET/POST/PATCH /api/v1/admin/catalog/attributes*`. Formalizes the shape
+ * `serializeAdminAttribute` has emitted since features 002/012/022/023/039 and
+ * adds the single additive field `customFieldDefinitionId` — the backing
+ * product-host Custom Field definition (contracts/attribute-admin-api.md).
+ * All request schemas above are byte-compatible and unchanged (FR-007, SC-003).
+ */
+export declare const adminAttributeResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    key: z.ZodString;
+    label: z.ZodRecord<z.ZodString, z.ZodString>;
+    labelDefault: z.ZodString;
+    type: z.ZodEnum<{
+        number: "number";
+        input: "input";
+        select: "select";
+        price: "price";
+        multiselect: "multiselect";
+        slider: "slider";
+    }>;
+    numericKind: z.ZodOptional<z.ZodEnum<{
+        number: "number";
+        price: "price";
+    }>>;
+    valueType: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        date: "date";
+        enum: "enum";
+        select: "select";
+        price: "price";
+        multiselect: "multiselect";
+    }>;
+    enumValues: z.ZodNullable<z.ZodArray<z.ZodString>>;
+    isSearchable: z.ZodBoolean;
+    isFilterable: z.ZodBoolean;
+    isVariantAxis: z.ZodBoolean;
+    displayAsSlider: z.ZodBoolean;
+    isComparable: z.ZodBoolean;
+    isRequired: z.ZodBoolean;
+    isPromoRule: z.ZodBoolean;
+    filterPosition: z.ZodNumber;
+    isVisibleOnProductPage: z.ZodBoolean;
+    massEditable: z.ZodBoolean;
+    quickSearchable: z.ZodBoolean;
+    customFieldDefinitionId: z.ZodString;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type AdminAttributeResponse = z.infer<typeof adminAttributeResponseSchema>;
+export declare const createCategoryRequestSchema: z.ZodObject<{
+    parentCategoryId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    name: z.ZodRecord<z.ZodString, z.ZodString>;
+    slug: z.ZodString;
+    sortOrder: z.ZodOptional<z.ZodNumber>;
+    isActive: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type CreateCategoryRequest = z.infer<typeof createCategoryRequestSchema>;
+export declare const updateCategoryRequestSchema: z.ZodObject<{
+    parentCategoryId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    name: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    slug: z.ZodOptional<z.ZodString>;
+    sortOrder: z.ZodOptional<z.ZodNumber>;
+    isActive: z.ZodOptional<z.ZodBoolean>;
+    mainImageAssetId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    customFieldValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export type UpdateCategoryRequest = z.infer<typeof updateCategoryRequestSchema>;
+/**
+ * The orderings the storefront listing accepts.
+ *
+ * Feature 086 adds `price` / `-price`, following the convention the two `name`
+ * members set: the bare member ascends, the `-` prefix descends. "Price" is the
+ * **viewer's own** resolved unit price at quantity 1 — the figure the card
+ * renders — never a stored base price, a channel price or anything a search
+ * index carries.
+ */
+export declare const productListSortSchema: z.ZodEnum<{
+    name: "name";
+    price: "price";
+    relevance: "relevance";
+    "-createdAt": "-createdAt";
+    "-name": "-name";
+    "-price": "-price";
+}>;
+export type ProductListSort = z.infer<typeof productListSortSchema>;
+/** The two orderings feature 086 added, as a narrowing a consumer can reuse. */
+export declare function isPriceSort(sort: ProductListSort | undefined): sort is 'price' | '-price';
+export declare const productListQuerySchema: z.ZodObject<{
+    q: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    cursor: z.ZodOptional<z.ZodString>;
+    sort: z.ZodOptional<z.ZodEnum<{
+        name: "name";
+        price: "price";
+        relevance: "relevance";
+        "-createdAt": "-createdAt";
+        "-name": "-name";
+        "-price": "-price";
+    }>>;
+    changedSince: z.ZodOptional<z.ZodString>;
+    minPrice: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    maxPrice: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type ProductListQuery = z.infer<typeof productListQuerySchema>;
+/**
+ * What the listing surface may offer this viewer on this page — feature 086 /
+ * FR-023.
+ *
+ * It rides on the listing response because the storefront has to decide whether
+ * to *render* the price controls, and the answer depends on the viewer and the
+ * channel: a non-public channel publishes no prices, and
+ * `pricing.unauthenticated_display_mode = none` hides them until login. A
+ * storefront that guessed would guess wrong on exactly the deployments that
+ * care, and a control that offers an ordering the API refuses is a worse defect
+ * than no control.
+ *
+ * It is **not** on the filter-definitions endpoint, which is anonymous and
+ * shared (FR-010): a per-viewer answer may not travel on a response whose cache
+ * key omits the viewer.
+ */
+export declare const productListCapabilitiesSchema: z.ZodObject<{
+    priceOrdering: z.ZodBoolean;
+}, z.core.$strip>;
+export type ProductListCapabilities = z.infer<typeof productListCapabilitiesSchema>;
+export declare const notifyWhenAvailableRequestSchema: z.ZodObject<{
+    variantId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type NotifyWhenAvailableRequest = z.infer<typeof notifyWhenAvailableRequestSchema>;
+export declare const notifyWhenAvailableResponseSchema: z.ZodObject<{
+    subscriptionId: z.ZodString;
+    requestedAt: z.ZodString;
+}, z.core.$strip>;
+export type NotifyWhenAvailableResponse = z.infer<typeof notifyWhenAvailableResponseSchema>;
+export declare const attributeSetSchema: z.ZodObject<{
+    id: z.ZodString;
+    code: z.ZodString;
+    name: z.ZodRecord<z.ZodString, z.ZodString>;
+    description: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>;
+    isSystem: z.ZodBoolean;
+    attributeCount: z.ZodNumber;
+    productCount: z.ZodNumber;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type AttributeSet = z.infer<typeof attributeSetSchema>;
+export declare const attributeSetAssignedAttributeSchema: z.ZodObject<{
+    id: z.ZodString;
+    key: z.ZodString;
+    label: z.ZodRecord<z.ZodString, z.ZodString>;
+    valueType: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        date: "date";
+        enum: "enum";
+        select: "select";
+        price: "price";
+        multiselect: "multiselect";
+    }>;
+    position: z.ZodNumber;
+    languageScoped: z.ZodBoolean;
+}, z.core.$strip>;
+export type AttributeSetAssignedAttribute = z.infer<typeof attributeSetAssignedAttributeSchema>;
+export declare const attributeSetDetailSchema: z.ZodObject<{
+    id: z.ZodString;
+    code: z.ZodString;
+    name: z.ZodRecord<z.ZodString, z.ZodString>;
+    description: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>;
+    isSystem: z.ZodBoolean;
+    attributeCount: z.ZodNumber;
+    productCount: z.ZodNumber;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    attributes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        key: z.ZodString;
+        label: z.ZodRecord<z.ZodString, z.ZodString>;
+        valueType: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            date: "date";
+            enum: "enum";
+            select: "select";
+            price: "price";
+            multiselect: "multiselect";
+        }>;
+        position: z.ZodNumber;
+        languageScoped: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AttributeSetDetail = z.infer<typeof attributeSetDetailSchema>;
+export declare const createAttributeSetRequestSchema: z.ZodObject<{
+    code: z.ZodString;
+    name: z.ZodRecord<z.ZodString, z.ZodString>;
+    description: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    attributeIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type CreateAttributeSetRequest = z.infer<typeof createAttributeSetRequestSchema>;
+export declare const updateAttributeSetRequestSchema: z.ZodObject<{
+    code: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>>;
+}, z.core.$strict>;
+export type UpdateAttributeSetRequest = z.infer<typeof updateAttributeSetRequestSchema>;
+export declare const assignAttributesRequestSchema: z.ZodObject<{
+    assignments: z.ZodArray<z.ZodObject<{
+        attributeId: z.ZodString;
+        position: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+export type AssignAttributesRequest = z.infer<typeof assignAttributesRequestSchema>;
+export declare const galleryLabelSchema: z.ZodEnum<{
+    base_image: "base_image";
+    small_image: "small_image";
+    thumbnail: "thumbnail";
+}>;
+export type GalleryLabel = z.infer<typeof galleryLabelSchema>;
+export declare const galleryItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    productId: z.ZodString;
+    assetId: z.ZodString;
+    position: z.ZodNumber;
+    labels: z.ZodArray<z.ZodEnum<{
+        base_image: "base_image";
+        small_image: "small_image";
+        thumbnail: "thumbnail";
+    }>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type GalleryItem = z.infer<typeof galleryItemSchema>;
+export declare const createGalleryItemRequestSchema: z.ZodObject<{
+    assetId: z.ZodString;
+    position: z.ZodOptional<z.ZodNumber>;
+    labels: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        base_image: "base_image";
+        small_image: "small_image";
+        thumbnail: "thumbnail";
+    }>>>;
+}, z.core.$strict>;
+export type CreateGalleryItemRequest = z.infer<typeof createGalleryItemRequestSchema>;
+export declare const updateGalleryItemRequestSchema: z.ZodObject<{
+    position: z.ZodOptional<z.ZodNumber>;
+    labels: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        base_image: "base_image";
+        small_image: "small_image";
+        thumbnail: "thumbnail";
+    }>>>;
+}, z.core.$strict>;
+export type UpdateGalleryItemRequest = z.infer<typeof updateGalleryItemRequestSchema>;
+export declare const reorderGalleryRequestSchema: z.ZodObject<{
+    orderedGalleryItemIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type ReorderGalleryRequest = z.infer<typeof reorderGalleryRequestSchema>;
+export declare const attachmentTypeSchema: z.ZodObject<{
+    id: z.ZodString;
+    code: z.ZodString;
+    name: z.ZodRecord<z.ZodString, z.ZodString>;
+    position: z.ZodNumber;
+    usageCount: z.ZodNumber;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type AttachmentType = z.infer<typeof attachmentTypeSchema>;
+export declare const createAttachmentTypeRequestSchema: z.ZodObject<{
+    code: z.ZodString;
+    name: z.ZodRecord<z.ZodString, z.ZodString>;
+    position: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type CreateAttachmentTypeRequest = z.infer<typeof createAttachmentTypeRequestSchema>;
+export declare const updateAttachmentTypeRequestSchema: z.ZodObject<{
+    code: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    position: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type UpdateAttachmentTypeRequest = z.infer<typeof updateAttachmentTypeRequestSchema>;
+export declare const productAttachmentSchema: z.ZodObject<{
+    id: z.ZodString;
+    productId: z.ZodString;
+    assetId: z.ZodString;
+    attachmentTypeId: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    position: z.ZodNumber;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type ProductAttachment = z.infer<typeof productAttachmentSchema>;
+export declare const createAttachmentRequestSchema: z.ZodObject<{
+    assetId: z.ZodString;
+    attachmentTypeId: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    position: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type CreateAttachmentRequest = z.infer<typeof createAttachmentRequestSchema>;
+export declare const updateAttachmentRequestSchema: z.ZodObject<{
+    attachmentTypeId: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    position: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type UpdateAttachmentRequest = z.infer<typeof updateAttachmentRequestSchema>;
+/**
+ * A named ordering unit attached to a product (e.g. "Paleta" = 480 pieces).
+ * Managed in the Inventory section of the admin product card; surfaced on the
+ * storefront product page so buyers can order by the unit.
+ */
+export declare const packagingUnitSchema: z.ZodObject<{
+    id: z.ZodString;
+    productId: z.ZodString;
+    name: z.ZodString;
+    baseQuantity: z.ZodNumber;
+    position: z.ZodNumber;
+    isDefault: z.ZodBoolean;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type PackagingUnitDto = z.infer<typeof packagingUnitSchema>;
+export declare const createPackagingUnitRequestSchema: z.ZodObject<{
+    name: z.ZodString;
+    baseQuantity: z.ZodNumber;
+    isDefault: z.ZodOptional<z.ZodBoolean>;
+    position: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type CreatePackagingUnitRequest = z.infer<typeof createPackagingUnitRequestSchema>;
+export declare const updatePackagingUnitRequestSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    baseQuantity: z.ZodOptional<z.ZodNumber>;
+    isDefault: z.ZodOptional<z.ZodBoolean>;
+    position: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type UpdatePackagingUnitRequest = z.infer<typeof updatePackagingUnitRequestSchema>;
+export declare const reorderPackagingUnitsRequestSchema: z.ZodObject<{
+    orderedIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type ReorderPackagingUnitsRequest = z.infer<typeof reorderPackagingUnitsRequestSchema>;
+export declare const productLinkKindSchema: z.ZodEnum<{
+    related: "related";
+    up_sell: "up_sell";
+    cross_sell: "cross_sell";
+}>;
+export type ProductLinkKind = z.infer<typeof productLinkKindSchema>;
+export declare const productLinkSchema: z.ZodObject<{
+    id: z.ZodString;
+    sourceProductId: z.ZodString;
+    targetProductId: z.ZodString;
+    kind: z.ZodEnum<{
+        related: "related";
+        up_sell: "up_sell";
+        cross_sell: "cross_sell";
+    }>;
+    position: z.ZodNumber;
+}, z.core.$strip>;
+export type ProductLink = z.infer<typeof productLinkSchema>;
+/**
+ * Bulk-create payload (T104). One transaction, all-or-nothing —
+ * partial inserts on a duplicate or self-link MUST roll back the
+ * entire batch (FR + research). Each entry pins its kind so admins
+ * can submit a mixed batch in a single round trip.
+ */
+export declare const bulkCreateLinksRequestSchema: z.ZodObject<{
+    links: z.ZodArray<z.ZodObject<{
+        targetProductId: z.ZodString;
+        kind: z.ZodEnum<{
+            related: "related";
+            up_sell: "up_sell";
+            cross_sell: "cross_sell";
+        }>;
+        position: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type BulkCreateLinksRequest = z.infer<typeof bulkCreateLinksRequestSchema>;
+export declare const reorderLinksRequestSchema: z.ZodObject<{
+    linkIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type ReorderLinksRequest = z.infer<typeof reorderLinksRequestSchema>;
+/**
+ * Storefront-shape link entry (T107) — the listing carries enough Product
+ * fields for a card render without a follow-up fetch. Inactive targets
+ * are filtered out by `listForStorefront` so the storefront never sees
+ * `status='archived'` rows.
+ */
+export declare const groupedItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    parentProductId: z.ZodString;
+    childProductId: z.ZodString;
+    quantity: z.ZodNumber;
+    position: z.ZodNumber;
+}, z.core.$strip>;
+export type GroupedItem = z.infer<typeof groupedItemSchema>;
+export declare const createGroupedItemRequestSchema: z.ZodObject<{
+    childProductId: z.ZodString;
+    quantity: z.ZodNumber;
+    position: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type CreateGroupedItemRequest = z.infer<typeof createGroupedItemRequestSchema>;
+export declare const updateGroupedItemRequestSchema: z.ZodObject<{
+    quantity: z.ZodOptional<z.ZodNumber>;
+    position: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type UpdateGroupedItemRequest = z.infer<typeof updateGroupedItemRequestSchema>;
+export declare const bundleSlotOptionSchema: z.ZodObject<{
+    id: z.ZodString;
+    slotId: z.ZodString;
+    optionProductId: z.ZodString;
+    defaultQuantity: z.ZodNumber;
+    position: z.ZodNumber;
+}, z.core.$strip>;
+export type BundleSlotOption = z.infer<typeof bundleSlotOptionSchema>;
+export declare const bundleSlotSchema: z.ZodObject<{
+    id: z.ZodString;
+    parentProductId: z.ZodString;
+    name: z.ZodRecord<z.ZodString, z.ZodString>;
+    minQuantity: z.ZodNumber;
+    maxQuantity: z.ZodNumber;
+    position: z.ZodNumber;
+    options: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        slotId: z.ZodString;
+        optionProductId: z.ZodString;
+        defaultQuantity: z.ZodNumber;
+        position: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type BundleSlot = z.infer<typeof bundleSlotSchema>;
+export declare const createBundleSlotRequestSchema: z.ZodObject<{
+    name: z.ZodRecord<z.ZodString, z.ZodString>;
+    minQuantity: z.ZodOptional<z.ZodNumber>;
+    maxQuantity: z.ZodNumber;
+    position: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type CreateBundleSlotRequest = z.infer<typeof createBundleSlotRequestSchema>;
+export declare const updateBundleSlotRequestSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    minQuantity: z.ZodOptional<z.ZodNumber>;
+    maxQuantity: z.ZodOptional<z.ZodNumber>;
+    position: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type UpdateBundleSlotRequest = z.infer<typeof updateBundleSlotRequestSchema>;
+export declare const createBundleSlotOptionRequestSchema: z.ZodObject<{
+    optionProductId: z.ZodString;
+    defaultQuantity: z.ZodOptional<z.ZodNumber>;
+    position: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type CreateBundleSlotOptionRequest = z.infer<typeof createBundleSlotOptionRequestSchema>;
+/**
+ * Buyer's bundle configuration — what the storefront posts to the
+ * `/bundle-configuration/validate` endpoint. One selection per slot,
+ * referencing the chosen option's id and the buyer-picked quantity.
+ */
+export declare const bundleConfigurationSelectionSchema: z.ZodObject<{
+    slotId: z.ZodString;
+    optionId: z.ZodString;
+    quantity: z.ZodNumber;
+}, z.core.$strip>;
+export type BundleConfigurationSelection = z.infer<typeof bundleConfigurationSelectionSchema>;
+export declare const validateBundleConfigurationRequestSchema: z.ZodObject<{
+    selections: z.ZodArray<z.ZodObject<{
+        slotId: z.ZodString;
+        optionId: z.ZodString;
+        quantity: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+export type ValidateBundleConfigurationRequest = z.infer<typeof validateBundleConfigurationRequestSchema>;
+export declare const bundleValidationErrorSchema: z.ZodObject<{
+    code: z.ZodEnum<{
+        MIN_NOT_MET: "MIN_NOT_MET";
+        MAX_EXCEEDED: "MAX_EXCEEDED";
+        UNKNOWN_OPTION: "UNKNOWN_OPTION";
+    }>;
+    slotId: z.ZodOptional<z.ZodString>;
+    message: z.ZodString;
+}, z.core.$strip>;
+export type BundleValidationError = z.infer<typeof bundleValidationErrorSchema>;
+export declare const bundleValidationResultSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    errors: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            MIN_NOT_MET: "MIN_NOT_MET";
+            MAX_EXCEEDED: "MAX_EXCEEDED";
+            UNKNOWN_OPTION: "UNKNOWN_OPTION";
+        }>;
+        slotId: z.ZodOptional<z.ZodString>;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+    resolvedSelections: z.ZodArray<z.ZodObject<{
+        slotId: z.ZodString;
+        optionId: z.ZodString;
+        optionProductId: z.ZodString;
+        quantity: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type BundleValidationResult = z.infer<typeof bundleValidationResultSchema>;
+export declare const productLinkSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        related: "related";
+        up_sell: "up_sell";
+        cross_sell: "cross_sell";
+    }>;
+    position: z.ZodNumber;
+    product: z.ZodObject<{
+        id: z.ZodString;
+        sku: z.ZodString;
+        slug: z.ZodString;
+        name: z.ZodString;
+        primaryAssetUrl: z.ZodNullable<z.ZodString>;
+        price: z.ZodNullable<z.ZodObject<{
+            amount: z.ZodNumber;
+            currency: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ProductLinkSummary = z.infer<typeof productLinkSummarySchema>;
+/**
+ * A product as it crosses a module boundary — a plain shape, never the ORM
+ * entity (FR-011). Twenty modules read this row; between them they touch
+ * nearly every column, which is why the record mirrors the table rather than
+ * narrowing it. What it is not is the *class*: a consumer cannot call a method
+ * on it, cannot persist it, and cannot pull a relation off it.
+ */
+export interface CatalogProductRecord {
+    id: string;
+    sku: string;
+    slug: string;
+    type: ProductType;
+    status: ProductStatus;
+    /** Per-locale JSONB. Resolve with the caller's language chain. */
+    name: Record<string, string>;
+    description: Record<string, string>;
+    /** Per-product override of the global stock mode; `null` ⇒ inherit. */
+    stockMode: StockMode | null;
+    visibility: ProductVisibility;
+    /** JSONB `{ attributeKey: value }`, validated against the attribute set. */
+    attributeValues: Record<string, unknown>;
+    allowedOrganizationIds: string[];
+    attributeSetId: string;
+    downloadAssetId: string | null;
+    downloadUrl: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+    archivedAt: Date | null;
+    deletedAt: Date | null;
+    manageStock: boolean;
+    backorderEnabled: boolean;
+    lowStockThreshold: number | null;
+    lowStockThresholdMode: 'cumulative' | 'per_warehouse';
+    fulfilmentStrategy: FulfilmentStrategy | null;
+    fulfilmentStrategyWarehouseOrder: string[] | null;
+}
+/**
+ * Who is asking for a product — the single input every enforcing read path
+ * needs beyond the row itself (issue #227).
+ *
+ * Two fields rather than one, because `organizationId === null` conflates two
+ * callers that the `logged_in_only` visibility distinguishes: an anonymous
+ * crawler, and a signed-in buyer whose account carries no Organization (the
+ * guest-style Customer of feature 026). The first must not see a
+ * `logged_in_only` row; the second must.
+ *
+ * An `organizationId` is never asserted by the caller: it comes off the
+ * resolved actor — the customer session's Organization, or a bound API key's.
+ */
+export interface ProductAudience {
+    /**
+     * The asking buyer's Organization, or `null` when the caller has none.
+     * Matched against `allowed_organization_ids` by membership, never by
+     * prefix or by comparing the array to anything.
+     */
+    readonly organizationId: string | null;
+    /** `true` for any caller the platform has identified; `false` for the public. */
+    readonly authenticated: boolean;
+}
+/**
+ * The most restrictive audience there is. Anything it may see, every other
+ * audience may see too — which is what makes it the right default for a path
+ * that has not yet been taught to resolve its caller, and the right constant
+ * for a test that means "the public".
+ */
+export declare const ANONYMOUS_PRODUCT_AUDIENCE: ProductAudience;
+/**
+ * Does this audience get to see this product?
+ *
+ * **This is the platform's one answer.** `Product.visibility` and
+ * `Product.allowedOrganizationIds` have been persisted, defaulted and
+ * operator-editable since the foundation migration, and until issue #227 a
+ * single read path out of two dozen enforced them — `catalog`'s quick-search,
+ * repaired for issue #174 after a buyer's type-ahead disclosed products
+ * restricted to other organisations. Every other surface answered the question
+ * its own way or not at all, so the repair starts by making the question have
+ * one answer that a listing, a PDP, a search hit, a cart line, a comparison and
+ * a feed row can all reach.
+ *
+ * It lives in `@endora-commerce/contracts` rather than in `catalog` because the record it
+ * reads is already published here: twenty modules hold a
+ * {@link CatalogProductRecord}, both columns are on it, and a predicate over a
+ * published shape needs no port, no manifest edge and no `catalog` on the other
+ * end of a call. A module that holds the row can enforce; a module that cannot
+ * hold the row has nothing to enforce over.
+ *
+ * The rule, in the order it is decided:
+ *
+ *  1. **A non-empty `allowedOrganizationIds` decides alone**, and it restricts
+ *     whatever `visibility` says — `public` included. `public` with an
+ *     allow-list naming three organisations is a state an operator can save
+ *     today, and reading it as "public wins" discloses exactly the rows the
+ *     operator named someone else on.
+ *  2. Otherwise the allow-list is empty and the answer is `visibility`'s alone:
+ *     `public` to everybody; `logged_in_only` to any authenticated caller;
+ *     `organization_restricted` **to nobody**. That last one is the reading
+ *     that surprises: the restriction was asked for and names no organisation,
+ *     so the permissive reading of it would disclose the row to the whole
+ *     world.
+ *
+ * ## The two SQL restatements of this rule, and how they differ
+ *
+ * A predicate over a record cannot be pushed into a query, and two read paths
+ * must filter in SQL rather than after it. So `catalog` states this rule twice
+ * more, in SQL, and the two statements are **not** copies of each other — they
+ * answer for different audiences and are meant to differ (issue #262):
+ *
+ *  - **`catalog-quick-search.service.ts`** answers for a **signed-in buyer**.
+ *    `CatalogQuickSearchParams.organizationId` is required and there is no
+ *    anonymous spelling, so the audience is
+ *    `{ organizationId, authenticated: true }` by construction. It is the
+ *    restatement where `@>` containment over the JSONB array does real work:
+ *    the buyer's id has to be an *element* of the allow-list rather than a
+ *    substring of the serialised bag. It is SQL because the statement carries
+ *    a `limit`, and a post-filter would hand a buyer a short page — or an
+ *    empty one — while visible rows waited behind the restricted ones.
+ *  - **`catalog-product-filter.service.ts`'s `sellableFloor`** answers for
+ *    {@link ANONYMOUS_PRODUCT_AUDIENCE}, because the port's only consumer is a
+ *    product feed and a feed is read by Google. With no organisation to
+ *    contain, the containment branch can never match, so that restatement
+ *    collapses to two equalities — `visibility = 'public'` and an empty
+ *    allow-list. It is SQL because `countSellable` is the number an operator
+ *    is shown before saving and `listSellable` is what the next run emits, and
+ *    the two must be one query's answer.
+ *
+ * Neither is licensed to drift toward the other: the containment clause would
+ * be dead weight in the feed floor, and the two equalities would hide from a
+ * buyer every row his own organisation is named on. What keeps both honest is
+ * that each has a parity test which **derives** its expectation from this
+ * function over `productVisibilitySchema.options`, so a fourth visibility value
+ * forces every side to be decided rather than letting one keep an accidental
+ * default — this predicate falls through to `return true`, both SQL sites fail
+ * closed:
+ *
+ *  - `backend/test/integration/catalog/quick-search-audience-parity.test.ts`
+ *    — visibility × (empty, own org, another org, several including own,
+ *    a near-miss string) × three viewers;
+ *  - `backend/test/integration/catalog/product-filter-port.test.ts`
+ *    — visibility × (empty, non-empty) for the anonymous audience, on
+ *    `listSellable` and `countSellable` alike.
+ *
+ * `backend/test/unit/catalog/product-visibility-predicate.test.ts` is the truth
+ * table all three are read against.
+ *
+ * Unifying the three into one shared SQL fragment was considered and refused:
+ * the builder would have to live here, and a fragment knows table and column
+ * names — the persistence shape. This package knows API shapes and depends on
+ * `zod` alone (FR-034). Keeping that line is worth more than removing the
+ * duplication, so the duplication is kept and pinned instead.
+ *
+ * What this predicate is **not** is the channel answer. Channel scoping is
+ * Principle XII's, travels through `sales_channel_products` and the sanctioned
+ * bridge accessors, and is a second filter every buyer-facing path owes on top
+ * of this one.
+ *
+ * That second filter has two spellings and neither is here, by an owner ruling
+ * of 2026-08-21 (issue #259): the channel is a property of the **request**, not
+ * of the viewer's relationship to the product, so folding it in would merge two
+ * questions and make this predicate asynchronous. The **view** side spells it
+ * as `CatalogQueryService.filterByChannel`; the **acquisition** side — cart
+ * add, comparison add, a quote line, a saved list, a pasted quick-order SKU —
+ * spells it as `productIdsInRequestChannel` in
+ * `backend/src/kernel/sales-channels/request-channel-assortment.ts`. Every one
+ * of those refuses out-of-assortment with the *same* answer it gives a
+ * restricted row and an absent one, so the pair cannot be used to enumerate an
+ * operator's private assortment.
+ *
+ * **Two re-acquisition paths are exempt, by the same ruling**: `orders`'
+ * reorder and `quote_requests`' `convertToOrder`. Neither names a product the
+ * caller supplied — each rebuilds a cart from lines the buyer already holds a
+ * commitment on, a placed order or a quote the seller approved at agreed
+ * prices — and refusing would strand a buyer holding an approved quote they
+ * cannot act on. Read that as decided, not as the two seams that were missed;
+ * each carries the reason at its own call site, including the second-order
+ * consequence that makes the obvious repair of the first one wrong. Two
+ * operator surfaces are exempt on the operator's-permission ground instead:
+ * `RfqAdminService.createOnBehalf` and `quick_order`'s `'unrestricted'` import
+ * arm, both of which say so where they stand.
+ */
+export declare function isProductVisibleTo(product: Pick<CatalogProductRecord, 'visibility' | 'allowedOrganizationIds'>, audience: ProductAudience): boolean;
+/** A category row, as the eight modules that read one see it. */
+export interface CatalogCategoryRecord {
+    id: string;
+    parentCategoryId: string | null;
+    name: Record<string, string>;
+    slug: string;
+    sortOrder: number;
+    metaTitleOverride: Record<string, string> | null;
+    metaDescriptionOverride: Record<string, string> | null;
+    customFieldValues: Record<string, unknown>;
+    isActive: boolean;
+    inventoryThresholdHigh: number | null;
+    inventoryThresholdMedium: number | null;
+    inventoryThresholdLow: number | null;
+    mainImageAssetId: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+    deletedAt: Date | null;
+}
+/**
+ * One `product ↔ category` assignment, with the category's slug alongside.
+ *
+ * The slug rides on the row because every caller that reads assignments in
+ * bulk is building a projection keyed by product — a search document, a feed
+ * line — and would otherwise follow every assignment with a category lookup.
+ */
+export interface CatalogCategoryAssignmentRecord {
+    productId: string;
+    categoryId: string;
+    slug: string;
+}
+/** A configurable product's variant row. */
+export interface CatalogProductVariantRecord {
+    id: string;
+    parentProductId: string;
+    sku: string;
+    variantAttributeValues: Record<string, unknown>;
+    /** Decimal string, or `null` when the variant inherits the parent's price. */
+    priceOverride: string | null;
+    stockLevel: number | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+/** A packaging unit — "box of 12" — a cart line may be placed in. */
+export interface CatalogPackagingUnitRecord {
+    id: string;
+    productId: string;
+    name: string;
+    baseQuantity: number;
+    position: number;
+    isDefault: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+}
+/** A directed product↔product relation (cross-sell, up-sell, related). */
+export interface CatalogProductLinkRow {
+    id: string;
+    sourceProductId: string;
+    targetProductId: string;
+    kind: ProductLinkKind;
+    position: number;
+}
+/** A per-channel / per-language override of one attribute value (feature 022). */
+export interface CatalogProductValueOverrideRecord {
+    id: string;
+    productId: string;
+    attributeKey: string;
+    channelId: string;
+    languageCode: string | null;
+    /** The stored value, wrapped so `null` and "absent" stay distinguishable. */
+    value: {
+        v: unknown;
+    };
+}
+/**
+ * Which products a lookup should consider.
+ *
+ * `liveOnly` excludes soft-deleted rows and `activeOnly` narrows further to
+ * `status === 'active'`. Both default to `false`, which is the wider read —
+ * and the correct default, because an inactive or soft-deleted product still
+ * has to resolve from a historical order, invoice, RFQ or shopping list.
+ */
+export interface CatalogProductLookupOptions {
+    liveOnly?: boolean;
+    activeOnly?: boolean;
+}
+/**
+ * Container name: `catalogProductReadPort`. Owner: `catalog`.
+ *
+ * Forty-six of `catalog`'s inbound sites are a read of the `Product` entity,
+ * and they reduce to four questions: by id, by ids, by sku, by skus. The rest
+ * of this port is the three neighbouring tables the same callers reach for in
+ * the same breath — variants, packaging units and links — plus the value
+ * overrides the search indexer reads.
+ *
+ * When `catalog` is off every method fails closed, and that is the answer a
+ * cart or an order line should get: pricing a line for a product the platform
+ * will not read is worse than refusing the line.
+ *
+ * Whether `catalog` has an off state at all is its manifest's `activation` to
+ * say, not this line's: a module declaring `nonDeactivatable` never enters one.
+ */
+export interface CatalogProductReadPort {
+    findById(id: string, options?: CatalogProductLookupOptions): Promise<CatalogProductRecord | null>;
+    findByIds(ids: readonly string[], options?: CatalogProductLookupOptions): Promise<CatalogProductRecord[]>;
+    findBySku(sku: string, options?: CatalogProductLookupOptions): Promise<CatalogProductRecord | null>;
+    findBySkus(skus: readonly string[], options?: CatalogProductLookupOptions): Promise<CatalogProductRecord[]>;
+    /** `count === ids.length` existence check, without loading the rows. */
+    countByIds(ids: readonly string[]): Promise<number>;
+    /** Every product, ordered by sku — the bulk export and the price-list backfill. */
+    listAll(options?: CatalogProductLookupOptions): Promise<CatalogProductRecord[]>;
+    /** Variants of the given parent products, ordered by sku. */
+    listVariantsByProductIds(productIds: readonly string[]): Promise<CatalogProductVariantRecord[]>;
+    findVariantsBySkus(skus: readonly string[]): Promise<CatalogProductVariantRecord[]>;
+    /** A variant, but only if it belongs to that parent. */
+    findVariantInProduct(parentProductId: string, variantId: string): Promise<CatalogProductVariantRecord | null>;
+    /** A packaging unit, but only if it belongs to that product. */
+    findPackagingUnitInProduct(productId: string, packagingUnitId: string): Promise<CatalogPackagingUnitRecord | null>;
+    /** Links out of the given products, optionally narrowed to one kind. */
+    listLinksBySourceIds(sourceProductIds: readonly string[], kind?: ProductLinkKind): Promise<CatalogProductLinkRow[]>;
+    /** Attribute-value overrides for the given products. */
+    listValueOverridesByProductIds(productIds: readonly string[]): Promise<CatalogProductValueOverrideRecord[]>;
+}
+/**
+ * Container name: `catalogCategoryReadPort`. Owner: `catalog`.
+ *
+ * Fourteen inbound sites read the `Category` entity: the inventory threshold
+ * resolver walks it, `price_lists` walks the ancestor chain to resolve a
+ * category rule, `product_feeds` maps the whole tree onto an external
+ * taxonomy, `seo` renders a category page's meta tags.
+ *
+ * `ancestorsOf` is here rather than in `price_lists` because that module walks
+ * the chain with a `findOne` per level today — a loop over the parent pointer
+ * whose depth is data, in a module that does not own the table.
+ *
+ * **Owner off:** the seam fails closed — resolving this port throws
+ * `ModuleDisabledError` and the call answers 503 `MODULE_DISABLED`, so nothing
+ * half-executes. Whether `catalog` has an off state at all is its manifest's
+ * `activation` to say, not this line's: a module declaring
+ * `nonDeactivatable` never enters one.
+ */
+export interface CatalogCategoryReadPort {
+    findById(id: string, options?: {
+        liveOnly?: boolean;
+    }): Promise<CatalogCategoryRecord | null>;
+    findByIds(ids: readonly string[], options?: {
+        liveOnly?: boolean;
+    }): Promise<CatalogCategoryRecord[]>;
+    findBySlug(slug: string): Promise<CatalogCategoryRecord | null>;
+    /** `count === ids.length` existence check. */
+    countByIds(ids: readonly string[]): Promise<number>;
+    /** The whole tree, ordered by sort order then slug. */
+    listAll(options?: {
+        liveOnly?: boolean;
+    }): Promise<CatalogCategoryRecord[]>;
+    /** Categories carrying at least one inventory threshold override. */
+    listWithInventoryThresholds(): Promise<CatalogCategoryRecord[]>;
+    /**
+     * The category and its ancestors, nearest-first. Empty when the id does not
+     * resolve. A cycle is impossible — the write path enforces it — but the walk
+     * is bounded anyway, because a corrupt `parent_id` should not hang a request.
+     */
+    ancestorsOf(categoryId: string): Promise<CatalogCategoryRecord[]>;
+    /**
+     * The category assignments of the given products (feature 075 / D-87).
+     *
+     * `product_categories` is a `catalog` table with no entity class, so the two
+     * modules that needed it joined it in raw SQL — a boundary crossing that
+     * names no import specifier and therefore compiled, gated by nothing.
+     *
+     * `activeOnly` drops assignments to a deactivated category. That is the
+     * narrowing a customer-facing projection wants and the reason the option
+     * exists rather than a hidden filter: an inactive category left in a search
+     * document keeps working as a storefront PLP filter.
+     */
+    listAssignmentsForProducts(productIds: readonly string[], options?: {
+        activeOnly?: boolean;
+    }): Promise<CatalogCategoryAssignmentRecord[]>;
+    /**
+     * Distinct ids of the products assigned to `categoryId` or to any category
+     * below it.
+     *
+     * The walk is **structural**: it filters neither `isActive` nor `deletedAt`.
+     * The caller is re-projecting a subtree because a category just changed, and
+     * the change that matters most is a deactivation — narrowing to live rows
+     * would return nothing exactly when the stale projections need rewriting.
+     * A caller that wants the live set narrows the rows it gets back.
+     */
+    listProductIdsInSubtree(categoryId: string): Promise<string[]>;
+    /**
+     * Ids of the products assigned to `categoryId` itself — not to anything below
+     * it (feature 075 / D-87).
+     *
+     * The narrow sibling of {@link listProductIdsInSubtree}, and the two are not
+     * interchangeable: a caller detaching products because one category left the
+     * source tree must touch that category's own assignments and no descendant's,
+     * because a descendant that is still mapped keeps its products.
+     *
+     * **Structural**, like the subtree walk: it filters neither `isActive` nor
+     * `deletedAt`. The assignment is the fact being asked about, and a caller
+     * removing one wants it gone whatever state the product is in.
+     */
+    listProductIdsInCategory(categoryId: string): Promise<string[]>;
+    /**
+     * Product ids assigned to each requested category **or to any live category
+     * below it**, keyed by the requested id. Every id asked for is present, with
+     * an empty set when nothing matches — so a criterion naming a deleted
+     * category narrows to nothing rather than silently disappearing.
+     *
+     * **Not a batched {@link listProductIdsInSubtree}, and the two are not
+     * interchangeable.** That one is structural, for a caller re-projecting
+     * because a category changed. This one is a *selection*: the descendant walk
+     * skips soft-deleted categories, because a rule that says "everything under
+     * Footwear" must not keep publishing the products of a branch an operator
+     * deleted. It is also **cycle-tolerant** — the walk carries a visited set per
+     * root — where the structural read is a recursive CTE with no guard. The
+     * write path forbids a cycle in `parent_category_id`; its guard is written to
+     * tolerate a *pre-existing* one, so corrupt data is reachable here, and a
+     * caller that assembled this from the structural read would hang.
+     *
+     * No channel scoping: the caller applies its own eligibility floor, which for
+     * a feed is stricter than the storefront's.
+     *
+     * `product_feeds`' criteria compiler is the requirement (FR-025) — it must
+     * evaluate category membership including descendants without learning the
+     * shape of `product_categories` or of the tree. It reached this through a
+     * composition root's closure over an unpublished container name until
+     * `specs/110-instance-repository/` T118c.
+     */
+    expandCategoryProductIds(categoryIds: readonly string[]): Promise<Map<string, Set<string>>>;
+    /**
+     * How many **live** products sit in each of `categoryIds` — one grouped read,
+     * not a count per id (feature 075 / D-87).
+     *
+     * Live means not soft-deleted: a deleted product is not in the category any
+     * more in any sense an operator means, which is the filter the caller this
+     * replaced had written into its own join. Categories with no live product are
+     * omitted rather than returned as zero, so the caller decides what an absent
+     * count renders as.
+     */
+    countLiveProductsByCategory(categoryIds: readonly string[]): Promise<CatalogCategoryProductCount[]>;
+}
+/** One category's live product count — see `countLiveProductsByCategory`. */
+export interface CatalogCategoryProductCount {
+    categoryId: string;
+    productCount: number;
+}
+/**
+ * One row of a categories import.
+ *
+ * Absent fields are left unchanged on an existing row; `parentSlug: null` means
+ * root. `slug` addresses the row: a slug that exists is updated, one that does
+ * not is created, and a slug introduced earlier in the same call resolves as a
+ * parent for a later one.
+ */
+export interface CategoryImportRow {
+    slug: string;
+    parentSlug?: string | null;
+    sortOrder?: number;
+    /** Per-locale, merged into the stored JSONB rather than replacing it. */
+    name?: Record<string, string>;
+    isActive?: boolean;
+}
+/**
+ * One row of a products import.
+ *
+ * `sku` addresses an existing product; the import creates none, because a
+ * product needs an attribute set, a type and a slug that a flat sheet does not
+ * carry.
+ */
+export interface ProductImportRow {
+    sku: string;
+    status?: ProductStatus;
+    visibility?: ProductVisibility;
+    /** Per-locale, merged into the stored JSONB rather than replacing it. */
+    name?: Record<string, string>;
+    description?: Record<string, string>;
+}
+/**
+ * Container name: `catalogBulkImportPort`. Owner: `catalog`.
+ *
+ * All-or-nothing per call: one transaction, one audit row, no partial commits.
+ * A rejected row leaves the whole call applying nothing, which is what makes a
+ * corrected re-upload safe — see {@link BulkImportReport}.
+ *
+ * With `catalog` off the call answers 503 `MODULE_DISABLED`; the caller is
+ * expected to decide presence before offering the surface at all.
+ *
+ * Whether `catalog` has an off state at all is its manifest's `activation` to
+ * say, not this line's: a module declaring `nonDeactivatable` never enters one.
+ */
+export interface CatalogBulkImportPort {
+    importCategories(rows: readonly CategoryImportRow[]): Promise<BulkImportReport>;
+    importProducts(rows: readonly ProductImportRow[]): Promise<BulkImportReport>;
+}
+export interface CatalogAttributeOptionView {
+    /** `custom_field_options` id. */
+    id: string;
+    value: string;
+    label: Record<string, string>;
+    labelDefault: string;
+    isDefault: boolean;
+    sortOrder: number;
+    createdAt: Date;
+    updatedAt: Date;
+}
+/**
+ * The composed attribute view (feature 061,
+ * `contracts/catalog-attribute-view.md`): the `custom_fields` definition and
+ * the `product_attributes` extension row, joined, shaped like the pre-061
+ * `ProductAttribute` so consumer rewires stay mechanical.
+ */
+export interface CatalogAttributeView {
+    /** Extension row id — the id the admin API has always exposed. */
+    id: string;
+    /** Backing `custom_field_definitions` id (host `product`). */
+    customFieldDefinitionId: string;
+    key: string;
+    label: Record<string, string>;
+    labelDefault: string;
+    /** Legacy 8-value form, derived bijectively (feature 061 research §R7). */
+    valueType: AttributeValueType;
+    isRequired: boolean;
+    options: CatalogAttributeOptionView[];
+    isSearchable: boolean;
+    isFilterable: boolean;
+    isVariantAxis: boolean;
+    displayAsSlider: boolean;
+    isComparable: boolean;
+    quickSearchable: boolean;
+    isPromoRule: boolean;
+    filterPosition: number;
+    isVisibleOnProductPage: boolean;
+    channelScoped: boolean;
+    languageScoped: boolean;
+    massEditable: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export type CatalogAttributeFlag = 'isSearchable' | 'isFilterable' | 'isVariantAxis' | 'isComparable' | 'quickSearchable' | 'isPromoRule' | 'massEditable' | 'isVisibleOnProductPage';
+/**
+ * Container name: `catalogAttributeReadPort`. Owner: `catalog`.
+ *
+ * The **only** sanctioned way any module — including `catalog`'s own route
+ * serializers — reads product-attribute definitions (Principle I). `search`,
+ * `comparisons`, `quick_order` and `pim_ergonode` all read it today by
+ * importing the class.
+ *
+ * Freshness: the definitions half rides the custom-fields cache (invalidated
+ * by every committed attribute Command, 5 s TTL fallback); the extension half
+ * is a live query, so flag reads are always fresh.
+ *
+ * **Owner off:** the seam fails closed — resolving this port throws
+ * `ModuleDisabledError` and the call answers 503 `MODULE_DISABLED`, so nothing
+ * half-executes. Whether `catalog` has an off state at all is its manifest's
+ * `activation` to say, not this line's: a module declaring
+ * `nonDeactivatable` never enters one.
+ */
+export interface CatalogAttributeReadPort {
+    listAll(): Promise<CatalogAttributeView[]>;
+    getByIdOrKey(idOrKey: string): Promise<CatalogAttributeView | null>;
+    listByFlag(flag: CatalogAttributeFlag): Promise<CatalogAttributeView[]>;
+    /** `attributeKey → optionValue → labels`, for label resolution on read. */
+    optionLabelIndex(): Promise<Map<string, Map<string, CatalogAttributeOptionLabels>>>;
+}
+/** The two label forms an option carries: per-locale, and the fallback. */
+export interface CatalogAttributeOptionLabels {
+    label: Record<string, string>;
+    labelDefault: string;
+}
+/** Which of the three quick-search predicates a hit satisfied. */
+export type CatalogQuickSearchField = 'sku' | 'name' | 'attribute';
+export interface CatalogQuickSearchParams {
+    /** The raw needle. Matched case-insensitively, as a substring. */
+    q: string;
+    limit: number;
+    /**
+     * The channel the caller resolved for this request. Required, and there is
+     * no "all channels" spelling: a channel is always resolved (feature 053), so
+     * an optional parameter here could only mean "the caller forgot", and the
+     * answer to that must not be the cross-channel catalogue.
+     */
+    salesChannelId: string;
+    /**
+     * The organisation the buyer is shopping on behalf of. Required, and — like
+     * `salesChannelId` — there is no anonymous spelling: every transacting
+     * customer has an Organization (Constitution XI), and the alternative to
+     * requiring one is a caller that forgets and gets the unrestricted
+     * catalogue. A surface with no signed-in buyer must not call this port.
+     *
+     * See {@link CatalogQuickSearchPort} for what it restricts.
+     */
+    organizationId: string;
+}
+export interface CatalogQuickSearchHit {
+    productId: string;
+    sku: string;
+    slug: string;
+    /** Per-locale JSONB as stored — the caller picks its own language. */
+    name: Record<string, string>;
+    status: ProductStatus;
+    matchedOn: CatalogQuickSearchField[];
+}
+/**
+ * Container name: `catalogQuickSearchPort`. Owner: `catalog`.
+ *
+ * The buyer-facing type-ahead behind `quick_order`'s CSV-free entry path
+ * (feature 039 FR-011/FR-013), published here because the predicate is a
+ * catalogue question in every part: which products are active, which are
+ * visible on the channel being shopped, and which attribute values are
+ * searchable at all — the last decided by the `quickSearchable` flag this
+ * module owns, over the `attribute_values` JSONB layout this module owns.
+ *
+ * It exists because `quick_order` was answering it with a hand-written knex
+ * `select` against `products`, which filtered `status = 'active'` and nothing
+ * else (issue #174). No import specifier, so `check:module-boundary` read
+ * clean; and no channel predicate, so a signed-in buyer's type-ahead returned
+ * every active product on the platform whatever channel they were shopping —
+ * Constitution XII, in the one place no static check was looking.
+ *
+ * ## What it restricts, and how strictly
+ *
+ * Channel scoping is the same `sales_channel_products` membership filter this
+ * module's own public listing applies, and it fails closed to the empty set.
+ *
+ * `visibility` and `allowed_organization_ids` are applied too, on the
+ * **restrictive** reading of both columns. A row is disclosed when
+ *
+ *   - the buyer's `organizationId` appears in `allowed_organization_ids`; or
+ *   - `allowed_organization_ids` is empty **and** `visibility` is not
+ *     `organization_restricted`.
+ *
+ * Two consequences are deliberate. A non-empty allow-list restricts **whatever
+ * the `visibility` column says** — `public` with an allow-list naming three
+ * organisations is a state an operator can save today, and reading it as
+ * "public wins" would let a type-ahead disclose exactly the rows the operator
+ * named someone else on. And `organization_restricted` with an **empty**
+ * allow-list is visible to nobody, rather than to everybody.
+ * `logged_in_only` *is* disclosed, because `organizationId` is required: there
+ * is no caller of this port that is not a signed-in buyer.
+ *
+ * A looser reading would differ on precisely those two rows, and only there.
+ *
+ * This is stricter than the rest of the module, and knowingly so. No other read
+ * path in `catalog` enforces either column (the standing platform-wide gap),
+ * but this surface requires a signed-in buyer, discloses SKU, slug and name for
+ * every hit, and hands back an id that `POST /quick-order/build` accepts — so a
+ * restriction an operator set on the product would otherwise be bypassed by
+ * typing three characters. Closing the gap on the remaining surfaces is its own
+ * change; leaving this one open until then is not the safe half of the choice.
+ *
+ * When `catalog` is off the call fails closed: `quick_order` declares `catalog`
+ * in `dependencies`, and a type-ahead that cannot ask the catalogue has nothing
+ * true to answer.
+ *
+ * Whether `catalog` has an off state at all is its manifest's `activation` to
+ * say, not this line's: a module declaring `nonDeactivatable` never enters one.
+ */
+export interface CatalogQuickSearchPort {
+    quickSearch(params: CatalogQuickSearchParams): Promise<CatalogQuickSearchHit[]>;
+}
+/**
+ * Scope flags for the **system** product attributes — the ones that are not
+ * rows in `product_attributes` and therefore carry no DB-stored scope flags.
+ *
+ * Published as a **constant, not a port** (FR-013): `name` and `description`
+ * are channel- and language-scoped because the product table stores them as
+ * per-locale JSONB, which is a fact about the schema rather than about whether
+ * a module is switched on. `search`'s indexer reads it to decide which
+ * overrides to resolve.
+ *
+ * Adding another system attribute is a one-line change here plus a resolver
+ * consumer. The reserved keys MUST NOT collide with `product_attributes.key`
+ * — enforced at write time by the override-service validator.
+ */
+export declare const SYSTEM_ATTRIBUTE_SCOPES: Readonly<Record<string, AttributeScope>>;
+export type SystemAttributeKey = keyof typeof SYSTEM_ATTRIBUTE_SCOPES;
+export declare function isSystemAttributeKey(key: string): key is SystemAttributeKey;
+/**
+ * Resolve the effective scope of an attribute given its key and (for
+ * user-defined attributes) its scope flags. Returns the system-pinned scope
+ * when the key is reserved; falls back to the row's flags otherwise; returns
+ * `{ false, false }` when neither applies (the caller should treat that as
+ * global-only).
+ */
+export declare function getAttributeScope(attributeKey: string, productAttributeRow?: {
+    channelScoped: boolean;
+    languageScoped: boolean;
+} | null): AttributeScope;
+/** Optional metadata attaching an audit entry to an admin mutation. */
+export interface CatalogAdminAuditContext {
+    actorAdminUserId: string;
+    impersonatedCustomerAccountId?: string | null;
+    ipAddress?: string | null;
+    userAgent?: string | null;
+    requestId?: string | null;
+}
+/**
+ * An attribute option as the write path returns it.
+ *
+ * Distinct from `AttributeOption`, the API DTO above, on one axis: the two
+ * timestamps are `Date`, not an ISO string. That is what an in-process call
+ * hands back, and serialising them here would mean every consumer parsing them
+ * again.
+ */
+export interface CatalogAttributeOptionResult {
+    id: string;
+    attributeId: string;
+    value: string;
+    label: Record<string, string>;
+    labelDefault: string;
+    isDefault: boolean;
+    sortOrder: number;
+    createdAt: Date;
+    updatedAt: Date;
+}
+/** The eight flags `listAttributesByFlag` accepts — a superset of the read model's. */
+export type CatalogAdminAttributeFlag = 'isSearchable' | 'isFilterable' | 'isComparable' | 'isVariantAxis' | 'isPromoRule' | 'isVisibleOnProductPage' | 'isRequired' | 'isMassEditable';
+/**
+ * Container name: `catalogProductWritePort`. Owner: `catalog`.
+ *
+ * `pim_ergonode` is the only consumer, and it is the whole reason this port is
+ * narrow: an import run creates and updates products, attributes and variants,
+ * and touches nothing else on `CatalogAdminService`'s considerable surface.
+ *
+ * `createProduct` and the two variant writes return **records**, where the
+ * service returns entities. That substitution is the point of the port.
+ *
+ * **Owner off:** the seam fails closed — resolving this port throws
+ * `ModuleDisabledError` and the call answers 503 `MODULE_DISABLED`, so nothing
+ * half-executes. Whether `catalog` has an off state at all is its manifest's
+ * `activation` to say, not this line's: a module declaring
+ * `nonDeactivatable` never enters one.
+ */
+export interface CatalogProductWritePort {
+    createProduct(req: CreateProductRequest, auditCtx?: CatalogAdminAuditContext): Promise<CatalogProductRecord>;
+    updateProduct(id: string, req: UpdateProductRequest): Promise<CatalogProductRecord>;
+    listAttributes(): Promise<CatalogAttributeView[]>;
+    listAttributesByFlag(flag: CatalogAdminAttributeFlag): Promise<CatalogAttributeView[]>;
+    createAttribute(req: CreateAttributeRequest): Promise<CatalogAttributeView>;
+    updateAttributeByIdOrKey(idOrKey: string, req: UpdateAttributeRequest, auditCtx?: CatalogAdminAuditContext): Promise<CatalogAttributeView>;
+    addAttributeOption(attributeIdOrKey: string, input: {
+        value: string;
+        label?: Record<string, string>;
+        labelDefault: string;
+        isDefault?: boolean;
+        sortOrder?: number;
+    }): Promise<CatalogAttributeOptionResult>;
+    patchAttributeOption(optionId: string, input: {
+        label?: Record<string, string>;
+        labelDefault?: string;
+        isDefault?: boolean;
+        sortOrder?: number;
+    }): Promise<CatalogAttributeOptionResult>;
+    createVariant(parentProductId: string, req: CreateVariantRequest): Promise<CatalogProductVariantRecord>;
+    updateVariant(parentProductId: string, variantId: string, req: UpdateVariantRequest): Promise<CatalogProductVariantRecord>;
+    deleteVariant(parentProductId: string, variantId: string): Promise<void>;
+}
+/**
+ * One channel/language override upsert — feature 022 / product-scope-overrides.
+ * Used by PIM importers (feature 089) to land channel-locale-scoped names and
+ * descriptions without reaching `product_value_overrides` directly (Principle XII).
+ */
+export interface CatalogProductValueOverrideUpsert {
+    attributeKey: string;
+    channelId: string;
+    languageCode: string | null;
+    value: {
+        v: unknown;
+    };
+}
+/**
+ * Container name: `catalogProductValueOverrideWritePort`. Owner: `catalog`.
+ *
+ * Bulk upsert of per-channel / per-language product attribute overrides. The
+ * only consumer today is `pim_unopim` (feature 089 / FR-023); the admin SPA
+ * still goes through `ProductOverridesService` inside catalog's own routes.
+ *
+ * **Owner off:** resolving this port throws `ModuleDisabledError` (503).
+ */
+export interface CatalogProductValueOverrideWritePort {
+    applyBulk(productId: string, input: {
+        upserts: readonly CatalogProductValueOverrideUpsert[];
+    }): Promise<void>;
+}
+/** The patch `updateCategory` accepts. Absent keys are left alone. */
+export interface UpdateCategoryInput {
+    parentCategoryId?: string | null;
+    name?: Record<string, string>;
+    slug?: string;
+    sortOrder?: number;
+    /** Feature 013 / US5 — library asset rendered as the storefront main image. */
+    mainImageAssetId?: string | null;
+    /** Feature 055 — validated and merged against the definitions on write. */
+    customFieldValues?: Record<string, unknown>;
+    /**
+     * Feature 068 — activation switch. `false` hides the category from every
+     * customer-facing read while the admin tree keeps listing it.
+     */
+    isActive?: boolean;
+}
+/**
+ * The three display-band thresholds a category may override. Absent keys are
+ * left alone; an explicit `null` clears the override.
+ */
+export interface CategoryInventoryThresholdPatch {
+    high?: number | null;
+    medium?: number | null;
+    low?: number | null;
+}
+/**
+ * Container name: `catalogCategoryWritePort`. Owner: `catalog`.
+ *
+ * `pim_ergonode` again, and again narrow: an import run lists the tree,
+ * creates the categories it is missing and updates the ones that moved.
+ *
+ * `setInventoryThresholds` is the fourth method and belongs to a different
+ * consumer: `inventory` stores the per-category half of its display-band
+ * thresholds in three columns on this module's `categories` table, and wrote
+ * them by holding the entity. It is deliberately **not** a key on
+ * {@link UpdateCategoryInput}: `update` runs the `category.update` Command,
+ * emits the search-reindex event and writes an audit row, none of which a
+ * threshold patch did or should — `inventory` records one
+ * `low_stock_threshold.update` summary row for the whole patch, and an
+ * operator reading a category's history should not find a rename-shaped entry
+ * for it. The columns' owner is still the question underneath, and the answer
+ * that retires this method is moving them into `inventory_thresholds` with
+ * `scopeKind = 'category'`, which is a data migration and not a cut.
+ *
+ * **Owner off:** the seam fails closed — resolving this port throws
+ * `ModuleDisabledError` and the call answers 503 `MODULE_DISABLED`, so nothing
+ * half-executes. Whether `catalog` has an off state at all is its manifest's
+ * `activation` to say, not this line's: a module declaring
+ * `nonDeactivatable` never enters one.
+ */
+export interface CatalogCategoryWritePort {
+    listAll(): Promise<CatalogCategoryRecord[]>;
+    create(input: CreateCategoryRequest): Promise<CatalogCategoryRecord>;
+    update(id: string, input: UpdateCategoryInput): Promise<CatalogCategoryRecord>;
+    /** Rejects an unknown or soft-deleted category with 404 `NOT_FOUND`. */
+    setInventoryThresholds(id: string, patch: CategoryInventoryThresholdPatch): Promise<void>;
+}
+/**
+ * Container name: `attributeSetService`. Owner: `catalog`.
+ *
+ * Already returns contract DTOs, so the port is the four methods
+ * `pim_ergonode` calls and nothing else.
+ *
+ * **Owner off:** the seam fails closed — resolving this port throws
+ * `ModuleDisabledError` and the call answers 503 `MODULE_DISABLED`, so nothing
+ * half-executes. Whether `catalog` has an off state at all is its manifest's
+ * `activation` to say, not this line's: a module declaring
+ * `nonDeactivatable` never enters one.
+ */
+export interface CatalogAttributeSetPort {
+    listSets(): Promise<AttributeSet[]>;
+    getSetDetail(id: string): Promise<AttributeSetDetail>;
+    createSet(input: CreateAttributeSetRequest): Promise<AttributeSetDetail>;
+    assignAttributes(id: string, input: AssignAttributesRequest): Promise<AttributeSetDetail>;
+}
+/**
+ * Container name: `attachmentService`. Owner: `catalog`.
+ *
+ * **Owner off:** the seam fails closed — resolving this port throws
+ * `ModuleDisabledError` and the call answers 503 `MODULE_DISABLED`, so nothing
+ * half-executes. Whether `catalog` has an off state at all is its manifest's
+ * `activation` to say, not this line's: a module declaring
+ * `nonDeactivatable` never enters one.
+ */
+export interface CatalogAttachmentPort {
+    listTypes(): Promise<AttachmentType[]>;
+    createType(req: CreateAttachmentTypeRequest): Promise<AttachmentType>;
+    listAttachments(productId: string): Promise<ProductAttachment[]>;
+    createAttachment(productId: string, req: CreateAttachmentRequest): Promise<ProductAttachment>;
+    updateAttachment(productId: string, attachmentId: string, req: UpdateAttachmentRequest): Promise<ProductAttachment>;
+    deleteAttachment(productId: string, attachmentId: string): Promise<void>;
+}
+/** Whether a gallery write may silently move a conflicting label off another item. */
+export interface CatalogGalleryWriteOptions {
+    replaceConflictingLabels: boolean;
+}
+/**
+ * One gallery item of a batch read, flattened to the three fields a caller
+ * outside `catalog` builds an image list from: which product it belongs to,
+ * which asset it points at, and where it sits in the operator's order.
+ *
+ * Deliberately not `GalleryItem`. The batch read exists for callers that walk a
+ * page — or a whole sellable catalogue — and the label set, the timestamps and
+ * the item id are all rows or columns those callers do not read; carrying them
+ * would cost a second statement per batch for a field nobody looks at.
+ */
+export interface CatalogGalleryBatchItem {
+    productId: string;
+    assetId: string;
+    position: number;
+}
+/**
+ * Container name: `galleryService`. Owner: `catalog`.
+ *
+ * **Owner off:** the seam fails closed — resolving this port throws
+ * `ModuleDisabledError` and the call answers 503 `MODULE_DISABLED`, so nothing
+ * half-executes. Whether `catalog` has an off state at all is its manifest's
+ * `activation` to say, not this line's: a module declaring
+ * `nonDeactivatable` never enters one.
+ */
+export interface CatalogGalleryPort {
+    list(productId: string): Promise<GalleryItem[]>;
+    /**
+     * The gallery items of a **batch** of products, ordered by product and then
+     * by the operator's position, in one statement.
+     *
+     * `list` cannot serve this caller and it is not a matter of taste: it takes a
+     * single product, verifies it exists, and then runs two more queries, so a
+     * page of 500 products costs 1500 round-trips where this costs one. That is
+     * what kept a raw `select … from gallery_items` inside `product_feeds` — a
+     * boundary crossing that names no import specifier and so compiled (feature
+     * 075 / D-87).
+     *
+     * **A product id that resolves to nothing is data, not an error.** No row
+     * comes back for it and the method does not throw: a caller holding an id
+     * whose product has since been removed asks about the batch it has, not about
+     * the batch it wishes it had. The two absences — "this product has an empty
+     * gallery" and "this product is gone" — are therefore not distinguished here,
+     * because both consumers render them identically (no image) and telling them
+     * apart would need exactly the product-existence probe that makes `list`
+     * unusable for a batch.
+     */
+    listForProducts(productIds: readonly string[]): Promise<CatalogGalleryBatchItem[]>;
+    /**
+     * The `base_image` url of each of a batch of products — `base_image` only,
+     * with no fallback to `thumbnail` or to the first item by position.
+     *
+     * The returned map holds **one entry per requested id**, `null` where this
+     * module has no `base_image` for it: the product carries no such label, the
+     * product is gone, or the asset row behind the label no longer resolves. A
+     * caller that renders a placeholder for all three (both of today's do) reads
+     * one branch; the map's key set answering the request exactly is what lets it
+     * index without re-checking membership.
+     *
+     * `catalog` answers this from its own `gallery_item_labels` and
+     * `gallery_items` plus the asset read port it already holds, so a consumer
+     * gets the url without joining `assets_library`'s table itself — which is the
+     * third of the three reaches this method retires (feature 075 / D-87).
+     */
+    baseImageUrls(productIds: readonly string[]): Promise<Map<string, string | null>>;
+    create(productId: string, req: CreateGalleryItemRequest, options: CatalogGalleryWriteOptions): Promise<GalleryItem>;
+    delete(productId: string, itemId: string): Promise<void>;
+    reorder(productId: string, orderedIds: string[]): Promise<void>;
+}
+/** One child line of a grouped product. */
+export interface CatalogGroupedItemRow {
+    id: string;
+    parentProductId: string;
+    childProductId: string;
+    quantity: number;
+    position: number;
+}
+/**
+ * Container name: `groupedService`. Owner: `catalog`.
+ *
+ * **Owner off:** the seam fails closed — resolving this port throws
+ * `ModuleDisabledError` and the call answers 503 `MODULE_DISABLED`, so nothing
+ * half-executes. Whether `catalog` has an off state at all is its manifest's
+ * `activation` to say, not this line's: a module declaring
+ * `nonDeactivatable` never enters one.
+ */
+export interface CatalogGroupedPort {
+    list(parentProductId: string): Promise<CatalogGroupedItemRow[]>;
+    addItem(parentProductId: string, input: {
+        childProductId: string;
+        quantity: number;
+        position?: number | undefined;
+    }): Promise<CatalogGroupedItemRow>;
+    updateItem(parentProductId: string, itemId: string, input: {
+        quantity?: number | undefined;
+        position?: number | undefined;
+    }): Promise<CatalogGroupedItemRow>;
+    removeItem(parentProductId: string, itemId: string): Promise<void>;
+}
+/** A link to create, as the bulk writer takes it. */
+export interface CatalogCreateProductLinkInput {
+    targetProductId: string;
+    kind: ProductLinkKind;
+    position?: number | undefined;
+}
+/**
+ * Container name: `productLinkService`. Owner: `catalog`.
+ *
+ * **Owner off:** the seam fails closed — resolving this port throws
+ * `ModuleDisabledError` and the call answers 503 `MODULE_DISABLED`, so nothing
+ * half-executes. Whether `catalog` has an off state at all is its manifest's
+ * `activation` to say, not this line's: a module declaring
+ * `nonDeactivatable` never enters one.
+ */
+export interface CatalogProductLinkPort {
+    listForAdmin(sourceProductId: string, kind?: ProductLinkKind): Promise<CatalogProductLinkRow[]>;
+    bulkCreate(sourceProductId: string, inputs: CatalogCreateProductLinkInput[]): Promise<CatalogProductLinkRow[]>;
+    removeLink(sourceProductId: string, linkId: string): Promise<void>;
+}
+/** One option inside a bundle slot, as the admin CRUD surface returns it. */
+export interface CatalogBundleSlotOptionRow {
+    id: string;
+    slotId: string;
+    optionProductId: string;
+    defaultQuantity: number;
+    position: number;
+}
+/** One bundle slot with its options. */
+export interface CatalogBundleSlotRow {
+    id: string;
+    parentProductId: string;
+    name: Record<string, string>;
+    minQuantity: number;
+    maxQuantity: number;
+    position: number;
+    options: CatalogBundleSlotOptionRow[];
+}
+/**
+ * Container name: `bundleService`. Owner: `catalog`.
+ *
+ * `pim_pimcore` writes mappable bundle compositions through this seam
+ * (feature 089 / FR-022) — never against catalog's tables.
+ */
+export interface CatalogBundlePort {
+    listSlots(parentProductId: string): Promise<CatalogBundleSlotRow[]>;
+    createSlot(parentProductId: string, input: {
+        name: Record<string, string>;
+        minQuantity?: number | undefined;
+        maxQuantity: number;
+        position?: number | undefined;
+    }): Promise<CatalogBundleSlotRow>;
+    updateSlot(parentProductId: string, slotId: string, input: {
+        name?: Record<string, string> | undefined;
+        minQuantity?: number | undefined;
+        maxQuantity?: number | undefined;
+        position?: number | undefined;
+    }): Promise<CatalogBundleSlotRow>;
+    deleteSlot(parentProductId: string, slotId: string): Promise<void>;
+    addOption(parentProductId: string, slotId: string, input: {
+        optionProductId: string;
+        defaultQuantity?: number | undefined;
+        position?: number | undefined;
+    }): Promise<CatalogBundleSlotOptionRow>;
+    removeOption(parentProductId: string, slotId: string, optionId: string): Promise<void>;
+}
+/**
+ * Container name: `packagingUnitService`. Owner: `catalog`.
+ *
+ * `pim_pimcore` writes mappable packaging units through this seam
+ * (feature 089 / FR-026).
+ */
+export interface CatalogPackagingPort {
+    list(productId: string): Promise<PackagingUnitDto[]>;
+    create(productId: string, req: CreatePackagingUnitRequest): Promise<PackagingUnitDto>;
+    update(productId: string, unitId: string, req: UpdatePackagingUnitRequest): Promise<PackagingUnitDto>;
+    delete(productId: string, unitId: string): Promise<void>;
+}
+/** One attribute with its options, as the promotion rule builder renders it. */
+export interface CatalogAttributeWithOptions {
+    id: string;
+    key: string;
+    label: Record<string, string>;
+    labelDefault: string;
+    valueType: AttributeValueType;
+    isPromoRule: boolean;
+    options: Array<{
+        value: string;
+        label: Record<string, string>;
+        labelDefault: string;
+    }>;
+}
+/**
+ * Container name: `catalogPromoAttributePort`. Owner: `catalog`.
+ *
+ * `promotions` builds its rule editor from these two answers, and reaches
+ * `CatalogQueryService` — the storefront query service, 1400 lines — for them.
+ * The port is the two questions.
+ *
+ * **Owner off:** the seam fails closed — resolving this port throws
+ * `ModuleDisabledError` and the call answers 503 `MODULE_DISABLED`, so nothing
+ * half-executes. Whether `catalog` has an off state at all is its manifest's
+ * `activation` to say, not this line's: a module declaring
+ * `nonDeactivatable` never enters one.
+ */
+export interface CatalogPromoAttributePort {
+    promoRuleAttributeKeys(): Promise<string[]>;
+    getAttributeWithOptions(key: string): Promise<CatalogAttributeWithOptions | null>;
+}
+/** A scalar a filter condition compares against. */
+export type CatalogProductFilterValue = string | number | boolean | Date | null;
+/**
+ * What a condition addresses.
+ *
+ * `column` names one of the six product columns a selection may filter on;
+ * `attribute` addresses one key of `products.attribute_values`, the JSONB bag
+ * that has held product attributes and product custom fields alike since
+ * feature 061.
+ */
+export type CatalogProductFilterField = {
+    kind: 'column';
+    column: 'id' | 'sku' | 'type' | 'status' | 'createdAt' | 'updatedAt';
+} | {
+    kind: 'attribute';
+    key: string;
+};
+/**
+ * The operators a condition may use.
+ *
+ * `contains` and `startsWith` are patterns the **owner** builds, so a caller
+ * never writes SQL `LIKE` syntax and the escaping rule has one home. Both match
+ * case-insensitively, as the queries they replace already did.
+ *
+ * **Their value is matched literally.** `%`, `_` and the escape character are
+ * characters, not wildcards: the owner escapes them before building the
+ * pattern, so `contains "50%"` selects the products whose text carries the
+ * three characters `5`, `0`, `%` and not every product with "50" followed by
+ * anything. That is part of this shape rather than one provider's detail — a
+ * caller passes the value as the operator's user typed it and never
+ * pre-escapes, and any provider of {@link CatalogProductFilterPort} owes the
+ * same semantics.
+ */
+export type CatalogProductFilterOperator = 'eq' | 'ne' | 'in' | 'nin' | 'gt' | 'gte' | 'lt' | 'lte' | 'contains' | 'startsWith' | 'isNull' | 'isNotNull';
+export interface CatalogProductFilterCondition {
+    kind: 'condition';
+    field: CatalogProductFilterField;
+    op: CatalogProductFilterOperator;
+    /**
+     * The comparison values. `in` / `nin` read all of them; a range is expressed
+     * as two conditions under an `and` group; every other operator reads the
+     * first; `isNull` and `isNotNull` read none.
+     */
+    values: readonly CatalogProductFilterValue[];
+}
+export interface CatalogProductFilterGroup {
+    kind: 'group';
+    op: 'and' | 'or';
+    children: readonly CatalogProductFilter[];
+}
+/**
+ * The two constants a compiler needs and an empty object cannot express.
+ *
+ * `all` constrains nothing; `none` can never be satisfied. They are named
+ * rather than left to `{}`, because inside an `or` branch an empty predicate
+ * collapses the branch instead of matching everything — a superset silently
+ * becoming a subset, which is how a filter drops the rows it was meant to keep.
+ *
+ * Two interfaces rather than one with a two-value `kind`, so `kind` stays a
+ * discriminant a translator can narrow the whole union on.
+ */
+export interface CatalogProductFilterAll {
+    kind: 'all';
+}
+export interface CatalogProductFilterNone {
+    kind: 'none';
+}
+export type CatalogProductFilterConstant = CatalogProductFilterAll | CatalogProductFilterNone;
+export type CatalogProductFilter = CatalogProductFilterCondition | CatalogProductFilterGroup | CatalogProductFilterAll | CatalogProductFilterNone;
+/** One keyset page of the products a filter selects. */
+export interface CatalogSellableProductQuery {
+    /**
+     * The only ids the query may consider — for a feed, the sales channel's
+     * membership, resolved by the caller through the sanctioned bridge accessor
+     * (Principle XII). Required, and an empty list selects nothing: this port has
+     * no "every product in the platform" reading.
+     */
+    productIds: readonly string[];
+    filter: CatalogProductFilter;
+    /** Keyset cursor. Only ids strictly greater come back; `null` starts at the first. */
+    afterId?: string | null;
+    /** Page size. Defaults to 500, the size the feed pipeline already walks in. */
+    limit?: number;
+}
+/**
+ * Container name: `catalogProductFilterPort`. Owner: `catalog`.
+ *
+ * **Sellable** is this module's floor and this module applies it: `status`
+ * `active`, not archived, not soft-deleted, and **visible to
+ * {@link ANONYMOUS_PRODUCT_AUDIENCE}** — `isProductVisibleTo`'s answer for a
+ * caller with no session and no organisation, which is what a product feed's
+ * reader is (issue #259). It is conjoined *with* the caller's filter here, so
+ * no filter a caller can construct widens past it.
+ *
+ * The audience is fixed rather than a parameter because this port has one
+ * consumer and that consumer is a feed: an operator ruled that a feed shows the
+ * prices of the sales channel it is generated for and takes no organisation
+ * into account, so there is no per-buyer reading of it to ask for. A caller
+ * that needs another audience needs a different port, not a wider floor —
+ * `visibility` said `public` alone until issue #259, and a `public` product
+ * carrying a non-empty `allowed_organization_ids` went into a Google Shopping
+ * feed for as long as that was the whole test.
+ *
+ * Rows come back as {@link CatalogProductRecord} in ascending id order, which
+ * is what makes the cursor a keyset rather than an offset: a catalogue that
+ * moves under a long walk cannot make the walk skip a row or repeat one.
+ *
+ * When `catalog` is off both methods fail closed. A feed assembled from a
+ * catalogue the platform is refusing to serve is worse than a run that stops
+ * and says why.
+ *
+ * Whether `catalog` has an off state at all is its manifest's `activation` to
+ * say, not this line's: a module declaring `nonDeactivatable` never enters one.
+ */
+export interface CatalogProductFilterPort {
+    listSellable(query: CatalogSellableProductQuery): Promise<CatalogProductRecord[]>;
+    countSellable(query: Omit<CatalogSellableProductQuery, 'afterId' | 'limit'>): Promise<number>;
+}
+//# sourceMappingURL=catalog.d.ts.map