@endora-commerce/contracts 0.100.0

package/dist/product-feeds.d.ts

@@ -0,0 +1,2837 @@
+import { z } from 'zod';
+/** Providers the module knows how to shape output for. `custom` is operator-authored. */
+export declare const feedProviderCodeSchema: z.ZodEnum<{
+    custom: "custom";
+    meta: "meta";
+    google_merchant: "google_merchant";
+    amazon: "amazon";
+    ebay: "ebay";
+    allegro: "allegro";
+}>;
+export type FeedProviderCode = z.infer<typeof feedProviderCodeSchema>;
+/**
+ * Only Google and Meta publish a category taxonomy. A revision of one reaches
+ * the platform either bundled with the image or from an optional, off-by-default
+ * check (FR-077, FR-086); generation reads the revision in force and contacts
+ * nobody either way.
+ */
+export declare const taxonomyProviderCodeSchema: z.ZodEnum<{
+    meta: "meta";
+    google_merchant: "google_merchant";
+}>;
+export type TaxonomyProviderCode = z.infer<typeof taxonomyProviderCodeSchema>;
+/**
+ * What the generated file is.
+ *
+ * `txt` is tab-separated like `tsv` and differs only in extension and media
+ * type — several marketplace importers (Google Merchant's own flat file among
+ * them) accept nothing else, and renaming the file is exactly the kind of step
+ * an operator should not have to know about.
+ *
+ * `xlsx` is the real Office Open XML workbook, not a spreadsheet-flavoured
+ * text file. The legacy binary `.xls` (BIFF8) is deliberately absent: it is
+ * superseded, and nothing in this stack can write it.
+ */
+export declare const feedOutputFormatSchema: z.ZodEnum<{
+    csv: "csv";
+    xml: "xml";
+    tsv: "tsv";
+    txt: "txt";
+    xlsx: "xlsx";
+}>;
+export type FeedOutputFormat = z.infer<typeof feedOutputFormatSchema>;
+/** Formats that lay one item per row across fixed columns (everything but XML). */
+export declare const TABULAR_FEED_FORMATS: readonly ["csv", "tsv", "txt", "xlsx"];
+export declare function isTabularFeedFormat(format: FeedOutputFormat): boolean;
+export declare const feedItemGranularitySchema: z.ZodEnum<{
+    product: "product";
+    variant: "variant";
+}>;
+export type FeedItemGranularity = z.infer<typeof feedItemGranularitySchema>;
+export declare const feedPricePresentationSchema: z.ZodEnum<{
+    net: "net";
+    gross: "gross";
+}>;
+export type FeedPricePresentation = z.infer<typeof feedPricePresentationSchema>;
+/**
+ * Closed catalogue of value sources a template field may bind to (FR-003).
+ *
+ * `attribute` and `custom_field` are two names for one registry: since feature
+ * 061 a product attribute IS a product-host Custom Field definition carrying a
+ * catalog extension. Both are accepted so a document exported from either
+ * vocabulary imports cleanly; both resolve through the same definitions read.
+ */
+export declare const feedFieldSourceKindSchema: z.ZodEnum<{
+    description: "description";
+    link: "link";
+    name: "name";
+    slug: "slug";
+    availability: "availability";
+    price: "price";
+    sku: "sku";
+    attribute: "attribute";
+    product_id: "product_id";
+    product_type: "product_type";
+    brand: "brand";
+    custom_field: "custom_field";
+    sale_price: "sale_price";
+    stock_quantity: "stock_quantity";
+    image_link: "image_link";
+    additional_image_link: "additional_image_link";
+    category_path: "category_path";
+    provider_category: "provider_category";
+    grouping_id: "grouping_id";
+    constant: "constant";
+}>;
+export type FeedFieldSourceKind = z.infer<typeof feedFieldSourceKindSchema>;
+/** Closed transform list — deliberately not an expression language (FR-067). */
+export declare const feedFieldTransformSchema: z.ZodEnum<{
+    trim: "trim";
+    none: "none";
+    upper: "upper";
+    lower: "lower";
+    truncate: "truncate";
+    strip_html: "strip_html";
+    absolute_url: "absolute_url";
+}>;
+export type FeedFieldTransform = z.infer<typeof feedFieldTransformSchema>;
+export declare const feedRunStatusSchema: z.ZodEnum<{
+    completed: "completed";
+    failed: "failed";
+    skipped: "skipped";
+    queued: "queued";
+    running: "running";
+    completed_with_warnings: "completed_with_warnings";
+    empty: "empty";
+}>;
+export type FeedRunStatus = z.infer<typeof feedRunStatusSchema>;
+export declare const feedRunTriggerSchema: z.ZodEnum<{
+    scheduled: "scheduled";
+    manual: "manual";
+}>;
+export type FeedRunTrigger = z.infer<typeof feedRunTriggerSchema>;
+/** Enumerated run-issue reasons (FR-054). Operator-facing labels come from i18n. */
+export declare const feedRunIssueReasonSchema: z.ZodEnum<{
+    missing_price: "missing_price";
+    missing_image: "missing_image";
+    private_image_asset: "private_image_asset";
+    missing_required_field: "missing_required_field";
+    missing_translation: "missing_translation";
+    unresolvable_link: "unresolvable_link";
+    unmapped_provider_category: "unmapped_provider_category";
+    stale_provider_category_mapping: "stale_provider_category_mapping";
+    unsupported_product_type: "unsupported_product_type";
+    zero_tax_rate_on_gross_feed: "zero_tax_rate_on_gross_feed";
+}>;
+export type FeedRunIssueReason = z.infer<typeof feedRunIssueReasonSchema>;
+export declare const feedRunFailureCodeSchema: z.ZodEnum<{
+    unbound_template_fields: "unbound_template_fields";
+    unknown_attribute: "unknown_attribute";
+    channel_unavailable: "channel_unavailable";
+    storefront_url_unconfigured: "storefront_url_unconfigured";
+    price_list_unavailable: "price_list_unavailable";
+    language_unavailable: "language_unavailable";
+    skip_threshold_exceeded: "skip_threshold_exceeded";
+    storage_unavailable: "storage_unavailable";
+    worker_lost: "worker_lost";
+    internal_error: "internal_error";
+}>;
+export type FeedRunFailureCode = z.infer<typeof feedRunFailureCodeSchema>;
+export declare const cronExpressionSchema: z.ZodString;
+/**
+ * IANA timezone. Validated against the runtime's own tz database rather than a
+ * hard-coded list, so it cannot drift from what the scheduler will accept.
+ */
+export declare const timezoneSchema: z.ZodString;
+export declare const feedScheduleSchema: z.ZodNullable<z.ZodObject<{
+    cron: z.ZodString;
+    timezone: z.ZodString;
+}, z.core.$strip>>;
+export type FeedSchedule = z.infer<typeof feedScheduleSchema>;
+export interface SchedulePreset {
+    id: string;
+    cron: string;
+}
+/**
+ * The presets the admin `Select` offers (ux-design §2.2 — "never make a
+ * merchandiser write cron"). Short on purpose: a preset list long enough to
+ * need scanning is a cron field with extra steps. Anything else is *Custom*.
+ */
+export declare const SCHEDULE_PRESETS: ReadonlyArray<SchedulePreset>;
+/** The preset a cron expression corresponds to, or null when it is custom. */
+export declare function presetForCron(cron: string): string | null;
+/**
+ * The point-and-click form of a schedule — the four shapes an operator can
+ * assemble without knowing cron.
+ *
+ * Deliberately a small closed set. Cron can express far more, and the *Custom*
+ * text input remains for anyone who needs it; what this type exists to do is
+ * make the common cases reachable without teaching five positional fields.
+ */
+export type CronBuilderValue = {
+    frequency: 'hourly';
+    minute: number;
+} | {
+    frequency: 'daily';
+    hour: number;
+    minute: number;
+} | {
+    frequency: 'weekly';
+    dayOfWeek: number;
+    hour: number;
+    minute: number;
+} | {
+    frequency: 'monthly';
+    dayOfMonth: number;
+    hour: number;
+    minute: number;
+};
+export type CronBuilderFrequency = CronBuilderValue['frequency'];
+export declare const CRON_BUILDER_FREQUENCIES: readonly ["hourly", "daily", "weekly", "monthly"];
+/** The expression a builder selection stands for. Always valid by construction. */
+export declare function cronFromBuilder(value: CronBuilderValue): string;
+/**
+ * The builder selection an expression corresponds to, or `null` when the
+ * expression says something the four frequencies cannot.
+ *
+ * The `null` is the important half. `0 * /4 * * *` is a perfectly good schedule
+ * that no frequency here describes; reporting it as "hourly" would show the
+ * operator a dropdown they never chose and quadruple the run rate if they then
+ * saved. Anything with a step, a list, a range, a fixed month, or both a
+ * day-of-month and a day-of-week (which cron ORs together) is refused, and the
+ * caller keeps the operator on the raw expression instead.
+ */
+export declare function builderFromCron(cron: string): CronBuilderValue | null;
+export declare function isValidTimezone(timezone: string): boolean;
+/**
+ * Grammar (the contract's regex) **and** field ranges. Both, because a
+ * grammatically valid expression that can never fire is the worse failure: the
+ * operator sees a saved schedule and no runs.
+ */
+export declare function isValidCronExpression(expression: string): boolean;
+/**
+ * The sentence rendered live under the *Custom* input (ux-design §2.2).
+ *
+ * Returns `null` for an invalid expression so the caller shows
+ * `feeds.schedule.invalid` instead — an echo and an error must never be on
+ * screen at once. For a valid expression it always returns *something*: the
+ * shapes the presets produce get real prose, and anything else gets the
+ * expression back verbatim. Echoing the input is honest; an empty line under a
+ * valid expression reads like a rejection.
+ */
+export declare function describeCronExpression(expression: string): string | null;
+export declare const productSelectionOpSchema: z.ZodEnum<{
+    in: "in";
+    startsWith: "startsWith";
+    isSet: "isSet";
+    eq: "eq";
+    gt: "gt";
+    gte: "gte";
+    lt: "lt";
+    lte: "lte";
+    contains: "contains";
+    neq: "neq";
+    between: "between";
+    notIn: "notIn";
+    isNotSet: "isNotSet";
+}>;
+export type ProductSelectionOp = z.infer<typeof productSelectionOpSchema>;
+/** Built-in, product-context fields the criteria builder offers (FR-025). */
+export declare const productSelectionBuiltinFieldSchema: z.ZodEnum<{
+    status: "status";
+    updatedAt: "updatedAt";
+    createdAt: "createdAt";
+    category: "category";
+    price: "price";
+    productType: "productType";
+    brand: "brand";
+    stockState: "stockState";
+}>;
+export type ProductSelectionBuiltinField = z.infer<typeof productSelectionBuiltinFieldSchema>;
+export declare const productSelectionFieldSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"builtin">;
+    key: z.ZodEnum<{
+        status: "status";
+        updatedAt: "updatedAt";
+        createdAt: "createdAt";
+        category: "category";
+        price: "price";
+        productType: "productType";
+        brand: "brand";
+        stockState: "stockState";
+    }>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"attribute">;
+    attributeKey: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"customField">;
+    fieldKey: z.ZodString;
+}, z.core.$strip>], "kind">;
+export type ProductSelectionField = z.infer<typeof productSelectionFieldSchema>;
+export declare const productSelectionValueSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+export type ProductSelectionValue = z.infer<typeof productSelectionValueSchema>;
+export type ProductSelectionAll = {
+    kind: 'all';
+};
+export type ProductSelectionCondition = {
+    kind: 'condition';
+    field: ProductSelectionField;
+    op: ProductSelectionOp;
+    values: ProductSelectionValue[];
+};
+export type ProductSelectionGroup = {
+    kind: 'group';
+    op: 'AND' | 'OR';
+    children: ProductSelectionRule[];
+};
+export type ProductSelectionRule = ProductSelectionAll | ProductSelectionCondition | ProductSelectionGroup;
+export declare function productSelectionDepth(node: ProductSelectionRule): number;
+/** `{ kind: 'all' }` is the canonical "whole channel catalogue" (FR-024). */
+export declare const productSelectionRuleSchema: z.ZodType<ProductSelectionRule, unknown, z.core.$ZodTypeInternals<ProductSelectionRule, unknown>>;
+export declare const feedTemplateFieldSchema: z.ZodObject<{
+    id: z.ZodString;
+    outputName: z.ZodString;
+    sourceKind: z.ZodEnum<{
+        description: "description";
+        link: "link";
+        name: "name";
+        slug: "slug";
+        availability: "availability";
+        price: "price";
+        sku: "sku";
+        attribute: "attribute";
+        product_id: "product_id";
+        product_type: "product_type";
+        brand: "brand";
+        custom_field: "custom_field";
+        sale_price: "sale_price";
+        stock_quantity: "stock_quantity";
+        image_link: "image_link";
+        additional_image_link: "additional_image_link";
+        category_path: "category_path";
+        provider_category: "provider_category";
+        grouping_id: "grouping_id";
+        constant: "constant";
+    }>;
+    sourceKey: z.ZodNullable<z.ZodString>;
+    constantValue: z.ZodNullable<z.ZodString>;
+    fallbackValue: z.ZodNullable<z.ZodString>;
+    providerRequired: z.ZodBoolean;
+    transform: z.ZodNullable<z.ZodEnum<{
+        trim: "trim";
+        none: "none";
+        upper: "upper";
+        lower: "lower";
+        truncate: "truncate";
+        strip_html: "strip_html";
+        absolute_url: "absolute_url";
+    }>>;
+    transformArg: z.ZodNullable<z.ZodString>;
+    sortOrder: z.ZodNumber;
+    helpKey: z.ZodNullable<z.ZodString>;
+    unbound: z.ZodBoolean;
+}, z.core.$strip>;
+export type FeedTemplateField = z.infer<typeof feedTemplateFieldSchema>;
+/** Cross-field rules that FR-009 requires to be refused at save time. */
+export declare const feedTemplateFieldWriteSchema: z.ZodObject<{
+    outputName: z.ZodString;
+    sourceKind: z.ZodEnum<{
+        description: "description";
+        link: "link";
+        name: "name";
+        slug: "slug";
+        availability: "availability";
+        price: "price";
+        sku: "sku";
+        attribute: "attribute";
+        product_id: "product_id";
+        product_type: "product_type";
+        brand: "brand";
+        custom_field: "custom_field";
+        sale_price: "sale_price";
+        stock_quantity: "stock_quantity";
+        image_link: "image_link";
+        additional_image_link: "additional_image_link";
+        category_path: "category_path";
+        provider_category: "provider_category";
+        grouping_id: "grouping_id";
+        constant: "constant";
+    }>;
+    sourceKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    constantValue: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    fallbackValue: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    providerRequired: z.ZodOptional<z.ZodBoolean>;
+    transform: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        trim: "trim";
+        none: "none";
+        upper: "upper";
+        lower: "lower";
+        truncate: "truncate";
+        strip_html: "strip_html";
+        absolute_url: "absolute_url";
+    }>>>;
+    transformArg: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    sortOrder: z.ZodNumber;
+    helpKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type FeedTemplateFieldWrite = z.infer<typeof feedTemplateFieldWriteSchema>;
+export declare const feedTemplateSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    providerCode: z.ZodEnum<{
+        custom: "custom";
+        meta: "meta";
+        google_merchant: "google_merchant";
+        amazon: "amazon";
+        ebay: "ebay";
+        allegro: "allegro";
+    }>;
+    outputFormat: z.ZodEnum<{
+        csv: "csv";
+        xml: "xml";
+        tsv: "tsv";
+        txt: "txt";
+        xlsx: "xlsx";
+    }>;
+    itemGranularity: z.ZodEnum<{
+        product: "product";
+        variant: "variant";
+    }>;
+    taxonomyProviderCode: z.ZodNullable<z.ZodEnum<{
+        meta: "meta";
+        google_merchant: "google_merchant";
+    }>>;
+    isSystem: z.ZodBoolean;
+    systemCode: z.ZodNullable<z.ZodString>;
+    fields: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        outputName: z.ZodString;
+        sourceKind: z.ZodEnum<{
+            description: "description";
+            link: "link";
+            name: "name";
+            slug: "slug";
+            availability: "availability";
+            price: "price";
+            sku: "sku";
+            attribute: "attribute";
+            product_id: "product_id";
+            product_type: "product_type";
+            brand: "brand";
+            custom_field: "custom_field";
+            sale_price: "sale_price";
+            stock_quantity: "stock_quantity";
+            image_link: "image_link";
+            additional_image_link: "additional_image_link";
+            category_path: "category_path";
+            provider_category: "provider_category";
+            grouping_id: "grouping_id";
+            constant: "constant";
+        }>;
+        sourceKey: z.ZodNullable<z.ZodString>;
+        constantValue: z.ZodNullable<z.ZodString>;
+        fallbackValue: z.ZodNullable<z.ZodString>;
+        providerRequired: z.ZodBoolean;
+        transform: z.ZodNullable<z.ZodEnum<{
+            trim: "trim";
+            none: "none";
+            upper: "upper";
+            lower: "lower";
+            truncate: "truncate";
+            strip_html: "strip_html";
+            absolute_url: "absolute_url";
+        }>>;
+        transformArg: z.ZodNullable<z.ZodString>;
+        sortOrder: z.ZodNumber;
+        helpKey: z.ZodNullable<z.ZodString>;
+        unbound: z.ZodBoolean;
+    }, z.core.$strip>>;
+    usedByFeedCount: z.ZodNumber;
+    version: z.ZodNumber;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type FeedTemplate = z.infer<typeof feedTemplateSchema>;
+export declare const createFeedTemplateRequestSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    providerCode: z.ZodDefault<z.ZodEnum<{
+        custom: "custom";
+        meta: "meta";
+        google_merchant: "google_merchant";
+        amazon: "amazon";
+        ebay: "ebay";
+        allegro: "allegro";
+    }>>;
+    outputFormat: z.ZodDefault<z.ZodEnum<{
+        csv: "csv";
+        xml: "xml";
+        tsv: "tsv";
+        txt: "txt";
+        xlsx: "xlsx";
+    }>>;
+    itemGranularity: z.ZodDefault<z.ZodEnum<{
+        product: "product";
+        variant: "variant";
+    }>>;
+    taxonomyProviderCode: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        meta: "meta";
+        google_merchant: "google_merchant";
+    }>>>;
+    fields: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        outputName: z.ZodString;
+        sourceKind: z.ZodEnum<{
+            description: "description";
+            link: "link";
+            name: "name";
+            slug: "slug";
+            availability: "availability";
+            price: "price";
+            sku: "sku";
+            attribute: "attribute";
+            product_id: "product_id";
+            product_type: "product_type";
+            brand: "brand";
+            custom_field: "custom_field";
+            sale_price: "sale_price";
+            stock_quantity: "stock_quantity";
+            image_link: "image_link";
+            additional_image_link: "additional_image_link";
+            category_path: "category_path";
+            provider_category: "provider_category";
+            grouping_id: "grouping_id";
+            constant: "constant";
+        }>;
+        sourceKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        constantValue: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        fallbackValue: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        providerRequired: z.ZodOptional<z.ZodBoolean>;
+        transform: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            trim: "trim";
+            none: "none";
+            upper: "upper";
+            lower: "lower";
+            truncate: "truncate";
+            strip_html: "strip_html";
+            absolute_url: "absolute_url";
+        }>>>;
+        transformArg: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        sortOrder: z.ZodNumber;
+        helpKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type CreateFeedTemplateRequest = z.infer<typeof createFeedTemplateRequestSchema>;
+/**
+ * Full replacement of the field list — the structure editor saves the whole
+ * ordered list, so reordering, renaming, adding and removing are one atomic,
+ * single-audit-entry operation rather than a burst of per-field PATCHes.
+ *
+ * The four defaulted keys are re-declared without their defaults for the same
+ * reason `updateProductFeedRequestSchema` does: `z.object().partial()` makes a
+ * key optional but does **not** remove its `.default()`. A save that only
+ * renamed a template would otherwise arrive carrying `providerCode: 'custom'`,
+ * `outputFormat: 'xml'`, `itemGranularity: 'product'` and an empty `fields`
+ * array — silently rewriting a Google per-variant XML template into a custom
+ * per-product one, and emptying its field list.
+ */
+export declare const updateFeedTemplateRequestSchema: z.ZodObject<{
+    description: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+    name: z.ZodOptional<z.ZodString>;
+    taxonomyProviderCode: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        meta: "meta";
+        google_merchant: "google_merchant";
+    }>>>>;
+    providerCode: z.ZodOptional<z.ZodEnum<{
+        custom: "custom";
+        meta: "meta";
+        google_merchant: "google_merchant";
+        amazon: "amazon";
+        ebay: "ebay";
+        allegro: "allegro";
+    }>>;
+    outputFormat: z.ZodOptional<z.ZodEnum<{
+        csv: "csv";
+        xml: "xml";
+        tsv: "tsv";
+        txt: "txt";
+        xlsx: "xlsx";
+    }>>;
+    itemGranularity: z.ZodOptional<z.ZodEnum<{
+        product: "product";
+        variant: "variant";
+    }>>;
+    fields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        outputName: z.ZodString;
+        sourceKind: z.ZodEnum<{
+            description: "description";
+            link: "link";
+            name: "name";
+            slug: "slug";
+            availability: "availability";
+            price: "price";
+            sku: "sku";
+            attribute: "attribute";
+            product_id: "product_id";
+            product_type: "product_type";
+            brand: "brand";
+            custom_field: "custom_field";
+            sale_price: "sale_price";
+            stock_quantity: "stock_quantity";
+            image_link: "image_link";
+            additional_image_link: "additional_image_link";
+            category_path: "category_path";
+            provider_category: "provider_category";
+            grouping_id: "grouping_id";
+            constant: "constant";
+        }>;
+        sourceKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        constantValue: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        fallbackValue: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        providerRequired: z.ZodOptional<z.ZodBoolean>;
+        transform: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            trim: "trim";
+            none: "none";
+            upper: "upper";
+            lower: "lower";
+            truncate: "truncate";
+            strip_html: "strip_html";
+            absolute_url: "absolute_url";
+        }>>>;
+        transformArg: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        sortOrder: z.ZodNumber;
+        helpKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type UpdateFeedTemplateRequest = z.infer<typeof updateFeedTemplateRequestSchema>;
+export declare const duplicateFeedTemplateRequestSchema: z.ZodObject<{
+    name: z.ZodString;
+}, z.core.$strip>;
+export type DuplicateFeedTemplateRequest = z.infer<typeof duplicateFeedTemplateRequestSchema>;
+export declare const feedTemplateResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        providerCode: z.ZodEnum<{
+            custom: "custom";
+            meta: "meta";
+            google_merchant: "google_merchant";
+            amazon: "amazon";
+            ebay: "ebay";
+            allegro: "allegro";
+        }>;
+        outputFormat: z.ZodEnum<{
+            csv: "csv";
+            xml: "xml";
+            tsv: "tsv";
+            txt: "txt";
+            xlsx: "xlsx";
+        }>;
+        itemGranularity: z.ZodEnum<{
+            product: "product";
+            variant: "variant";
+        }>;
+        taxonomyProviderCode: z.ZodNullable<z.ZodEnum<{
+            meta: "meta";
+            google_merchant: "google_merchant";
+        }>>;
+        isSystem: z.ZodBoolean;
+        systemCode: z.ZodNullable<z.ZodString>;
+        fields: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            outputName: z.ZodString;
+            sourceKind: z.ZodEnum<{
+                description: "description";
+                link: "link";
+                name: "name";
+                slug: "slug";
+                availability: "availability";
+                price: "price";
+                sku: "sku";
+                attribute: "attribute";
+                product_id: "product_id";
+                product_type: "product_type";
+                brand: "brand";
+                custom_field: "custom_field";
+                sale_price: "sale_price";
+                stock_quantity: "stock_quantity";
+                image_link: "image_link";
+                additional_image_link: "additional_image_link";
+                category_path: "category_path";
+                provider_category: "provider_category";
+                grouping_id: "grouping_id";
+                constant: "constant";
+            }>;
+            sourceKey: z.ZodNullable<z.ZodString>;
+            constantValue: z.ZodNullable<z.ZodString>;
+            fallbackValue: z.ZodNullable<z.ZodString>;
+            providerRequired: z.ZodBoolean;
+            transform: z.ZodNullable<z.ZodEnum<{
+                trim: "trim";
+                none: "none";
+                upper: "upper";
+                lower: "lower";
+                truncate: "truncate";
+                strip_html: "strip_html";
+                absolute_url: "absolute_url";
+            }>>;
+            transformArg: z.ZodNullable<z.ZodString>;
+            sortOrder: z.ZodNumber;
+            helpKey: z.ZodNullable<z.ZodString>;
+            unbound: z.ZodBoolean;
+        }, z.core.$strip>>;
+        usedByFeedCount: z.ZodNumber;
+        version: z.ZodNumber;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const feedTemplateListResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        version: z.ZodNumber;
+        id: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        isSystem: z.ZodBoolean;
+        updatedAt: z.ZodString;
+        createdAt: z.ZodString;
+        providerCode: z.ZodEnum<{
+            custom: "custom";
+            meta: "meta";
+            google_merchant: "google_merchant";
+            amazon: "amazon";
+            ebay: "ebay";
+            allegro: "allegro";
+        }>;
+        outputFormat: z.ZodEnum<{
+            csv: "csv";
+            xml: "xml";
+            tsv: "tsv";
+            txt: "txt";
+            xlsx: "xlsx";
+        }>;
+        itemGranularity: z.ZodEnum<{
+            product: "product";
+            variant: "variant";
+        }>;
+        taxonomyProviderCode: z.ZodNullable<z.ZodEnum<{
+            meta: "meta";
+            google_merchant: "google_merchant";
+        }>>;
+        systemCode: z.ZodNullable<z.ZodString>;
+        usedByFeedCount: z.ZodNumber;
+    }, z.core.$strip>>;
+    pagination: z.ZodObject<{
+        cursor: z.ZodNullable<z.ZodString>;
+        hasMore: z.ZodBoolean;
+        limit: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/** Why a group exists, so the editor can order and head the picker's sections. */
+export declare const feedFieldSourceGroupKindSchema: z.ZodEnum<{
+    attribute: "attribute";
+    custom_field: "custom_field";
+    constant: "constant";
+    product_property: "product_property";
+    price_and_stock: "price_and_stock";
+    computed: "computed";
+}>;
+export type FeedFieldSourceGroupKind = z.infer<typeof feedFieldSourceGroupKindSchema>;
+export declare const feedFieldSourceSchema: z.ZodObject<{
+    sourceKind: z.ZodEnum<{
+        description: "description";
+        link: "link";
+        name: "name";
+        slug: "slug";
+        availability: "availability";
+        price: "price";
+        sku: "sku";
+        attribute: "attribute";
+        product_id: "product_id";
+        product_type: "product_type";
+        brand: "brand";
+        custom_field: "custom_field";
+        sale_price: "sale_price";
+        stock_quantity: "stock_quantity";
+        image_link: "image_link";
+        additional_image_link: "additional_image_link";
+        category_path: "category_path";
+        provider_category: "provider_category";
+        grouping_id: "grouping_id";
+        constant: "constant";
+    }>;
+    sourceKey: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    labelKey: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    label: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    description: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    valueType: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    requiresTaxonomy: z.ZodDefault<z.ZodBoolean>;
+    unsupportedInFormats: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        csv: "csv";
+        xml: "xml";
+        tsv: "tsv";
+        txt: "txt";
+        xlsx: "xlsx";
+    }>>>;
+}, z.core.$strip>;
+export type FeedFieldSource = z.infer<typeof feedFieldSourceSchema>;
+export declare const feedFieldSourceCatalogueSchema: z.ZodObject<{
+    groups: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            attribute: "attribute";
+            custom_field: "custom_field";
+            constant: "constant";
+            product_property: "product_property";
+            price_and_stock: "price_and_stock";
+            computed: "computed";
+        }>;
+        sources: z.ZodArray<z.ZodObject<{
+            sourceKind: z.ZodEnum<{
+                description: "description";
+                link: "link";
+                name: "name";
+                slug: "slug";
+                availability: "availability";
+                price: "price";
+                sku: "sku";
+                attribute: "attribute";
+                product_id: "product_id";
+                product_type: "product_type";
+                brand: "brand";
+                custom_field: "custom_field";
+                sale_price: "sale_price";
+                stock_quantity: "stock_quantity";
+                image_link: "image_link";
+                additional_image_link: "additional_image_link";
+                category_path: "category_path";
+                provider_category: "provider_category";
+                grouping_id: "grouping_id";
+                constant: "constant";
+            }>;
+            sourceKey: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            labelKey: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            label: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            description: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            valueType: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            requiresTaxonomy: z.ZodDefault<z.ZodBoolean>;
+            unsupportedInFormats: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                csv: "csv";
+                xml: "xml";
+                tsv: "tsv";
+                txt: "txt";
+                xlsx: "xlsx";
+            }>>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type FeedFieldSourceCatalogue = z.infer<typeof feedFieldSourceCatalogueSchema>;
+export declare const feedFieldSourceCatalogueResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        groups: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                attribute: "attribute";
+                custom_field: "custom_field";
+                constant: "constant";
+                product_property: "product_property";
+                price_and_stock: "price_and_stock";
+                computed: "computed";
+            }>;
+            sources: z.ZodArray<z.ZodObject<{
+                sourceKind: z.ZodEnum<{
+                    description: "description";
+                    link: "link";
+                    name: "name";
+                    slug: "slug";
+                    availability: "availability";
+                    price: "price";
+                    sku: "sku";
+                    attribute: "attribute";
+                    product_id: "product_id";
+                    product_type: "product_type";
+                    brand: "brand";
+                    custom_field: "custom_field";
+                    sale_price: "sale_price";
+                    stock_quantity: "stock_quantity";
+                    image_link: "image_link";
+                    additional_image_link: "additional_image_link";
+                    category_path: "category_path";
+                    provider_category: "provider_category";
+                    grouping_id: "grouping_id";
+                    constant: "constant";
+                }>;
+                sourceKey: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                labelKey: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                label: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                description: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                valueType: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                requiresTaxonomy: z.ZodDefault<z.ZodBoolean>;
+                unsupportedInFormats: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                    csv: "csv";
+                    xml: "xml";
+                    tsv: "tsv";
+                    txt: "txt";
+                    xlsx: "xlsx";
+                }>>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/** The template exactly as it stands on screen — no id, possibly invalid. */
+export declare const feedTemplateDraftSchema: z.ZodObject<{
+    providerCode: z.ZodEnum<{
+        custom: "custom";
+        meta: "meta";
+        google_merchant: "google_merchant";
+        amazon: "amazon";
+        ebay: "ebay";
+        allegro: "allegro";
+    }>;
+    outputFormat: z.ZodEnum<{
+        csv: "csv";
+        xml: "xml";
+        tsv: "tsv";
+        txt: "txt";
+        xlsx: "xlsx";
+    }>;
+    itemGranularity: z.ZodEnum<{
+        product: "product";
+        variant: "variant";
+    }>;
+    taxonomyProviderCode: z.ZodNullable<z.ZodEnum<{
+        meta: "meta";
+        google_merchant: "google_merchant";
+    }>>;
+    fields: z.ZodArray<z.ZodObject<{
+        outputName: z.ZodString;
+        sourceKind: z.ZodEnum<{
+            description: "description";
+            link: "link";
+            name: "name";
+            slug: "slug";
+            availability: "availability";
+            price: "price";
+            sku: "sku";
+            attribute: "attribute";
+            product_id: "product_id";
+            product_type: "product_type";
+            brand: "brand";
+            custom_field: "custom_field";
+            sale_price: "sale_price";
+            stock_quantity: "stock_quantity";
+            image_link: "image_link";
+            additional_image_link: "additional_image_link";
+            category_path: "category_path";
+            provider_category: "provider_category";
+            grouping_id: "grouping_id";
+            constant: "constant";
+        }>;
+        sourceKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        constantValue: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        fallbackValue: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        providerRequired: z.ZodOptional<z.ZodBoolean>;
+        transform: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            trim: "trim";
+            none: "none";
+            upper: "upper";
+            lower: "lower";
+            truncate: "truncate";
+            strip_html: "strip_html";
+            absolute_url: "absolute_url";
+        }>>>;
+        transformArg: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        sortOrder: z.ZodNumber;
+        helpKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type FeedTemplateDraft = z.infer<typeof feedTemplateDraftSchema>;
+/** The resolution context. Every part is optional; the server fills the rest. */
+export declare const feedPreviewContextSchema: z.ZodObject<{
+    productFeedId: z.ZodOptional<z.ZodString>;
+    salesChannelId: z.ZodOptional<z.ZodString>;
+    languageCode: z.ZodOptional<z.ZodString>;
+    currencyCode: z.ZodOptional<z.ZodString>;
+    priceListId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    pricePresentation: z.ZodOptional<z.ZodEnum<{
+        net: "net";
+        gross: "gross";
+    }>>;
+    taxCountry: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type FeedPreviewContext = z.infer<typeof feedPreviewContextSchema>;
+export declare const feedTemplatePreviewRequestSchema: z.ZodObject<{
+    baseTemplateId: z.ZodOptional<z.ZodString>;
+    draft: z.ZodObject<{
+        providerCode: z.ZodEnum<{
+            custom: "custom";
+            meta: "meta";
+            google_merchant: "google_merchant";
+            amazon: "amazon";
+            ebay: "ebay";
+            allegro: "allegro";
+        }>;
+        outputFormat: z.ZodEnum<{
+            csv: "csv";
+            xml: "xml";
+            tsv: "tsv";
+            txt: "txt";
+            xlsx: "xlsx";
+        }>;
+        itemGranularity: z.ZodEnum<{
+            product: "product";
+            variant: "variant";
+        }>;
+        taxonomyProviderCode: z.ZodNullable<z.ZodEnum<{
+            meta: "meta";
+            google_merchant: "google_merchant";
+        }>>;
+        fields: z.ZodArray<z.ZodObject<{
+            outputName: z.ZodString;
+            sourceKind: z.ZodEnum<{
+                description: "description";
+                link: "link";
+                name: "name";
+                slug: "slug";
+                availability: "availability";
+                price: "price";
+                sku: "sku";
+                attribute: "attribute";
+                product_id: "product_id";
+                product_type: "product_type";
+                brand: "brand";
+                custom_field: "custom_field";
+                sale_price: "sale_price";
+                stock_quantity: "stock_quantity";
+                image_link: "image_link";
+                additional_image_link: "additional_image_link";
+                category_path: "category_path";
+                provider_category: "provider_category";
+                grouping_id: "grouping_id";
+                constant: "constant";
+            }>;
+            sourceKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            constantValue: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            fallbackValue: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            providerRequired: z.ZodOptional<z.ZodBoolean>;
+            transform: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                trim: "trim";
+                none: "none";
+                upper: "upper";
+                lower: "lower";
+                truncate: "truncate";
+                strip_html: "strip_html";
+                absolute_url: "absolute_url";
+            }>>>;
+            transformArg: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            sortOrder: z.ZodNumber;
+            helpKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    context: z.ZodDefault<z.ZodObject<{
+        productFeedId: z.ZodOptional<z.ZodString>;
+        salesChannelId: z.ZodOptional<z.ZodString>;
+        languageCode: z.ZodOptional<z.ZodString>;
+        currencyCode: z.ZodOptional<z.ZodString>;
+        priceListId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        pricePresentation: z.ZodOptional<z.ZodEnum<{
+            net: "net";
+            gross: "gross";
+        }>>;
+        taxCountry: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    productId: z.ZodString;
+    variantId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type FeedTemplatePreviewRequest = z.infer<typeof feedTemplatePreviewRequestSchema>;
+export declare const feedTemplatePreviewFieldSchema: z.ZodObject<{
+    outputName: z.ZodString;
+    value: z.ZodNullable<z.ZodString>;
+    resolvedFrom: z.ZodEnum<{
+        source: "source";
+        fallback: "fallback";
+        omitted: "omitted";
+    }>;
+    wouldSkipItem: z.ZodBoolean;
+    issueReason: z.ZodNullable<z.ZodEnum<{
+        missing_price: "missing_price";
+        missing_image: "missing_image";
+        private_image_asset: "private_image_asset";
+        missing_required_field: "missing_required_field";
+        missing_translation: "missing_translation";
+        unresolvable_link: "unresolvable_link";
+        unmapped_provider_category: "unmapped_provider_category";
+        stale_provider_category_mapping: "stale_provider_category_mapping";
+        unsupported_product_type: "unsupported_product_type";
+        zero_tax_rate_on_gross_feed: "zero_tax_rate_on_gross_feed";
+    }>>;
+    unbound: z.ZodBoolean;
+    helpKey: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const feedTemplatePreviewResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        fields: z.ZodArray<z.ZodObject<{
+            outputName: z.ZodString;
+            value: z.ZodNullable<z.ZodString>;
+            resolvedFrom: z.ZodEnum<{
+                source: "source";
+                fallback: "fallback";
+                omitted: "omitted";
+            }>;
+            wouldSkipItem: z.ZodBoolean;
+            issueReason: z.ZodNullable<z.ZodEnum<{
+                missing_price: "missing_price";
+                missing_image: "missing_image";
+                private_image_asset: "private_image_asset";
+                missing_required_field: "missing_required_field";
+                missing_translation: "missing_translation";
+                unresolvable_link: "unresolvable_link";
+                unmapped_provider_category: "unmapped_provider_category";
+                stale_provider_category_mapping: "stale_provider_category_mapping";
+                unsupported_product_type: "unsupported_product_type";
+                zero_tax_rate_on_gross_feed: "zero_tax_rate_on_gross_feed";
+            }>>;
+            unbound: z.ZodBoolean;
+            helpKey: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        wouldEmitItem: z.ZodBoolean;
+        skipReason: z.ZodNullable<z.ZodEnum<{
+            missing_price: "missing_price";
+            missing_image: "missing_image";
+            private_image_asset: "private_image_asset";
+            missing_required_field: "missing_required_field";
+            missing_translation: "missing_translation";
+            unresolvable_link: "unresolvable_link";
+            unmapped_provider_category: "unmapped_provider_category";
+            stale_provider_category_mapping: "stale_provider_category_mapping";
+            unsupported_product_type: "unsupported_product_type";
+            zero_tax_rate_on_gross_feed: "zero_tax_rate_on_gross_feed";
+        }>>;
+        renderedItem: z.ZodString;
+        resolvedContext: z.ZodObject<{
+            salesChannelId: z.ZodString;
+            languageCode: z.ZodString;
+            currencyCode: z.ZodString;
+            priceListId: z.ZodNullable<z.ZodString>;
+            pricePresentation: z.ZodEnum<{
+                net: "net";
+                gross: "gross";
+            }>;
+            taxCountry: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const productFeedTokenSchema: z.ZodObject<{
+    prefix: z.ZodNullable<z.ZodString>;
+    rotatedAt: z.ZodNullable<z.ZodString>;
+    revokedAt: z.ZodNullable<z.ZodString>;
+    url: z.ZodNullable<z.ZodString>;
+    urlIsLive: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const productFeedRunSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        completed: "completed";
+        failed: "failed";
+        skipped: "skipped";
+        queued: "queued";
+        running: "running";
+        completed_with_warnings: "completed_with_warnings";
+        empty: "empty";
+    }>;
+    trigger: z.ZodEnum<{
+        scheduled: "scheduled";
+        manual: "manual";
+    }>;
+    startedAt: z.ZodNullable<z.ZodString>;
+    finishedAt: z.ZodNullable<z.ZodString>;
+    emittedCount: z.ZodNumber;
+    skippedCount: z.ZodNumber;
+    warningCount: z.ZodNumber;
+    failureCode: z.ZodNullable<z.ZodEnum<{
+        unbound_template_fields: "unbound_template_fields";
+        unknown_attribute: "unknown_attribute";
+        channel_unavailable: "channel_unavailable";
+        storefront_url_unconfigured: "storefront_url_unconfigured";
+        price_list_unavailable: "price_list_unavailable";
+        language_unavailable: "language_unavailable";
+        skip_threshold_exceeded: "skip_threshold_exceeded";
+        storage_unavailable: "storage_unavailable";
+        worker_lost: "worker_lost";
+        internal_error: "internal_error";
+    }>>;
+}, z.core.$strip>;
+export type ProductFeedRunSummary = z.infer<typeof productFeedRunSummarySchema>;
+export declare const productFeedSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    slug: z.ZodString;
+    feedTemplateId: z.ZodString;
+    feedTemplateName: z.ZodString;
+    salesChannelId: z.ZodString;
+    salesChannelCode: z.ZodString;
+    languageCode: z.ZodString;
+    currencyCode: z.ZodString;
+    priceListId: z.ZodNullable<z.ZodString>;
+    pricePresentation: z.ZodEnum<{
+        net: "net";
+        gross: "gross";
+    }>;
+    taxCountry: z.ZodNullable<z.ZodString>;
+    selectionRule: z.ZodType<ProductSelectionRule, unknown, z.core.$ZodTypeInternals<ProductSelectionRule, unknown>>;
+    schedule: z.ZodNullable<z.ZodObject<{
+        cron: z.ZodString;
+        timezone: z.ZodString;
+    }, z.core.$strip>>;
+    enabled: z.ZodBoolean;
+    token: z.ZodObject<{
+        prefix: z.ZodNullable<z.ZodString>;
+        rotatedAt: z.ZodNullable<z.ZodString>;
+        revokedAt: z.ZodNullable<z.ZodString>;
+        url: z.ZodNullable<z.ZodString>;
+        urlIsLive: z.ZodBoolean;
+    }, z.core.$strip>;
+    lastRun: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodEnum<{
+            completed: "completed";
+            failed: "failed";
+            skipped: "skipped";
+            queued: "queued";
+            running: "running";
+            completed_with_warnings: "completed_with_warnings";
+            empty: "empty";
+        }>;
+        trigger: z.ZodEnum<{
+            scheduled: "scheduled";
+            manual: "manual";
+        }>;
+        startedAt: z.ZodNullable<z.ZodString>;
+        finishedAt: z.ZodNullable<z.ZodString>;
+        emittedCount: z.ZodNumber;
+        skippedCount: z.ZodNumber;
+        warningCount: z.ZodNumber;
+        failureCode: z.ZodNullable<z.ZodEnum<{
+            unbound_template_fields: "unbound_template_fields";
+            unknown_attribute: "unknown_attribute";
+            channel_unavailable: "channel_unavailable";
+            storefront_url_unconfigured: "storefront_url_unconfigured";
+            price_list_unavailable: "price_list_unavailable";
+            language_unavailable: "language_unavailable";
+            skip_threshold_exceeded: "skip_threshold_exceeded";
+            storage_unavailable: "storage_unavailable";
+            worker_lost: "worker_lost";
+            internal_error: "internal_error";
+        }>>;
+    }, z.core.$strip>>;
+    nextRunAt: z.ZodNullable<z.ZodString>;
+    publishedArtefactId: z.ZodNullable<z.ZodString>;
+    publishedItemCount: z.ZodNullable<z.ZodNumber>;
+    publishedAt: z.ZodNullable<z.ZodString>;
+    isRunning: z.ZodBoolean;
+    scheduleTooTightWarning: z.ZodBoolean;
+    version: z.ZodNumber;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type ProductFeed = z.infer<typeof productFeedSchema>;
+export declare const createProductFeedRequestSchema: z.ZodObject<{
+    name: z.ZodString;
+    slug: z.ZodString;
+    feedTemplateId: z.ZodString;
+    salesChannelId: z.ZodString;
+    languageCode: z.ZodString;
+    currencyCode: z.ZodString;
+    priceListId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    pricePresentation: z.ZodDefault<z.ZodEnum<{
+        net: "net";
+        gross: "gross";
+    }>>;
+    taxCountry: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    selectionRule: z.ZodDefault<z.ZodType<ProductSelectionRule, unknown, z.core.$ZodTypeInternals<ProductSelectionRule, unknown>>>;
+    schedule: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        cron: z.ZodString;
+        timezone: z.ZodString;
+    }, z.core.$strip>>>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type CreateProductFeedRequest = z.infer<typeof createProductFeedRequestSchema>;
+/**
+ * A PATCH carries only what the operator changed.
+ *
+ * The defaulted keys are re-declared without their defaults on purpose:
+ * `z.object().partial()` makes a key optional but does **not** remove its
+ * `.default()`, so a plain `.partial()` would inject `pricePresentation:
+ * 'gross'`, `selectionRule: {kind:'all'}`, `schedule: null` and `enabled: true`
+ * into every PATCH body. Renaming a feed would then silently flip it to gross
+ * prices (and fail cross-field validation for want of a `taxCountry`), reset
+ * its criteria and drop its schedule.
+ */
+export declare const updateProductFeedRequestSchema: z.ZodObject<{
+    languageCode: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    salesChannelId: z.ZodOptional<z.ZodString>;
+    slug: z.ZodOptional<z.ZodString>;
+    priceListId: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+    currencyCode: z.ZodOptional<z.ZodString>;
+    taxCountry: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+    feedTemplateId: z.ZodOptional<z.ZodString>;
+    pricePresentation: z.ZodOptional<z.ZodEnum<{
+        net: "net";
+        gross: "gross";
+    }>>;
+    selectionRule: z.ZodOptional<z.ZodType<ProductSelectionRule, unknown, z.core.$ZodTypeInternals<ProductSelectionRule, unknown>>>;
+    schedule: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        cron: z.ZodString;
+        timezone: z.ZodString;
+    }, z.core.$strip>>>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type UpdateProductFeedRequest = z.infer<typeof updateProductFeedRequestSchema>;
+export declare const duplicateProductFeedRequestSchema: z.ZodObject<{
+    name: z.ZodString;
+    slug: z.ZodString;
+    languageCode: z.ZodOptional<z.ZodString>;
+    currencyCode: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type DuplicateProductFeedRequest = z.infer<typeof duplicateProductFeedRequestSchema>;
+export declare const productFeedResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        slug: z.ZodString;
+        feedTemplateId: z.ZodString;
+        feedTemplateName: z.ZodString;
+        salesChannelId: z.ZodString;
+        salesChannelCode: z.ZodString;
+        languageCode: z.ZodString;
+        currencyCode: z.ZodString;
+        priceListId: z.ZodNullable<z.ZodString>;
+        pricePresentation: z.ZodEnum<{
+            net: "net";
+            gross: "gross";
+        }>;
+        taxCountry: z.ZodNullable<z.ZodString>;
+        selectionRule: z.ZodType<ProductSelectionRule, unknown, z.core.$ZodTypeInternals<ProductSelectionRule, unknown>>;
+        schedule: z.ZodNullable<z.ZodObject<{
+            cron: z.ZodString;
+            timezone: z.ZodString;
+        }, z.core.$strip>>;
+        enabled: z.ZodBoolean;
+        token: z.ZodObject<{
+            prefix: z.ZodNullable<z.ZodString>;
+            rotatedAt: z.ZodNullable<z.ZodString>;
+            revokedAt: z.ZodNullable<z.ZodString>;
+            url: z.ZodNullable<z.ZodString>;
+            urlIsLive: z.ZodBoolean;
+        }, z.core.$strip>;
+        lastRun: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            status: z.ZodEnum<{
+                completed: "completed";
+                failed: "failed";
+                skipped: "skipped";
+                queued: "queued";
+                running: "running";
+                completed_with_warnings: "completed_with_warnings";
+                empty: "empty";
+            }>;
+            trigger: z.ZodEnum<{
+                scheduled: "scheduled";
+                manual: "manual";
+            }>;
+            startedAt: z.ZodNullable<z.ZodString>;
+            finishedAt: z.ZodNullable<z.ZodString>;
+            emittedCount: z.ZodNumber;
+            skippedCount: z.ZodNumber;
+            warningCount: z.ZodNumber;
+            failureCode: z.ZodNullable<z.ZodEnum<{
+                unbound_template_fields: "unbound_template_fields";
+                unknown_attribute: "unknown_attribute";
+                channel_unavailable: "channel_unavailable";
+                storefront_url_unconfigured: "storefront_url_unconfigured";
+                price_list_unavailable: "price_list_unavailable";
+                language_unavailable: "language_unavailable";
+                skip_threshold_exceeded: "skip_threshold_exceeded";
+                storage_unavailable: "storage_unavailable";
+                worker_lost: "worker_lost";
+                internal_error: "internal_error";
+            }>>;
+        }, z.core.$strip>>;
+        nextRunAt: z.ZodNullable<z.ZodString>;
+        publishedArtefactId: z.ZodNullable<z.ZodString>;
+        publishedItemCount: z.ZodNullable<z.ZodNumber>;
+        publishedAt: z.ZodNullable<z.ZodString>;
+        isRunning: z.ZodBoolean;
+        scheduleTooTightWarning: z.ZodBoolean;
+        version: z.ZodNumber;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const productFeedListResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        slug: z.ZodString;
+        feedTemplateId: z.ZodString;
+        feedTemplateName: z.ZodString;
+        salesChannelId: z.ZodString;
+        salesChannelCode: z.ZodString;
+        languageCode: z.ZodString;
+        currencyCode: z.ZodString;
+        priceListId: z.ZodNullable<z.ZodString>;
+        pricePresentation: z.ZodEnum<{
+            net: "net";
+            gross: "gross";
+        }>;
+        taxCountry: z.ZodNullable<z.ZodString>;
+        selectionRule: z.ZodType<ProductSelectionRule, unknown, z.core.$ZodTypeInternals<ProductSelectionRule, unknown>>;
+        schedule: z.ZodNullable<z.ZodObject<{
+            cron: z.ZodString;
+            timezone: z.ZodString;
+        }, z.core.$strip>>;
+        enabled: z.ZodBoolean;
+        token: z.ZodObject<{
+            prefix: z.ZodNullable<z.ZodString>;
+            rotatedAt: z.ZodNullable<z.ZodString>;
+            revokedAt: z.ZodNullable<z.ZodString>;
+            url: z.ZodNullable<z.ZodString>;
+            urlIsLive: z.ZodBoolean;
+        }, z.core.$strip>;
+        lastRun: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            status: z.ZodEnum<{
+                completed: "completed";
+                failed: "failed";
+                skipped: "skipped";
+                queued: "queued";
+                running: "running";
+                completed_with_warnings: "completed_with_warnings";
+                empty: "empty";
+            }>;
+            trigger: z.ZodEnum<{
+                scheduled: "scheduled";
+                manual: "manual";
+            }>;
+            startedAt: z.ZodNullable<z.ZodString>;
+            finishedAt: z.ZodNullable<z.ZodString>;
+            emittedCount: z.ZodNumber;
+            skippedCount: z.ZodNumber;
+            warningCount: z.ZodNumber;
+            failureCode: z.ZodNullable<z.ZodEnum<{
+                unbound_template_fields: "unbound_template_fields";
+                unknown_attribute: "unknown_attribute";
+                channel_unavailable: "channel_unavailable";
+                storefront_url_unconfigured: "storefront_url_unconfigured";
+                price_list_unavailable: "price_list_unavailable";
+                language_unavailable: "language_unavailable";
+                skip_threshold_exceeded: "skip_threshold_exceeded";
+                storage_unavailable: "storage_unavailable";
+                worker_lost: "worker_lost";
+                internal_error: "internal_error";
+            }>>;
+        }, z.core.$strip>>;
+        nextRunAt: z.ZodNullable<z.ZodString>;
+        publishedArtefactId: z.ZodNullable<z.ZodString>;
+        publishedItemCount: z.ZodNullable<z.ZodNumber>;
+        publishedAt: z.ZodNullable<z.ZodString>;
+        isRunning: z.ZodBoolean;
+        scheduleTooTightWarning: z.ZodBoolean;
+        version: z.ZodNumber;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>>;
+    pagination: z.ZodObject<{
+        cursor: z.ZodNullable<z.ZodString>;
+        hasMore: z.ZodBoolean;
+        limit: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/** Returned exactly once, on create and on rotate. Never re-readable (FR-047). */
+export declare const productFeedTokenIssuedResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        token: z.ZodString;
+        url: z.ZodString;
+        prefix: z.ZodString;
+        rotatedAt: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * Match count for a criteria set **before saving** (FR-028).
+ *
+ * Draft-shaped by construction: it takes a channel and a rule, never a feed id,
+ * so the count works on `/product-feeds/new` where no feed exists yet and on an
+ * edited-but-unsaved criteria panel. Side-effect-free.
+ */
+export declare const productSelectionPreviewRequestSchema: z.ZodObject<{
+    salesChannelId: z.ZodString;
+    selectionRule: z.ZodType<ProductSelectionRule, unknown, z.core.$ZodTypeInternals<ProductSelectionRule, unknown>>;
+}, z.core.$strip>;
+export declare const productSelectionPreviewResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        matchedCount: z.ZodNumber;
+        sample: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            sku: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const feedRunIssueSchema: z.ZodObject<{
+    id: z.ZodString;
+    severity: z.ZodEnum<{
+        warning: "warning";
+        skip: "skip";
+    }>;
+    reason: z.ZodEnum<{
+        missing_price: "missing_price";
+        missing_image: "missing_image";
+        private_image_asset: "private_image_asset";
+        missing_required_field: "missing_required_field";
+        missing_translation: "missing_translation";
+        unresolvable_link: "unresolvable_link";
+        unmapped_provider_category: "unmapped_provider_category";
+        stale_provider_category_mapping: "stale_provider_category_mapping";
+        unsupported_product_type: "unsupported_product_type";
+        zero_tax_rate_on_gross_feed: "zero_tax_rate_on_gross_feed";
+    }>;
+    productId: z.ZodNullable<z.ZodString>;
+    variantId: z.ZodNullable<z.ZodString>;
+    sku: z.ZodNullable<z.ZodString>;
+    outputName: z.ZodNullable<z.ZodString>;
+    detail: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type FeedRunIssue = z.infer<typeof feedRunIssueSchema>;
+export declare const feedRunSchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        completed: "completed";
+        failed: "failed";
+        skipped: "skipped";
+        queued: "queued";
+        running: "running";
+        completed_with_warnings: "completed_with_warnings";
+        empty: "empty";
+    }>;
+    trigger: z.ZodEnum<{
+        scheduled: "scheduled";
+        manual: "manual";
+    }>;
+    startedAt: z.ZodNullable<z.ZodString>;
+    finishedAt: z.ZodNullable<z.ZodString>;
+    emittedCount: z.ZodNumber;
+    skippedCount: z.ZodNumber;
+    warningCount: z.ZodNumber;
+    failureCode: z.ZodNullable<z.ZodEnum<{
+        unbound_template_fields: "unbound_template_fields";
+        unknown_attribute: "unknown_attribute";
+        channel_unavailable: "channel_unavailable";
+        storefront_url_unconfigured: "storefront_url_unconfigured";
+        price_list_unavailable: "price_list_unavailable";
+        language_unavailable: "language_unavailable";
+        skip_threshold_exceeded: "skip_threshold_exceeded";
+        storage_unavailable: "storage_unavailable";
+        worker_lost: "worker_lost";
+        internal_error: "internal_error";
+    }>>;
+    productFeedId: z.ZodString;
+    triggeredByAdminUserId: z.ZodNullable<z.ZodString>;
+    consideredCount: z.ZodNumber;
+    durationMs: z.ZodNullable<z.ZodNumber>;
+    failureDetail: z.ZodNullable<z.ZodString>;
+    skipReason: z.ZodNullable<z.ZodEnum<{
+        already_running: "already_running";
+        feed_disabled: "feed_disabled";
+    }>>;
+    issueOverflow: z.ZodBoolean;
+    artefact: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        byteSize: z.ZodNumber;
+        itemCount: z.ZodNumber;
+        contentType: z.ZodString;
+        producedAt: z.ZodString;
+        isPublished: z.ZodBoolean;
+    }, z.core.$strip>>;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type FeedRun = z.infer<typeof feedRunSchema>;
+export declare const feedRunResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodEnum<{
+            completed: "completed";
+            failed: "failed";
+            skipped: "skipped";
+            queued: "queued";
+            running: "running";
+            completed_with_warnings: "completed_with_warnings";
+            empty: "empty";
+        }>;
+        trigger: z.ZodEnum<{
+            scheduled: "scheduled";
+            manual: "manual";
+        }>;
+        startedAt: z.ZodNullable<z.ZodString>;
+        finishedAt: z.ZodNullable<z.ZodString>;
+        emittedCount: z.ZodNumber;
+        skippedCount: z.ZodNumber;
+        warningCount: z.ZodNumber;
+        failureCode: z.ZodNullable<z.ZodEnum<{
+            unbound_template_fields: "unbound_template_fields";
+            unknown_attribute: "unknown_attribute";
+            channel_unavailable: "channel_unavailable";
+            storefront_url_unconfigured: "storefront_url_unconfigured";
+            price_list_unavailable: "price_list_unavailable";
+            language_unavailable: "language_unavailable";
+            skip_threshold_exceeded: "skip_threshold_exceeded";
+            storage_unavailable: "storage_unavailable";
+            worker_lost: "worker_lost";
+            internal_error: "internal_error";
+        }>>;
+        productFeedId: z.ZodString;
+        triggeredByAdminUserId: z.ZodNullable<z.ZodString>;
+        consideredCount: z.ZodNumber;
+        durationMs: z.ZodNullable<z.ZodNumber>;
+        failureDetail: z.ZodNullable<z.ZodString>;
+        skipReason: z.ZodNullable<z.ZodEnum<{
+            already_running: "already_running";
+            feed_disabled: "feed_disabled";
+        }>>;
+        issueOverflow: z.ZodBoolean;
+        artefact: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            byteSize: z.ZodNumber;
+            itemCount: z.ZodNumber;
+            contentType: z.ZodString;
+            producedAt: z.ZodString;
+            isPublished: z.ZodBoolean;
+        }, z.core.$strip>>;
+        createdAt: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const feedRunListResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodEnum<{
+            completed: "completed";
+            failed: "failed";
+            skipped: "skipped";
+            queued: "queued";
+            running: "running";
+            completed_with_warnings: "completed_with_warnings";
+            empty: "empty";
+        }>;
+        trigger: z.ZodEnum<{
+            scheduled: "scheduled";
+            manual: "manual";
+        }>;
+        startedAt: z.ZodNullable<z.ZodString>;
+        finishedAt: z.ZodNullable<z.ZodString>;
+        emittedCount: z.ZodNumber;
+        skippedCount: z.ZodNumber;
+        warningCount: z.ZodNumber;
+        failureCode: z.ZodNullable<z.ZodEnum<{
+            unbound_template_fields: "unbound_template_fields";
+            unknown_attribute: "unknown_attribute";
+            channel_unavailable: "channel_unavailable";
+            storefront_url_unconfigured: "storefront_url_unconfigured";
+            price_list_unavailable: "price_list_unavailable";
+            language_unavailable: "language_unavailable";
+            skip_threshold_exceeded: "skip_threshold_exceeded";
+            storage_unavailable: "storage_unavailable";
+            worker_lost: "worker_lost";
+            internal_error: "internal_error";
+        }>>;
+        productFeedId: z.ZodString;
+        triggeredByAdminUserId: z.ZodNullable<z.ZodString>;
+        consideredCount: z.ZodNumber;
+        durationMs: z.ZodNullable<z.ZodNumber>;
+        failureDetail: z.ZodNullable<z.ZodString>;
+        skipReason: z.ZodNullable<z.ZodEnum<{
+            already_running: "already_running";
+            feed_disabled: "feed_disabled";
+        }>>;
+        issueOverflow: z.ZodBoolean;
+        artefact: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            byteSize: z.ZodNumber;
+            itemCount: z.ZodNumber;
+            contentType: z.ZodString;
+            producedAt: z.ZodString;
+            isPublished: z.ZodBoolean;
+        }, z.core.$strip>>;
+        createdAt: z.ZodString;
+    }, z.core.$strip>>;
+    pagination: z.ZodObject<{
+        cursor: z.ZodNullable<z.ZodString>;
+        hasMore: z.ZodBoolean;
+        limit: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const feedRunIssueListResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        severity: z.ZodEnum<{
+            warning: "warning";
+            skip: "skip";
+        }>;
+        reason: z.ZodEnum<{
+            missing_price: "missing_price";
+            missing_image: "missing_image";
+            private_image_asset: "private_image_asset";
+            missing_required_field: "missing_required_field";
+            missing_translation: "missing_translation";
+            unresolvable_link: "unresolvable_link";
+            unmapped_provider_category: "unmapped_provider_category";
+            stale_provider_category_mapping: "stale_provider_category_mapping";
+            unsupported_product_type: "unsupported_product_type";
+            zero_tax_rate_on_gross_feed: "zero_tax_rate_on_gross_feed";
+        }>;
+        productId: z.ZodNullable<z.ZodString>;
+        variantId: z.ZodNullable<z.ZodString>;
+        sku: z.ZodNullable<z.ZodString>;
+        outputName: z.ZodNullable<z.ZodString>;
+        detail: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    pagination: z.ZodObject<{
+        cursor: z.ZodNullable<z.ZodString>;
+        hasMore: z.ZodBoolean;
+        limit: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const feedRunListQuerySchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    cursor: z.ZodOptional<z.ZodString>;
+    sort: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        completed: "completed";
+        failed: "failed";
+        skipped: "skipped";
+        queued: "queued";
+        running: "running";
+        completed_with_warnings: "completed_with_warnings";
+        empty: "empty";
+    }>>;
+}, z.core.$strip>;
+/** Accepted-and-enqueued acknowledgement; the work never runs inline (FR-032). */
+export declare const startFeedRunResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        runId: z.ZodString;
+        status: z.ZodLiteral<"queued">;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const feedTaxonomySchema: z.ZodObject<{
+    providerCode: z.ZodEnum<{
+        meta: "meta";
+        google_merchant: "google_merchant";
+    }>;
+    revision: z.ZodString;
+    nodeCount: z.ZodNumber;
+    installedAt: z.ZodString;
+}, z.core.$strip>;
+export type FeedTaxonomy = z.infer<typeof feedTaxonomySchema>;
+export declare const feedTaxonomyNodeSchema: z.ZodObject<{
+    externalId: z.ZodString;
+    parentExternalId: z.ZodNullable<z.ZodString>;
+    label: z.ZodString;
+    fullPath: z.ZodString;
+    depth: z.ZodNumber;
+}, z.core.$strip>;
+export type FeedTaxonomyNode = z.infer<typeof feedTaxonomyNodeSchema>;
+export declare const feedTaxonomyNodeSearchQuerySchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    cursor: z.ZodOptional<z.ZodString>;
+    sort: z.ZodOptional<z.ZodString>;
+    providerCode: z.ZodEnum<{
+        meta: "meta";
+        google_merchant: "google_merchant";
+    }>;
+    q: z.ZodOptional<z.ZodString>;
+    lang: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const feedTaxonomyMappingSchema: z.ZodObject<{
+    categoryId: z.ZodString;
+    categoryName: z.ZodString;
+    categoryDepth: z.ZodNumber;
+    nodeExternalId: z.ZodNullable<z.ZodString>;
+    nodeFullPath: z.ZodNullable<z.ZodString>;
+    origin: z.ZodEnum<{
+        none: "none";
+        explicit: "explicit";
+        inherited: "inherited";
+    }>;
+    inheritedFromCategoryId: z.ZodNullable<z.ZodString>;
+    inheritedFromCategoryName: z.ZodNullable<z.ZodString>;
+    stale: z.ZodBoolean;
+}, z.core.$strip>;
+export type FeedTaxonomyMapping = z.infer<typeof feedTaxonomyMappingSchema>;
+export declare const setFeedTaxonomyMappingRequestSchema: z.ZodObject<{
+    providerCode: z.ZodEnum<{
+        meta: "meta";
+        google_merchant: "google_merchant";
+    }>;
+    categoryId: z.ZodString;
+    nodeExternalId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type SetFeedTaxonomyMappingRequest = z.infer<typeof setFeedTaxonomyMappingRequestSchema>;
+export declare const feedTaxonomyMappingListResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        categoryId: z.ZodString;
+        categoryName: z.ZodString;
+        categoryDepth: z.ZodNumber;
+        nodeExternalId: z.ZodNullable<z.ZodString>;
+        nodeFullPath: z.ZodNullable<z.ZodString>;
+        origin: z.ZodEnum<{
+            none: "none";
+            explicit: "explicit";
+            inherited: "inherited";
+        }>;
+        inheritedFromCategoryId: z.ZodNullable<z.ZodString>;
+        inheritedFromCategoryName: z.ZodNullable<z.ZodString>;
+        stale: z.ZodBoolean;
+    }, z.core.$strip>>;
+    pagination: z.ZodObject<{
+        cursor: z.ZodNullable<z.ZodString>;
+        hasMore: z.ZodBoolean;
+        limit: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/** Coverage summary shown above the mapping surface (FR-079). */
+export declare const feedTaxonomyCoverageResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        providerCode: z.ZodEnum<{
+            meta: "meta";
+            google_merchant: "google_merchant";
+        }>;
+        revision: z.ZodString;
+        totalCategories: z.ZodNumber;
+        explicitlyMapped: z.ZodNumber;
+        coveredByInheritance: z.ZodNumber;
+        uncovered: z.ZodNumber;
+        staleMappings: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/** Where a revision came from (FR-078). Both kinds are the same object to the operator. */
+export declare const feedTaxonomyRevisionSourceSchema: z.ZodEnum<{
+    bundled: "bundled";
+    fetched: "fetched";
+}>;
+export type FeedTaxonomyRevisionSource = z.infer<typeof feedTaxonomyRevisionSourceSchema>;
+/**
+ * Advisory markers rendered on the revisions list. `shrink` = the node count
+ * collapsed against the revision in force; the revision is still installed,
+ * because a valid smaller taxonomy is the provider's decision to make and the
+ * impact preview is where it becomes visible (research §R22).
+ */
+export declare const feedTaxonomyRevisionFlagSchema: z.ZodEnum<{
+    shrink: "shrink";
+}>;
+export type FeedTaxonomyRevisionFlag = z.infer<typeof feedTaxonomyRevisionFlagSchema>;
+export declare const feedTaxonomyRevisionSchema: z.ZodObject<{
+    id: z.ZodString;
+    providerCode: z.ZodEnum<{
+        meta: "meta";
+        google_merchant: "google_merchant";
+    }>;
+    revision: z.ZodString;
+    isCurrent: z.ZodBoolean;
+    nodeCount: z.ZodNumber;
+    source: z.ZodEnum<{
+        bundled: "bundled";
+        fetched: "fetched";
+    }>;
+    sourceUrls: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    installedAt: z.ZodString;
+    fetchedAt: z.ZodNullable<z.ZodString>;
+    promotedAt: z.ZodNullable<z.ZodString>;
+    supersededAt: z.ZodNullable<z.ZodString>;
+    flags: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        shrink: "shrink";
+    }>>>;
+}, z.core.$strip>;
+export type FeedTaxonomyRevision = z.infer<typeof feedTaxonomyRevisionSchema>;
+export declare const feedTaxonomyRevisionListResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        providerCode: z.ZodEnum<{
+            meta: "meta";
+            google_merchant: "google_merchant";
+        }>;
+        revision: z.ZodString;
+        isCurrent: z.ZodBoolean;
+        nodeCount: z.ZodNumber;
+        source: z.ZodEnum<{
+            bundled: "bundled";
+            fetched: "fetched";
+        }>;
+        sourceUrls: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+        installedAt: z.ZodString;
+        fetchedAt: z.ZodNullable<z.ZodString>;
+        promotedAt: z.ZodNullable<z.ZodString>;
+        supersededAt: z.ZodNullable<z.ZodString>;
+        flags: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            shrink: "shrink";
+        }>>>;
+    }, z.core.$strip>>;
+    pagination: z.ZodObject<{
+        cursor: z.ZodNullable<z.ZodString>;
+        hasMore: z.ZodBoolean;
+        limit: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const feedTaxonomyRevisionResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        id: z.ZodString;
+        providerCode: z.ZodEnum<{
+            meta: "meta";
+            google_merchant: "google_merchant";
+        }>;
+        revision: z.ZodString;
+        isCurrent: z.ZodBoolean;
+        nodeCount: z.ZodNumber;
+        source: z.ZodEnum<{
+            bundled: "bundled";
+            fetched: "fetched";
+        }>;
+        sourceUrls: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+        installedAt: z.ZodString;
+        fetchedAt: z.ZodNullable<z.ZodString>;
+        promotedAt: z.ZodNullable<z.ZodString>;
+        supersededAt: z.ZodNullable<z.ZodString>;
+        flags: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            shrink: "shrink";
+        }>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/** One shop category that changes state if the candidate is promoted (FR-094). */
+export declare const feedTaxonomyImpactCategorySchema: z.ZodObject<{
+    categoryId: z.ZodString;
+    categoryName: z.ZodString;
+    nodeExternalId: z.ZodString;
+    nodeFullPath: z.ZodNullable<z.ZodString>;
+    effect: z.ZodEnum<{
+        becomes_stale: "becomes_stale";
+        becomes_live: "becomes_live";
+        loses_coverage: "loses_coverage";
+    }>;
+    descendantsLosingCoverage: z.ZodNumber;
+}, z.core.$strip>;
+export type FeedTaxonomyImpactCategory = z.infer<typeof feedTaxonomyImpactCategorySchema>;
+export declare const feedTaxonomyRevisionImpactResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        providerCode: z.ZodEnum<{
+            meta: "meta";
+            google_merchant: "google_merchant";
+        }>;
+        candidateRevision: z.ZodString;
+        currentRevision: z.ZodNullable<z.ZodString>;
+        nodeCountCurrent: z.ZodNumber;
+        nodeCountCandidate: z.ZodNumber;
+        nodesAdded: z.ZodNumber;
+        nodesRemoved: z.ZodNumber;
+        mappings: z.ZodObject<{
+            total: z.ZodNumber;
+            wouldRemainLive: z.ZodNumber;
+            wouldBecomeStale: z.ZodNumber;
+            wouldBecomeLive: z.ZodNumber;
+        }, z.core.$strip>;
+        categories: z.ZodObject<{
+            total: z.ZodNumber;
+            coveredNow: z.ZodNumber;
+            coveredAfter: z.ZodNumber;
+            losingCoverage: z.ZodNumber;
+        }, z.core.$strip>;
+        affected: z.ZodArray<z.ZodObject<{
+            categoryId: z.ZodString;
+            categoryName: z.ZodString;
+            nodeExternalId: z.ZodString;
+            nodeFullPath: z.ZodNullable<z.ZodString>;
+            effect: z.ZodEnum<{
+                becomes_stale: "becomes_stale";
+                becomes_live: "becomes_live";
+                loses_coverage: "loses_coverage";
+            }>;
+            descendantsLosingCoverage: z.ZodNumber;
+        }, z.core.$strip>>;
+        affectedTruncated: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const promoteFeedTaxonomyRevisionRequestSchema: z.ZodObject<{
+    expectedStaleMappingCount: z.ZodNumber;
+}, z.core.$strip>;
+export type PromoteFeedTaxonomyRevisionRequest = z.infer<typeof promoteFeedTaxonomyRevisionRequestSchema>;
+export declare const feedTaxonomyCheckTriggerSchema: z.ZodEnum<{
+    scheduled: "scheduled";
+    manual: "manual";
+}>;
+export type FeedTaxonomyCheckTrigger = z.infer<typeof feedTaxonomyCheckTriggerSchema>;
+export declare const feedTaxonomyCheckOutcomeSchema: z.ZodEnum<{
+    failed: "failed";
+    installed: "installed";
+    rejected: "rejected";
+    unchanged: "unchanged";
+}>;
+export type FeedTaxonomyCheckOutcome = z.infer<typeof feedTaxonomyCheckOutcomeSchema>;
+/** Why a check did not install anything. Closed set — the admin renders a translated line per value. */
+export declare const feedTaxonomyCheckReasonSchema: z.ZodEnum<{
+    not_found: "not_found";
+    truncated: "truncated";
+    empty: "empty";
+    transport: "transport";
+    http_status: "http_status";
+    not_taxonomy: "not_taxonomy";
+    too_large: "too_large";
+    no_nodes: "no_nodes";
+    implausible: "implausible";
+    incomplete_languages: "incomplete_languages";
+}>;
+export type FeedTaxonomyCheckReason = z.infer<typeof feedTaxonomyCheckReasonSchema>;
+export declare const feedTaxonomyCheckSchema: z.ZodObject<{
+    id: z.ZodString;
+    providerCode: z.ZodEnum<{
+        meta: "meta";
+        google_merchant: "google_merchant";
+    }>;
+    trigger: z.ZodEnum<{
+        scheduled: "scheduled";
+        manual: "manual";
+    }>;
+    startedAt: z.ZodString;
+    finishedAt: z.ZodNullable<z.ZodString>;
+    outcome: z.ZodNullable<z.ZodEnum<{
+        failed: "failed";
+        installed: "installed";
+        rejected: "rejected";
+        unchanged: "unchanged";
+    }>>;
+    reason: z.ZodNullable<z.ZodEnum<{
+        not_found: "not_found";
+        truncated: "truncated";
+        empty: "empty";
+        transport: "transport";
+        http_status: "http_status";
+        not_taxonomy: "not_taxonomy";
+        too_large: "too_large";
+        no_nodes: "no_nodes";
+        implausible: "implausible";
+        incomplete_languages: "incomplete_languages";
+    }>>;
+    detail: z.ZodNullable<z.ZodString>;
+    httpStatus: z.ZodNullable<z.ZodNumber>;
+    bytesRead: z.ZodNullable<z.ZodNumber>;
+    contentHash: z.ZodNullable<z.ZodString>;
+    installedTaxonomyId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type FeedTaxonomyCheck = z.infer<typeof feedTaxonomyCheckSchema>;
+export declare const feedTaxonomyCheckListResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        providerCode: z.ZodEnum<{
+            meta: "meta";
+            google_merchant: "google_merchant";
+        }>;
+        trigger: z.ZodEnum<{
+            scheduled: "scheduled";
+            manual: "manual";
+        }>;
+        startedAt: z.ZodString;
+        finishedAt: z.ZodNullable<z.ZodString>;
+        outcome: z.ZodNullable<z.ZodEnum<{
+            failed: "failed";
+            installed: "installed";
+            rejected: "rejected";
+            unchanged: "unchanged";
+        }>>;
+        reason: z.ZodNullable<z.ZodEnum<{
+            not_found: "not_found";
+            truncated: "truncated";
+            empty: "empty";
+            transport: "transport";
+            http_status: "http_status";
+            not_taxonomy: "not_taxonomy";
+            too_large: "too_large";
+            no_nodes: "no_nodes";
+            implausible: "implausible";
+            incomplete_languages: "incomplete_languages";
+        }>>;
+        detail: z.ZodNullable<z.ZodString>;
+        httpStatus: z.ZodNullable<z.ZodNumber>;
+        bytesRead: z.ZodNullable<z.ZodNumber>;
+        contentHash: z.ZodNullable<z.ZodString>;
+        installedTaxonomyId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    pagination: z.ZodObject<{
+        cursor: z.ZodNullable<z.ZodString>;
+        hasMore: z.ZodBoolean;
+        limit: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const feedTaxonomyCheckResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        id: z.ZodString;
+        providerCode: z.ZodEnum<{
+            meta: "meta";
+            google_merchant: "google_merchant";
+        }>;
+        trigger: z.ZodEnum<{
+            scheduled: "scheduled";
+            manual: "manual";
+        }>;
+        startedAt: z.ZodString;
+        finishedAt: z.ZodNullable<z.ZodString>;
+        outcome: z.ZodNullable<z.ZodEnum<{
+            failed: "failed";
+            installed: "installed";
+            rejected: "rejected";
+            unchanged: "unchanged";
+        }>>;
+        reason: z.ZodNullable<z.ZodEnum<{
+            not_found: "not_found";
+            truncated: "truncated";
+            empty: "empty";
+            transport: "transport";
+            http_status: "http_status";
+            not_taxonomy: "not_taxonomy";
+            too_large: "too_large";
+            no_nodes: "no_nodes";
+            implausible: "implausible";
+            incomplete_languages: "incomplete_languages";
+        }>>;
+        detail: z.ZodNullable<z.ZodString>;
+        httpStatus: z.ZodNullable<z.ZodNumber>;
+        bytesRead: z.ZodNullable<z.ZodNumber>;
+        contentHash: z.ZodNullable<z.ZodString>;
+        installedTaxonomyId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const startFeedTaxonomyCheckRequestSchema: z.ZodObject<{
+    providerCode: z.ZodEnum<{
+        meta: "meta";
+        google_merchant: "google_merchant";
+    }>;
+}, z.core.$strip>;
+export type StartFeedTaxonomyCheckRequest = z.infer<typeof startFeedTaxonomyCheckRequestSchema>;
+/**
+ * Source-URL validation, applied at settings-write time AND again immediately
+ * before the request (FR-091). Twice, because settings can also be written by a
+ * seed, a migration or an overlay, so the request-time check is the one that
+ * actually holds. The address-range and redirect checks are NOT expressible in
+ * Zod and live in the fetcher — see research §R23.
+ */
+export declare const feedTaxonomySourceUrlSchema: z.ZodString;
+export declare const FEED_TEMPLATE_DOCUMENT_FORMAT_VERSION = 1;
+/**
+ * Deliberately carries NO uuid, NO timestamp, NO feed binding and NO secret, so
+ * two exports of an unchanged template are byte-identical (FR-013). Bindings
+ * travel as stable definition KEYS, which is what makes cross-installation
+ * import resolvable at all.
+ */
+export declare const feedTemplateDocumentSchema: z.ZodObject<{
+    formatVersion: z.ZodLiteral<1>;
+    template: z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        providerCode: z.ZodEnum<{
+            custom: "custom";
+            meta: "meta";
+            google_merchant: "google_merchant";
+            amazon: "amazon";
+            ebay: "ebay";
+            allegro: "allegro";
+        }>;
+        outputFormat: z.ZodEnum<{
+            csv: "csv";
+            xml: "xml";
+            tsv: "tsv";
+            txt: "txt";
+            xlsx: "xlsx";
+        }>;
+        itemGranularity: z.ZodEnum<{
+            product: "product";
+            variant: "variant";
+        }>;
+        taxonomyProviderCode: z.ZodNullable<z.ZodEnum<{
+            meta: "meta";
+            google_merchant: "google_merchant";
+        }>>;
+        fields: z.ZodArray<z.ZodObject<{
+            outputName: z.ZodString;
+            sourceKind: z.ZodEnum<{
+                description: "description";
+                link: "link";
+                name: "name";
+                slug: "slug";
+                availability: "availability";
+                price: "price";
+                sku: "sku";
+                attribute: "attribute";
+                product_id: "product_id";
+                product_type: "product_type";
+                brand: "brand";
+                custom_field: "custom_field";
+                sale_price: "sale_price";
+                stock_quantity: "stock_quantity";
+                image_link: "image_link";
+                additional_image_link: "additional_image_link";
+                category_path: "category_path";
+                provider_category: "provider_category";
+                grouping_id: "grouping_id";
+                constant: "constant";
+            }>;
+            sourceKey: z.ZodNullable<z.ZodString>;
+            constantValue: z.ZodNullable<z.ZodString>;
+            fallbackValue: z.ZodNullable<z.ZodString>;
+            providerRequired: z.ZodBoolean;
+            transform: z.ZodNullable<z.ZodEnum<{
+                trim: "trim";
+                none: "none";
+                upper: "upper";
+                lower: "lower";
+                truncate: "truncate";
+                strip_html: "strip_html";
+                absolute_url: "absolute_url";
+            }>>;
+            transformArg: z.ZodNullable<z.ZodString>;
+            sortOrder: z.ZodNumber;
+            helpKey: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type FeedTemplateDocument = z.infer<typeof feedTemplateDocumentSchema>;
+export declare const importFeedTemplateRequestSchema: z.ZodObject<{
+    document: z.ZodObject<{
+        formatVersion: z.ZodLiteral<1>;
+        template: z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodNullable<z.ZodString>;
+            providerCode: z.ZodEnum<{
+                custom: "custom";
+                meta: "meta";
+                google_merchant: "google_merchant";
+                amazon: "amazon";
+                ebay: "ebay";
+                allegro: "allegro";
+            }>;
+            outputFormat: z.ZodEnum<{
+                csv: "csv";
+                xml: "xml";
+                tsv: "tsv";
+                txt: "txt";
+                xlsx: "xlsx";
+            }>;
+            itemGranularity: z.ZodEnum<{
+                product: "product";
+                variant: "variant";
+            }>;
+            taxonomyProviderCode: z.ZodNullable<z.ZodEnum<{
+                meta: "meta";
+                google_merchant: "google_merchant";
+            }>>;
+            fields: z.ZodArray<z.ZodObject<{
+                outputName: z.ZodString;
+                sourceKind: z.ZodEnum<{
+                    description: "description";
+                    link: "link";
+                    name: "name";
+                    slug: "slug";
+                    availability: "availability";
+                    price: "price";
+                    sku: "sku";
+                    attribute: "attribute";
+                    product_id: "product_id";
+                    product_type: "product_type";
+                    brand: "brand";
+                    custom_field: "custom_field";
+                    sale_price: "sale_price";
+                    stock_quantity: "stock_quantity";
+                    image_link: "image_link";
+                    additional_image_link: "additional_image_link";
+                    category_path: "category_path";
+                    provider_category: "provider_category";
+                    grouping_id: "grouping_id";
+                    constant: "constant";
+                }>;
+                sourceKey: z.ZodNullable<z.ZodString>;
+                constantValue: z.ZodNullable<z.ZodString>;
+                fallbackValue: z.ZodNullable<z.ZodString>;
+                providerRequired: z.ZodBoolean;
+                transform: z.ZodNullable<z.ZodEnum<{
+                    trim: "trim";
+                    none: "none";
+                    upper: "upper";
+                    lower: "lower";
+                    truncate: "truncate";
+                    strip_html: "strip_html";
+                    absolute_url: "absolute_url";
+                }>>;
+                transformArg: z.ZodNullable<z.ZodString>;
+                sortOrder: z.ZodNumber;
+                helpKey: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    onNameConflict: z.ZodOptional<z.ZodEnum<{
+        replace: "replace";
+        create_copy: "create_copy";
+    }>>;
+}, z.core.$strip>;
+export type ImportFeedTemplateRequest = z.infer<typeof importFeedTemplateRequestSchema>;
+export declare const importFeedTemplateResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        template: z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodNullable<z.ZodString>;
+            providerCode: z.ZodEnum<{
+                custom: "custom";
+                meta: "meta";
+                google_merchant: "google_merchant";
+                amazon: "amazon";
+                ebay: "ebay";
+                allegro: "allegro";
+            }>;
+            outputFormat: z.ZodEnum<{
+                csv: "csv";
+                xml: "xml";
+                tsv: "tsv";
+                txt: "txt";
+                xlsx: "xlsx";
+            }>;
+            itemGranularity: z.ZodEnum<{
+                product: "product";
+                variant: "variant";
+            }>;
+            taxonomyProviderCode: z.ZodNullable<z.ZodEnum<{
+                meta: "meta";
+                google_merchant: "google_merchant";
+            }>>;
+            isSystem: z.ZodBoolean;
+            systemCode: z.ZodNullable<z.ZodString>;
+            fields: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                outputName: z.ZodString;
+                sourceKind: z.ZodEnum<{
+                    description: "description";
+                    link: "link";
+                    name: "name";
+                    slug: "slug";
+                    availability: "availability";
+                    price: "price";
+                    sku: "sku";
+                    attribute: "attribute";
+                    product_id: "product_id";
+                    product_type: "product_type";
+                    brand: "brand";
+                    custom_field: "custom_field";
+                    sale_price: "sale_price";
+                    stock_quantity: "stock_quantity";
+                    image_link: "image_link";
+                    additional_image_link: "additional_image_link";
+                    category_path: "category_path";
+                    provider_category: "provider_category";
+                    grouping_id: "grouping_id";
+                    constant: "constant";
+                }>;
+                sourceKey: z.ZodNullable<z.ZodString>;
+                constantValue: z.ZodNullable<z.ZodString>;
+                fallbackValue: z.ZodNullable<z.ZodString>;
+                providerRequired: z.ZodBoolean;
+                transform: z.ZodNullable<z.ZodEnum<{
+                    trim: "trim";
+                    none: "none";
+                    upper: "upper";
+                    lower: "lower";
+                    truncate: "truncate";
+                    strip_html: "strip_html";
+                    absolute_url: "absolute_url";
+                }>>;
+                transformArg: z.ZodNullable<z.ZodString>;
+                sortOrder: z.ZodNumber;
+                helpKey: z.ZodNullable<z.ZodString>;
+                unbound: z.ZodBoolean;
+            }, z.core.$strip>>;
+            usedByFeedCount: z.ZodNumber;
+            version: z.ZodNumber;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+        }, z.core.$strip>;
+        unresolvedBindings: z.ZodArray<z.ZodObject<{
+            outputName: z.ZodString;
+            sourceKind: z.ZodEnum<{
+                description: "description";
+                link: "link";
+                name: "name";
+                slug: "slug";
+                availability: "availability";
+                price: "price";
+                sku: "sku";
+                attribute: "attribute";
+                product_id: "product_id";
+                product_type: "product_type";
+                brand: "brand";
+                custom_field: "custom_field";
+                sale_price: "sale_price";
+                stock_quantity: "stock_quantity";
+                image_link: "image_link";
+                additional_image_link: "additional_image_link";
+                category_path: "category_path";
+                provider_category: "provider_category";
+                grouping_id: "grouping_id";
+                constant: "constant";
+            }>;
+            sourceKey: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const PRODUCT_FEED_ERROR_CODES: {
+    readonly TEMPLATE_IS_SYSTEM: "template_is_system";
+    readonly TEMPLATE_IN_USE: "template_in_use";
+    readonly DUPLICATE_OUTPUT_NAME: "duplicate_output_name";
+    readonly UNBOUND_TEMPLATE_FIELDS: "unbound_template_fields";
+    readonly TAXONOMY_REQUIRED_FOR_PROVIDER_CATEGORY: "taxonomy_required_for_provider_category";
+    readonly GROUPING_FIELD_REQUIRED_FOR_VARIANT_GRANULARITY: "grouping_field_required_for_variant_granularity";
+    readonly FEED_ALREADY_RUNNING: "feed_already_running";
+    readonly FEED_DISABLED: "feed_disabled";
+    readonly TOKEN_REVOKED: "token_revoked";
+    readonly TEMPLATE_NAME_CONFLICT: "template_name_conflict";
+    readonly INVALID_TEMPLATE_DOCUMENT: "invalid_template_document";
+    readonly UNKNOWN_TAXONOMY_NODE: "unknown_taxonomy_node";
+    /** `POST /checks` while the master switch is off (FR-087) — the response names the setting. */
+    readonly TAXONOMY_FETCH_DISABLED: "taxonomy_fetch_disabled";
+    /** A check for that provider is already in flight (FR-096). */
+    readonly TAXONOMY_CHECK_IN_PROGRESS: "taxonomy_check_in_progress";
+    /** `expectedStaleMappingCount` no longer matches the recomputed impact (FR-095). */
+    readonly IMPACT_CHANGED: "impact_changed";
+    /** The revision is already the one in force. */
+    readonly TAXONOMY_REVISION_ALREADY_CURRENT: "taxonomy_revision_already_current";
+    /** The target address is refused by the egress guard (SR-2, SR-4). */
+    readonly DELIVERY_TARGET_REFUSED: "delivery_target_refused";
+    /** `POST /delivery/test` on a feed that has no delivery configuration. */
+    readonly DELIVERY_NOT_CONFIGURED: "delivery_not_configured";
+    /** The connection test is rate-limited per feed (SR-5). */
+    readonly DELIVERY_TEST_RATE_LIMITED: "delivery_test_rate_limited";
+};
+export type ProductFeedErrorCode = (typeof PRODUCT_FEED_ERROR_CODES)[keyof typeof PRODUCT_FEED_ERROR_CODES];
+export declare const PRODUCT_FEED_SETTING_CODES: {
+    /**
+     * Feature 074 — the operator-activation control (Constitution XVII), and the
+     * only one of these codes that decides whether the module exists. It is not
+     * the same switch as `TAXONOMY_FETCH_ENABLED` below, which governs one
+     * outbound refresh inside a module that is present.
+     */
+    readonly ACTIVATION: "product_feeds.enabled";
+    readonly ARTEFACT_RETENTION_COUNT: "product_feeds.artefact_retention_count";
+    readonly MAX_CONCURRENT_RUNS: "product_feeds.max_concurrent_runs";
+    readonly SKIP_SHARE_FAILURE_THRESHOLD: "product_feeds.skip_share_failure_threshold";
+    readonly STALE_CLAIM_TIMEOUT_MINUTES: "product_feeds.stale_claim_timeout_minutes";
+    readonly RUN_ISSUE_CAP: "product_feeds.run_issue_cap";
+    readonly PUBLIC_FETCH_RATE_LIMIT_PER_MINUTE: "product_feeds.public_fetch_rate_limit_per_minute";
+    /** Above this many shop categories the mapping surface switches from tree to paged flat list. */
+    readonly CATEGORY_MAPPING_TREE_LIMIT: "product_feeds.category_mapping_tree_limit";
+    /**
+     * Master switch. **Defaults to `false`** and off is a first-class state: when
+     * it is off no Job Scheduler exists, `POST /checks` is refused, and the module
+     * makes no outbound request at all (FR-087, research §R24).
+     */
+    readonly TAXONOMY_FETCH_ENABLED: "product_feeds.taxonomy_fetch_enabled";
+    /** 5-field cron, validated by the module's existing `cronExpressionSchema`. Default `0 4 * * 1`, UTC. */
+    readonly TAXONOMY_FETCH_CRON: "product_feeds.taxonomy_fetch_cron";
+    /** Per-deployment overridable source URLs — a mirror or an internal proxy (FR-090). */
+    readonly TAXONOMY_SOURCE_URL_GOOGLE_EN: "product_feeds.taxonomy_source_url_google_en";
+    readonly TAXONOMY_SOURCE_URL_GOOGLE_PL: "product_feeds.taxonomy_source_url_google_pl";
+    readonly TAXONOMY_SOURCE_URL_META_EN: "product_feeds.taxonomy_source_url_meta_en";
+    readonly TAXONOMY_SOURCE_URL_META_PL: "product_feeds.taxonomy_source_url_meta_pl";
+    /** Retained revisions per provider; the three protected classes are never counted out (FR-097). */
+    readonly TAXONOMY_REVISION_RETENTION_COUNT: "product_feeds.taxonomy_revision_retention_count";
+    /** Attempts per published artefact before the delivery is abandoned (FR-104). */
+    readonly DELIVERY_MAX_ATTEMPTS: "product_feeds.delivery_max_attempts";
+    /** Ceiling on `POST /delivery/test` per feed per hour (SR-5). */
+    readonly DELIVERY_TEST_RATE_LIMIT_PER_HOUR: "product_feeds.delivery_test_rate_limit_per_hour";
+};
+/**
+ * Egress safety limits are deliberately NOT settings (FR-091, research §R23):
+ * they are safety floors, not operator policy, and an admin screen must not be
+ * able to widen an SSRF guard.
+ */
+export declare const TAXONOMY_FETCH_LIMITS: {
+    /** Per-request abort, via `AbortController` — the `SgtmClient` precedent. */
+    readonly REQUEST_TIMEOUT_MS: 20000;
+    /** Whole check, across both languages of one provider. */
+    readonly CHECK_BUDGET_MS: 120000;
+    /** Enforced while reading the stream, never trusted from `Content-Length`. */
+    readonly MAX_RESPONSE_BYTES: number;
+    /** Every hop re-validated against the same rules. */
+    readonly MAX_REDIRECTS: 3;
+    /** Below this a parsed file is treated as truncated rather than as a small taxonomy. */
+    readonly MIN_PLAUSIBLE_NODES: 500;
+    /** Checks retained per provider — roughly five months of weekly history. */
+    readonly CHECK_HISTORY_PER_PROVIDER: 20;
+};
+/** The three mechanisms. Stored verbatim on `product_feed_deliveries.protocol`. */
+export declare const feedDeliveryProtocolSchema: z.ZodEnum<{
+    sftp: "sftp";
+    ftp: "ftp";
+    http: "http";
+}>;
+export type FeedDeliveryProtocol = z.infer<typeof feedDeliveryProtocolSchema>;
+/**
+ * The operator's vocabulary for the `http` protocol. Presentation only: it
+ * selects a label and nothing else, and every value behaves identically.
+ */
+export declare const feedDeliveryHttpLabelSchema: z.ZodEnum<{
+    api: "api";
+    http_server: "http_server";
+    graphql: "graphql";
+}>;
+export type FeedDeliveryHttpLabel = z.infer<typeof feedDeliveryHttpLabelSchema>;
+export declare const feedDeliveryStatusSchema: z.ZodEnum<{
+    failed: "failed";
+    succeeded: "succeeded";
+}>;
+export type FeedDeliveryStatus = z.infer<typeof feedDeliveryStatusSchema>;
+/**
+ * Why an attempt failed, as a closed set an operator can be told about in their
+ * own language. `failureDetail` carries the transport's own words, redacted
+ * (FR-108); this is what the admin renders.
+ */
+export declare const feedDeliveryFailureReasonSchema: z.ZodEnum<{
+    not_configured: "not_configured";
+    internal_error: "internal_error";
+    target_refused: "target_refused";
+    authentication_failed: "authentication_failed";
+    connection_failed: "connection_failed";
+    transfer_failed: "transfer_failed";
+    rejected_by_target: "rejected_by_target";
+    artefact_unavailable: "artefact_unavailable";
+}>;
+export type FeedDeliveryFailureReason = z.infer<typeof feedDeliveryFailureReasonSchema>;
+/**
+ * A transport refusal an operator can be told about, carrying the closed-set
+ * reason above and the transport's own words.
+ *
+ * Adapters throw this rather than a bare `Error` so `product_feeds` does not
+ * have to guess a reason from a message, and the service's classifier decides
+ * on `instanceof`.
+ *
+ * **It lives here rather than beside the adapter interface because an adapter
+ * is a contribution and its author is not always the module** (feature 080,
+ * T040b). Every delivery adapter this platform runs is contributed from
+ * outside `product_feeds` — the composition roots contribute the real three and
+ * the test harness contributes refusing ones — so the class has to be nameable
+ * from outside without naming the module's sources. Once the module is a
+ * package that is not a style preference: a second evaluation of the module's
+ * source is a second class object, `instanceof` is false across the two copies,
+ * and every declared refusal silently reclassifies as `internal_error` and
+ * becomes retryable (D-160.6.1; the same shape that made a KSeF outage answer
+ * `UNEXPECTED`). `@endora-commerce/contracts` is resolved once, so the
+ * comparison holds.
+ *
+ * `detail` is **not** redacted by the thrower — an adapter does not know the
+ * full secret set. `DeliveryService` redacts on the way to the attempt row
+ * (FR-108).
+ */
+export declare class FeedDeliveryError extends Error {
+    readonly reason: FeedDeliveryFailureReason;
+    readonly cause?: unknown | undefined;
+    readonly name = "FeedDeliveryError";
+    constructor(reason: FeedDeliveryFailureReason, message: string, cause?: unknown | undefined);
+}
+/**
+ * The header names whose VALUE is treated as a secret and stored through the
+ * credentials module rather than in the configuration row (FR-107).
+ *
+ * A closed prefix/suffix rule rather than an operator toggle: an operator who
+ * has to remember to tick "this one is secret" will one day not, and the token
+ * lands in a jsonb column that every read returns. Matching is
+ * case-insensitive on the header name.
+ */
+export declare const FEED_DELIVERY_SECRET_HEADER_NAMES: readonly ["authorization", "proxy-authorization", "cookie"];
+export declare const FEED_DELIVERY_SECRET_HEADER_SUFFIXES: readonly ["-key", "-token", "-secret", "-password", "-auth"];
+/** True when this header's value must be stored as a secret (FR-107). */
+export declare function isSecretDeliveryHeader(name: string): boolean;
+/**
+ * The sentinel a read returns in place of a stored secret, and which a write
+ * may send back to mean "keep what is there". The credentials module's own
+ * write-only semantics, applied rather than re-invented.
+ */
+export declare const FEED_DELIVERY_REDACTED = "[redacted]";
+export declare const feedDeliveryHeaderInputSchema: z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodString;
+}, z.core.$strip>;
+export type FeedDeliveryHeaderInput = z.infer<typeof feedDeliveryHeaderInputSchema>;
+/**
+ * A header as read back. A secret one carries `value: null` and `isSet`, never
+ * the stored token — the same rule the credentials DTO applies to every secret
+ * field.
+ */
+export declare const feedDeliveryHeaderSchema: z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodNullable<z.ZodString>;
+    secret: z.ZodBoolean;
+    isSet: z.ZodBoolean;
+}, z.core.$strip>;
+export type FeedDeliveryHeader = z.infer<typeof feedDeliveryHeaderSchema>;
+export declare const upsertFeedDeliveryRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    protocol: z.ZodLiteral<"sftp">;
+    host: z.ZodString;
+    port: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    username: z.ZodString;
+    password: z.ZodOptional<z.ZodString>;
+    privateKey: z.ZodOptional<z.ZodString>;
+    directoryPath: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodBoolean;
+    expectedVersion: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    protocol: z.ZodLiteral<"ftp">;
+    host: z.ZodString;
+    port: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    username: z.ZodString;
+    password: z.ZodOptional<z.ZodString>;
+    directoryPath: z.ZodOptional<z.ZodString>;
+    passiveMode: z.ZodOptional<z.ZodBoolean>;
+    enabled: z.ZodBoolean;
+    expectedVersion: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    protocol: z.ZodLiteral<"http">;
+    httpLabel: z.ZodOptional<z.ZodEnum<{
+        api: "api";
+        http_server: "http_server";
+        graphql: "graphql";
+    }>>;
+    requestUrl: z.ZodString;
+    headers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strip>>>;
+    enabled: z.ZodBoolean;
+    expectedVersion: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>], "protocol">;
+export type UpsertFeedDeliveryRequest = z.infer<typeof upsertFeedDeliveryRequestSchema>;
+/**
+ * The delivery configuration as read back. Every secret is a boolean; nothing
+ * on this shape can be replayed as a credential (FR-107).
+ */
+export declare const feedDeliveryConfigSchema: z.ZodObject<{
+    id: z.ZodString;
+    productFeedId: z.ZodString;
+    enabled: z.ZodBoolean;
+    protocol: z.ZodEnum<{
+        sftp: "sftp";
+        ftp: "ftp";
+        http: "http";
+    }>;
+    httpLabel: z.ZodNullable<z.ZodEnum<{
+        api: "api";
+        http_server: "http_server";
+        graphql: "graphql";
+    }>>;
+    host: z.ZodNullable<z.ZodString>;
+    port: z.ZodNullable<z.ZodNumber>;
+    username: z.ZodNullable<z.ZodString>;
+    directoryPath: z.ZodNullable<z.ZodString>;
+    passiveMode: z.ZodBoolean;
+    requestUrl: z.ZodNullable<z.ZodString>;
+    headers: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodNullable<z.ZodString>;
+        secret: z.ZodBoolean;
+        isSet: z.ZodBoolean;
+    }, z.core.$strip>>;
+    passwordSet: z.ZodBoolean;
+    privateKeySet: z.ZodBoolean;
+    version: z.ZodNumber;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type FeedDeliveryConfig = z.infer<typeof feedDeliveryConfigSchema>;
+/** `GET`/`PUT /api/v1/admin/product-feeds/:id/delivery`. `null` means unconfigured. */
+export declare const feedDeliveryConfigResponseSchema: z.ZodObject<{
+    data: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        productFeedId: z.ZodString;
+        enabled: z.ZodBoolean;
+        protocol: z.ZodEnum<{
+            sftp: "sftp";
+            ftp: "ftp";
+            http: "http";
+        }>;
+        httpLabel: z.ZodNullable<z.ZodEnum<{
+            api: "api";
+            http_server: "http_server";
+            graphql: "graphql";
+        }>>;
+        host: z.ZodNullable<z.ZodString>;
+        port: z.ZodNullable<z.ZodNumber>;
+        username: z.ZodNullable<z.ZodString>;
+        directoryPath: z.ZodNullable<z.ZodString>;
+        passiveMode: z.ZodBoolean;
+        requestUrl: z.ZodNullable<z.ZodString>;
+        headers: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodNullable<z.ZodString>;
+            secret: z.ZodBoolean;
+            isSet: z.ZodBoolean;
+        }, z.core.$strip>>;
+        passwordSet: z.ZodBoolean;
+        privateKeySet: z.ZodBoolean;
+        version: z.ZodNumber;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * One recorded attempt (FR-105). `target` is the **redacted display form** —
+ * `sftp://user@host:22/path`, never a password and never a header value.
+ */
+export declare const feedDeliveryAttemptSchema: z.ZodObject<{
+    id: z.ZodString;
+    productFeedId: z.ZodString;
+    feedRunId: z.ZodNullable<z.ZodString>;
+    feedArtefactId: z.ZodNullable<z.ZodString>;
+    protocol: z.ZodEnum<{
+        sftp: "sftp";
+        ftp: "ftp";
+        http: "http";
+    }>;
+    target: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        succeeded: "succeeded";
+    }>;
+    failureReason: z.ZodNullable<z.ZodEnum<{
+        not_configured: "not_configured";
+        internal_error: "internal_error";
+        target_refused: "target_refused";
+        authentication_failed: "authentication_failed";
+        connection_failed: "connection_failed";
+        transfer_failed: "transfer_failed";
+        rejected_by_target: "rejected_by_target";
+        artefact_unavailable: "artefact_unavailable";
+    }>>;
+    failureDetail: z.ZodNullable<z.ZodString>;
+    attempt: z.ZodNumber;
+    isTest: z.ZodBoolean;
+    startedAt: z.ZodString;
+    finishedAt: z.ZodNullable<z.ZodString>;
+    durationMs: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type FeedDeliveryAttempt = z.infer<typeof feedDeliveryAttemptSchema>;
+/** `GET /api/v1/admin/product-feeds/:id/delivery/attempts`. */
+export declare const feedDeliveryAttemptListResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        productFeedId: z.ZodString;
+        feedRunId: z.ZodNullable<z.ZodString>;
+        feedArtefactId: z.ZodNullable<z.ZodString>;
+        protocol: z.ZodEnum<{
+            sftp: "sftp";
+            ftp: "ftp";
+            http: "http";
+        }>;
+        target: z.ZodString;
+        status: z.ZodEnum<{
+            failed: "failed";
+            succeeded: "succeeded";
+        }>;
+        failureReason: z.ZodNullable<z.ZodEnum<{
+            not_configured: "not_configured";
+            internal_error: "internal_error";
+            target_refused: "target_refused";
+            authentication_failed: "authentication_failed";
+            connection_failed: "connection_failed";
+            transfer_failed: "transfer_failed";
+            rejected_by_target: "rejected_by_target";
+            artefact_unavailable: "artefact_unavailable";
+        }>>;
+        failureDetail: z.ZodNullable<z.ZodString>;
+        attempt: z.ZodNumber;
+        isTest: z.ZodBoolean;
+        startedAt: z.ZodString;
+        finishedAt: z.ZodNullable<z.ZodString>;
+        durationMs: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+    pagination: z.ZodObject<{
+        cursor: z.ZodNullable<z.ZodString>;
+        hasMore: z.ZodBoolean;
+        limit: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/** `POST /api/v1/admin/product-feeds/:id/delivery/test` (FR-106). */
+export declare const feedDeliveryTestResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        ok: z.ZodBoolean;
+        failureReason: z.ZodNullable<z.ZodEnum<{
+            not_configured: "not_configured";
+            internal_error: "internal_error";
+            target_refused: "target_refused";
+            authentication_failed: "authentication_failed";
+            connection_failed: "connection_failed";
+            transfer_failed: "transfer_failed";
+            rejected_by_target: "rejected_by_target";
+            artefact_unavailable: "artefact_unavailable";
+        }>>;
+        failureDetail: z.ZodNullable<z.ZodString>;
+        attempt: z.ZodObject<{
+            id: z.ZodString;
+            productFeedId: z.ZodString;
+            feedRunId: z.ZodNullable<z.ZodString>;
+            feedArtefactId: z.ZodNullable<z.ZodString>;
+            protocol: z.ZodEnum<{
+                sftp: "sftp";
+                ftp: "ftp";
+                http: "http";
+            }>;
+            target: z.ZodString;
+            status: z.ZodEnum<{
+                failed: "failed";
+                succeeded: "succeeded";
+            }>;
+            failureReason: z.ZodNullable<z.ZodEnum<{
+                not_configured: "not_configured";
+                internal_error: "internal_error";
+                target_refused: "target_refused";
+                authentication_failed: "authentication_failed";
+                connection_failed: "connection_failed";
+                transfer_failed: "transfer_failed";
+                rejected_by_target: "rejected_by_target";
+                artefact_unavailable: "artefact_unavailable";
+            }>>;
+            failureDetail: z.ZodNullable<z.ZodString>;
+            attempt: z.ZodNumber;
+            isTest: z.ZodBoolean;
+            startedAt: z.ZodString;
+            finishedAt: z.ZodNullable<z.ZodString>;
+            durationMs: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * Egress and transport safety limits. Not settings, for the reason
+ * `TAXONOMY_FETCH_LIMITS` is not: an admin screen that can widen an SSRF guard
+ * or remove a timeout is an SSRF guard with an off switch.
+ */
+export declare const FEED_DELIVERY_LIMITS: {
+    /** Per-attempt ceiling on the whole transfer, whatever the protocol. */
+    readonly TRANSFER_TIMEOUT_MS: 300000;
+    /** Connect + authenticate. A host that cannot answer this fast is down. */
+    readonly CONNECT_TIMEOUT_MS: 20000;
+    /**
+     * One hop, re-validated, and the credential headers are re-attached only if
+     * the host is unchanged (SR-3).
+     */
+    readonly MAX_REDIRECTS: 1;
+    /** Attempts retained per feed. */
+    readonly ATTEMPT_HISTORY_PER_FEED: 50;
+    /** Delivery attempts per published artefact, unless the setting overrides it. */
+    readonly DEFAULT_MAX_ATTEMPTS: 5;
+    /** Backoff base; the worker multiplies it exponentially per attempt. */
+    readonly RETRY_BACKOFF_MS: 60000;
+    /** `POST /delivery/test` per feed per hour, unless the setting overrides it. */
+    readonly DEFAULT_TEST_RATE_LIMIT_PER_HOUR: 20;
+    /** The fixed, non-operator-controlled body a `http` connection test sends (SR-5). */
+    readonly TEST_PAYLOAD: "endora-commerce feed delivery connection test";
+    /** The filename a test writes and removes on an SFTP/FTP target. */
+    readonly TEST_FILENAME: ".endora-delivery-test";
+};
+//# sourceMappingURL=product-feeds.d.ts.map