@endora-commerce/contracts 0.100.0

package/dist/cms.d.ts

@@ -0,0 +1,872 @@
+import { z } from 'zod';
+export declare const cmsPageStatusSchema: z.ZodEnum<{
+    draft: "draft";
+    published: "published";
+    archived: "archived";
+}>;
+export type CmsPageStatus = z.infer<typeof cmsPageStatusSchema>;
+export declare const cmsContentEnvelopeSchema: z.ZodObject<{
+    schema_version: z.ZodOptional<z.ZodNumber>;
+    languages: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export type CmsContentEnvelope = z.infer<typeof cmsContentEnvelopeSchema>;
+export declare const cmsPageSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    slug: z.ZodString;
+    status: z.ZodEnum<{
+        draft: "draft";
+        published: "published";
+        archived: "archived";
+    }>;
+    active: z.ZodBoolean;
+    description: z.ZodNullable<z.ZodString>;
+    salesChannelIds: z.ZodArray<z.ZodString>;
+    languages: z.ZodArray<z.ZodString>;
+    version: z.ZodNumber;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type CmsPageSummary = z.infer<typeof cmsPageSummarySchema>;
+export declare const cmsPageDetailSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    slug: z.ZodString;
+    status: z.ZodEnum<{
+        draft: "draft";
+        published: "published";
+        archived: "archived";
+    }>;
+    active: z.ZodBoolean;
+    description: z.ZodNullable<z.ZodString>;
+    salesChannelIds: z.ZodArray<z.ZodString>;
+    languages: z.ZodArray<z.ZodString>;
+    version: z.ZodNumber;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    meta: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        keywords: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    content: z.ZodObject<{
+        schema_version: z.ZodOptional<z.ZodNumber>;
+        languages: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type CmsPageDetail = z.infer<typeof cmsPageDetailSchema>;
+export declare const createCmsPageRequestSchema: z.ZodObject<{
+    name: z.ZodString;
+    slug: z.ZodString;
+    active: z.ZodDefault<z.ZodBoolean>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    salesChannelIds: z.ZodArray<z.ZodString>;
+    languages: z.ZodArray<z.ZodString>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        keywords: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type CreateCmsPageRequest = z.infer<typeof createCmsPageRequestSchema>;
+export declare const patchCmsPageRequestSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    slug: z.ZodOptional<z.ZodString>;
+    active: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    description: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+    salesChannelIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    languages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    meta: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        keywords: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>>;
+    version: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type PatchCmsPageRequest = z.infer<typeof patchCmsPageRequestSchema>;
+export declare const putCmsPageContentRequestSchema: z.ZodObject<{
+    data: z.ZodUnknown;
+    version: z.ZodNumber;
+}, z.core.$strip>;
+export type PutCmsPageContentRequest = z.infer<typeof putCmsPageContentRequestSchema>;
+export declare const cmsBlockSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    code: z.ZodString;
+    active: z.ZodBoolean;
+    description: z.ZodNullable<z.ZodString>;
+    salesChannelIds: z.ZodArray<z.ZodString>;
+    languages: z.ZodArray<z.ZodString>;
+    version: z.ZodNumber;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type CmsBlockSummary = z.infer<typeof cmsBlockSummarySchema>;
+export declare const cmsBlockDetailSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    code: z.ZodString;
+    active: z.ZodBoolean;
+    description: z.ZodNullable<z.ZodString>;
+    salesChannelIds: z.ZodArray<z.ZodString>;
+    languages: z.ZodArray<z.ZodString>;
+    version: z.ZodNumber;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    content: z.ZodObject<{
+        schema_version: z.ZodOptional<z.ZodNumber>;
+        languages: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type CmsBlockDetail = z.infer<typeof cmsBlockDetailSchema>;
+export declare const createCmsBlockRequestSchema: z.ZodObject<{
+    name: z.ZodString;
+    code: z.ZodString;
+    active: z.ZodDefault<z.ZodBoolean>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    salesChannelIds: z.ZodArray<z.ZodString>;
+    languages: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type CreateCmsBlockRequest = z.infer<typeof createCmsBlockRequestSchema>;
+export declare const patchCmsBlockRequestSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    code: z.ZodOptional<z.ZodString>;
+    active: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    description: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+    salesChannelIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    languages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    version: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type PatchCmsBlockRequest = z.infer<typeof patchCmsBlockRequestSchema>;
+export declare const cmsTemplateSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    code: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    salesChannelIds: z.ZodArray<z.ZodString>;
+    languages: z.ZodArray<z.ZodString>;
+    version: z.ZodNumber;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type CmsTemplateSummary = z.infer<typeof cmsTemplateSummarySchema>;
+export declare const cmsTemplateDetailSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    code: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    salesChannelIds: z.ZodArray<z.ZodString>;
+    languages: z.ZodArray<z.ZodString>;
+    version: z.ZodNumber;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    content: z.ZodObject<{
+        schema_version: z.ZodOptional<z.ZodNumber>;
+        languages: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type CmsTemplateDetail = z.infer<typeof cmsTemplateDetailSchema>;
+export declare const createCmsTemplateRequestSchema: z.ZodObject<{
+    name: z.ZodString;
+    code: z.ZodString;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    salesChannelIds: z.ZodArray<z.ZodString>;
+    languages: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type CreateCmsTemplateRequest = z.infer<typeof createCmsTemplateRequestSchema>;
+export declare const patchCmsTemplateRequestSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    code: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+    salesChannelIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    languages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    version: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type PatchCmsTemplateRequest = z.infer<typeof patchCmsTemplateRequestSchema>;
+export declare const cmsHookSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    code: z.ZodString;
+    active: z.ZodBoolean;
+    description: z.ZodNullable<z.ZodString>;
+    isSystem: z.ZodBoolean;
+    salesChannelIds: z.ZodArray<z.ZodString>;
+    attachmentCount: z.ZodNumber;
+    version: z.ZodNumber;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type CmsHookSummary = z.infer<typeof cmsHookSummarySchema>;
+export declare const cmsHookDetailSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    code: z.ZodString;
+    active: z.ZodBoolean;
+    description: z.ZodNullable<z.ZodString>;
+    isSystem: z.ZodBoolean;
+    salesChannelIds: z.ZodArray<z.ZodString>;
+    attachmentCount: z.ZodNumber;
+    version: z.ZodNumber;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    attachments: z.ZodArray<z.ZodObject<{
+        blockId: z.ZodString;
+        blockCode: z.ZodString;
+        position: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CmsHookDetail = z.infer<typeof cmsHookDetailSchema>;
+export declare const createCmsHookRequestSchema: z.ZodObject<{
+    name: z.ZodString;
+    code: z.ZodString;
+    active: z.ZodDefault<z.ZodBoolean>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    salesChannelIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type CreateCmsHookRequest = z.infer<typeof createCmsHookRequestSchema>;
+export declare const patchCmsHookRequestSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    active: z.ZodOptional<z.ZodBoolean>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    salesChannelIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    version: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type PatchCmsHookRequest = z.infer<typeof patchCmsHookRequestSchema>;
+export declare const cmsHookAttachmentRequestSchema: z.ZodObject<{
+    blockId: z.ZodString;
+    position: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type CmsHookAttachmentRequest = z.infer<typeof cmsHookAttachmentRequestSchema>;
+export declare const pageBuilderContextSchema: z.ZodEnum<{
+    invoice: "invoice";
+    email: "email";
+    cms: "cms";
+    newsletter: "newsletter";
+}>;
+export type PageBuilderContext = z.infer<typeof pageBuilderContextSchema>;
+export declare const pageBuilderBreakpointsSchema: z.ZodObject<{
+    tabletMin: z.ZodNumber;
+    desktopMin: z.ZodNumber;
+}, z.core.$strip>;
+export type PageBuilderBreakpoints = z.infer<typeof pageBuilderBreakpointsSchema>;
+export declare const cmsFieldDescriptorSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        number: "number";
+        object: "object";
+        array: "array";
+        text: "text";
+        textarea: "textarea";
+        select: "select";
+        radio: "radio";
+        external: "external";
+        uuid: "uuid";
+        richtext: "richtext";
+    }>;
+    label: z.ZodOptional<z.ZodString>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    }, z.core.$strip>>>;
+    refKind: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CmsFieldDescriptor = z.infer<typeof cmsFieldDescriptorSchema>;
+export declare const cmsColorPaletteEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    hex: z.ZodString;
+}, z.core.$strip>;
+export type CmsColorPaletteEntry = z.infer<typeof cmsColorPaletteEntrySchema>;
+export declare const cmsColorPaletteSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    hex: z.ZodString;
+}, z.core.$strip>>;
+export type CmsColorPalette = z.infer<typeof cmsColorPaletteSchema>;
+export declare const putCmsColorPaletteRequestSchema: z.ZodObject<{
+    entries: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        hex: z.ZodString;
+    }, z.core.$strip>>;
+    expectedVersion: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PutCmsColorPaletteRequest = z.infer<typeof putCmsColorPaletteRequestSchema>;
+/**
+ * The grammar of a **persisted** Page Builder block name:
+ * `<ownerModuleId>.<LocalName>`, one separator exactly
+ * (`specs/096-page-builder-block-ownership/data-model.md` §3).
+ *
+ * The owner segment is the declaring module's `id` and is matched by the same
+ * shape as `moduleIdRe`, minus the underscore prefix `moduleIdRe` reserves for
+ * platform-internal modules — none of which owns a block. The local segment is
+ * PascalCase, which all 74 pre-existing names already are.
+ *
+ * **This is the one place the grammar is written.**
+ * `@endora-commerce/page-builder-core`'s `block-name.ts` imports it for
+ * `parseBlockName` / `ownerOf` / `isNamespaced` / `formatBlockName`, and every
+ * other reader goes through those — the discipline `text-normalization.ts`
+ * keeps for diacritic folding and slugs, for the same reason: a second copy of
+ * a grammar is a second answer waiting to disagree, and this one is written
+ * into `jsonb` and never rewritten.
+ */
+export declare const blockNameRe: RegExp;
+/**
+ * The grammar of a declared palette category's key (`data-model.md` §2).
+ * snake_case, like a module id and unlike a block's local name — a category is
+ * a section of a palette, not a persisted identifier.
+ */
+export declare const blockCategoryKeyRe: RegExp;
+/**
+ * A module's declaration of one Page Builder block
+ * (`specs/096-page-builder-block-ownership/contracts/block-definition.md` §1).
+ *
+ * Declared on the module manifest as `blocks`, beside `permissions`, `actions`
+ * and `errorCodes`, and read by nothing at runtime until the registry is
+ * populated from it.
+ *
+ * **There is no `ownerModule` field, and its absence is the design.** The owner
+ * is the segment before the `.` in `name`, so ownership is stated once rather
+ * than twice; the registry keeps computing it for the descriptor it serves.
+ * `defineModuleManifest` refuses a `name` whose owner segment is not the
+ * declaring module's own `id`.
+ *
+ * `labelKey` and `descriptionKey` are **relative to the declaring module's own
+ * i18n namespace** — `blocks.productGrid.label`, never `catalog.blocks.…` —
+ * which is the rule manifest `actions` already follow, and which this layer
+ * cannot enforce for the reason it cannot enforce it there either: relativity
+ * is a fact about a bundle, and this schema sees a string.
+ */
+export declare const BlockDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    labelKey: z.ZodString;
+    descriptionKey: z.ZodOptional<z.ZodString>;
+    category: z.ZodString;
+    contexts: z.ZodArray<z.ZodEnum<{
+        invoice: "invoice";
+        email: "email";
+        cms: "cms";
+        newsletter: "newsletter";
+    }>>;
+    fields: z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodEnum<{
+            number: "number";
+            object: "object";
+            array: "array";
+            text: "text";
+            textarea: "textarea";
+            select: "select";
+            radio: "radio";
+            external: "external";
+            uuid: "uuid";
+            richtext: "richtext";
+        }>;
+        label: z.ZodOptional<z.ZodString>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        }, z.core.$strip>>>;
+        refKind: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    defaultProps: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    responsiveFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    previewIcon: z.ZodOptional<z.ZodString>;
+    weight: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type BlockDefinition = z.infer<typeof BlockDefinitionSchema>;
+/**
+ * A declared palette section (`data-model.md` §2).
+ *
+ * Categories are declared rather than hard-coded so that a module contributing
+ * a block into a category never has to edit a shared `categories` map in a
+ * package it does not own — the shape feature 091 removed from the admin. Two
+ * modules declaring the same `(key, context)` is therefore expected and is not
+ * a collision; the palette merges them.
+ *
+ * **`contracts/block-definition.md` §1.1 is normative for that merge** — what
+ * unions, what resolves, the total order that decides which declaration's
+ * `titleKey`, `weight` and `visible` are served as one record, and the two CI
+ * signals that hold this repository's modules to agreeing. It is cited rather
+ * than summarised here: a second statement of a merge rule is a second answer
+ * waiting to disagree. `defineModuleManifest` refuses one *manifest* declaring
+ * one `(key, context)` twice (§1 rule 4), which is the only case with a single
+ * author and therefore the only one decidable where it is written.
+ *
+ * A category exists **per context**: `layout` in the CMS palette and `layout`
+ * in the e-mail palette are two declarations.
+ *
+ * `visible` is absent-means-visible rather than a Zod `.default(true)`,
+ * deliberately: `ModuleManifest` is the schema's *output* type, so a default
+ * would oblige every author to write `visible: true` on every category — which
+ * is what `actions`' `keywords` and `weight` already do, and is not a precedent
+ * worth extending. It replaces the CMS palette's `_internal` hidden drawer.
+ */
+export declare const BlockCategorySchema: z.ZodObject<{
+    key: z.ZodString;
+    titleKey: z.ZodString;
+    contexts: z.ZodArray<z.ZodEnum<{
+        invoice: "invoice";
+        email: "email";
+        cms: "cms";
+        newsletter: "newsletter";
+    }>>;
+    weight: z.ZodOptional<z.ZodNumber>;
+    visible: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type BlockCategory = z.infer<typeof BlockCategorySchema>;
+/**
+ * `GET /api/v1/admin/cms/page-builder/config`.
+ *
+ * Feature 096 extends this **additively**: every per-component field it gains
+ * is optional and the category list is optional, so a consumer reading only the
+ * five fields that were here before keeps working, and Phase 1 changes nothing
+ * a client can observe. `name` deliberately does **not** take `blockNameRe` —
+ * the registry serves the pre-migration bare names until the renderer maps are
+ * re-keyed, and a grammar here would make the vocabulary phase a breaking
+ * change.
+ */
+export declare const cmsPageBuilderDescriptorSchema: z.ZodObject<{
+    schemaVersion: z.ZodNumber;
+    breakpoints: z.ZodOptional<z.ZodObject<{
+        tabletMin: z.ZodNumber;
+        desktopMin: z.ZodNumber;
+    }, z.core.$strip>>;
+    colorPalette: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        hex: z.ZodString;
+    }, z.core.$strip>>>;
+    components: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        ownerModule: z.ZodString;
+        fields: z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodEnum<{
+                number: "number";
+                object: "object";
+                array: "array";
+                text: "text";
+                textarea: "textarea";
+                select: "select";
+                radio: "radio";
+                external: "external";
+                uuid: "uuid";
+                richtext: "richtext";
+            }>;
+            label: z.ZodOptional<z.ZodString>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+            }, z.core.$strip>>>;
+            refKind: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        previewIcon: z.ZodOptional<z.ZodString>;
+        contexts: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            invoice: "invoice";
+            email: "email";
+            cms: "cms";
+            newsletter: "newsletter";
+        }>>>;
+        labelKey: z.ZodOptional<z.ZodString>;
+        descriptionKey: z.ZodOptional<z.ZodString>;
+        category: z.ZodOptional<z.ZodString>;
+        defaultProps: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        responsiveFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        weight: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    categories: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        titleKey: z.ZodString;
+        contexts: z.ZodArray<z.ZodEnum<{
+            invoice: "invoice";
+            email: "email";
+            cms: "cms";
+            newsletter: "newsletter";
+        }>>;
+        weight: z.ZodOptional<z.ZodNumber>;
+        visible: z.ZodOptional<z.ZodBoolean>;
+        ownerModule: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type CmsPageBuilderDescriptor = z.infer<typeof cmsPageBuilderDescriptorSchema>;
+export declare const cmsAssetEmbedResolutionSchema: z.ZodObject<{
+    url: z.ZodString;
+    mimeType: z.ZodString;
+    filename: z.ZodString;
+    label: z.ZodNullable<z.ZodString>;
+    visibility: z.ZodEnum<{
+        public: "public";
+        private: "private";
+    }>;
+}, z.core.$strip>;
+export type CmsAssetEmbedResolution = z.infer<typeof cmsAssetEmbedResolutionSchema>;
+export declare const cmsResolvedBlockSchema: z.ZodObject<{
+    id: z.ZodString;
+    code: z.ZodString;
+    language: z.ZodString;
+    content: z.ZodObject<{
+        data: z.ZodUnknown;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type CmsResolvedBlock = z.infer<typeof cmsResolvedBlockSchema>;
+export declare const cmsResolvedTemplateSchema: z.ZodObject<{
+    id: z.ZodString;
+    code: z.ZodString;
+    language: z.ZodString;
+    content: z.ZodObject<{
+        data: z.ZodUnknown;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type CmsResolvedTemplate = CmsResolvedBlock;
+export declare const cmsResolvedPageSchema: z.ZodObject<{
+    id: z.ZodString;
+    slug: z.ZodString;
+    name: z.ZodString;
+    language: z.ZodString;
+    meta: z.ZodObject<{
+        title: z.ZodNullable<z.ZodString>;
+        description: z.ZodNullable<z.ZodString>;
+        keywords: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    content: z.ZodObject<{
+        data: z.ZodUnknown;
+    }, z.core.$strip>;
+    embeds: z.ZodObject<{
+        blocks: z.ZodRecord<z.ZodString, z.ZodObject<{
+            id: z.ZodString;
+            code: z.ZodString;
+            language: z.ZodString;
+            content: z.ZodObject<{
+                data: z.ZodUnknown;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        templates: z.ZodRecord<z.ZodString, z.ZodObject<{
+            id: z.ZodString;
+            code: z.ZodString;
+            language: z.ZodString;
+            content: z.ZodObject<{
+                data: z.ZodUnknown;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    assets: z.ZodRecord<z.ZodString, z.ZodObject<{
+        url: z.ZodString;
+        mimeType: z.ZodString;
+        filename: z.ZodString;
+        label: z.ZodNullable<z.ZodString>;
+        visibility: z.ZodEnum<{
+            public: "public";
+            private: "private";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CmsResolvedPage = z.infer<typeof cmsResolvedPageSchema>;
+export declare const cmsResolvedHookSchema: z.ZodObject<{
+    hookCode: z.ZodString;
+    blocks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        code: z.ZodString;
+        language: z.ZodString;
+        content: z.ZodObject<{
+            data: z.ZodUnknown;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CmsResolvedHook = z.infer<typeof cmsResolvedHookSchema>;
+/**
+ * One published CMS page, as a crawler needs to be told about it
+ * (`specs/105-cms-root-page-urls/` FR-021; `contracts/cms-page-url.md` §4.1).
+ *
+ * `slug` is the **per-channel** slug — `cms_page_sales_channels.slug`, which is
+ * what §1 says the page's address is built from, and not `cms_pages.slug`,
+ * which carries one value for every channel the page is published to. The two
+ * agree for a single-channel page and are free to disagree for any other, which
+ * is why the join and not the column is the source.
+ *
+ * `updatedAt` is the page row's, and it is here because a sitemap entry with no
+ * `lastModified` tells a crawler nothing it did not already know. Nothing else
+ * of the page travels: this shape exists to enumerate addresses, and a rendered
+ * page-builder tree per row would put the whole CMS through memory on every
+ * sitemap build — the reasoning `CmsPageRecord` already states for dropping
+ * `body` and `content`.
+ */
+export declare const cmsPageIndexEntrySchema: z.ZodObject<{
+    slug: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type CmsPageIndexEntry = z.infer<typeof cmsPageIndexEntrySchema>;
+/** The published pages of the requested sales channel (FR-021). */
+export declare const cmsPageIndexResponseSchema: z.ZodObject<{
+    pages: z.ZodArray<z.ZodObject<{
+        slug: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CmsPageIndexResponse = z.infer<typeof cmsPageIndexResponseSchema>;
+/**
+ * The deployment's reserved first path segments, as the page editor reads them
+ * (`specs/105-cms-root-page-urls/` FR-033; `contracts/cms-page-url.md` §5.3).
+ *
+ * Normalised: lowercase, one path segment each, no duplicates — whatever an
+ * operator typed into the Setting. The editor compares a slug's first segment
+ * against this list, and the backend refuses a save against the same value, so
+ * the warning and the refusal cannot disagree.
+ */
+export declare const cmsReservedSegmentsResponseSchema: z.ZodObject<{
+    segments: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type CmsReservedSegmentsResponse = z.infer<typeof cmsReservedSegmentsResponseSchema>;
+/**
+ * The first path segment of a CMS page slug — the only segment that can collide
+ * with a storefront route (`contracts/cms-page-url.md` §5.1).
+ *
+ * `cmsSlugRe` permits `/`, so `pomoc/dostawa` is one page at `/pomoc/dostawa`
+ * rather than a page under a section, and its first segment is `pomoc`. The
+ * storefront's route table decides the *first* segment of a URL and a catch-all
+ * takes everything after it, so that is what the refusal compares.
+ *
+ * **It lives here because two programs ask the question and must agree**: the
+ * backend, refusing a save, and the page editor, warning while the operator
+ * types. A second copy in the admin layer is a second answer waiting to
+ * disagree — the discipline `blockNameRe` and `slugify` already keep.
+ */
+export declare function firstSlugSegment(slug: string): string;
+/**
+ * One thing pointing at a CMS object, as a delete guard reports it.
+ *
+ * `kind` is deliberately open on the string side: the four `cms_*` tags are
+ * this module's own, and a scanner contributed by another module names its own
+ * kind. Closing the union would mean `cms` had to know every module that might
+ * ever embed a block.
+ */
+export interface CmsReference {
+    kind: 'cms_page' | 'cms_block' | 'cms_template' | 'cms_hook' | 'megamenu' | string;
+    entityId: string;
+    label: string;
+}
+/**
+ * A scanner contributed by another module so its references block a CMS page,
+ * block or template from being deleted.
+ *
+ * Every method is optional — a scanner fills in only the edges it cares about.
+ * `ownerModuleId` is not: a contribution seam records its contributor, so the
+ * registry can state a policy for an absent owner instead of having no way to
+ * express one (D-39).
+ *
+ * The block and template scanners receive both an id and a code, because a
+ * contributor may have stored either.
+ */
+export interface CmsExternalReferenceScanner {
+    ownerModuleId: string;
+    findPageReferences?: (pageId: string) => Promise<CmsReference[]>;
+    findBlockReferences?: (blockId: string, blockCode: string) => Promise<CmsReference[]>;
+    findTemplateReferences?: (templateId: string, templateCode: string) => Promise<CmsReference[]>;
+}
+/**
+ * Container name: `cmsReferenceRegistry`. Owner: `cms`.
+ *
+ * A **contribution seam**, and the reference-integrity twin of
+ * `assetReferenceRegistry`: `megamenu` is the one contributor today. Its
+ * absent-owner policy should be read the same way — these scanners exist to
+ * refuse a delete, not to render a surface, so an absent contributor's edges
+ * still matter. Publishing the shape must not change the classification.
+ */
+export interface CmsReferenceRegistryPort {
+    register(scanner: CmsExternalReferenceScanner): void;
+    /** The contributing module of every registered scanner, in registration order. */
+    owners(): readonly string[];
+}
+/**
+ * A CMS page as `seo` reads it — never the ORM entity (FR-011).
+ *
+ * **`path` and `title` are the entity's two `@deprecated` columns**, and the
+ * first version of this record carried only those. `slug`, `name` and `active`
+ * join them in Phase C, because they are what `seo` measurably reads: the
+ * sitemap stamps `${baseUrl}/${slug}` and excludes `active === false`, and the
+ * meta-tag rule falls back to `name` when a page has no localized `metaTitle`.
+ * Publishing the record without them would have made the cut change which URL
+ * a crawler is given and put deactivated pages back into the sitemap — a
+ * product change wearing a refactor.
+ *
+ * The deprecated pair stays: `cms` owns the decision to retire them, and
+ * removing a published field to fix a consumer is the wrong direction.
+ */
+export interface CmsPageRecord {
+    id: string;
+    /** @deprecated Use `slug`. The entity says so; the record repeats it. */
+    path: string;
+    /** The storefront slug — what a URL is built from. */
+    slug: string;
+    status: 'draft' | 'published' | 'archived';
+    /** Admin-facing page name, and the meta-title fallback. */
+    name: string;
+    /** An operator can deactivate a published page; a deactivated one has no URL. */
+    active: boolean;
+    /** @deprecated Use `name` + `metaTitle`. The entity says so; the record repeats it. */
+    title: Record<string, string>;
+    metaTitle: Record<string, string> | null;
+    metaDescription: Record<string, string> | null;
+    metaKeywords: Record<string, string> | null;
+    publishedAt: Date | null;
+    archivedAt: Date | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+/**
+ * Container name: `cmsPageReadPort`. Owner: `cms`.
+ *
+ * `seo` reads pages twice: to resolve one page's meta tags, and to enumerate
+ * the published ones for the sitemap. The `body` and `content` columns are
+ * absent from the record on purpose — a sitemap and a meta-tag resolver have
+ * no use for a page's rendered tree, and shipping it would make every sitemap
+ * build carry the whole CMS.
+ */
+export interface CmsPageReadPort {
+    findById(id: string): Promise<CmsPageRecord | null>;
+    findByPath(path: string): Promise<CmsPageRecord | null>;
+    /**
+     * These ids, in the order given. The sitemap's read: it already holds the
+     * channel's member ids, so `listPublished` would fetch every page on the
+     * platform to keep one channel's few.
+     */
+    findByIds(ids: readonly string[]): Promise<CmsPageRecord[]>;
+    /** Published pages only, ordered by path — the platform-wide enumeration. */
+    listPublished(): Promise<CmsPageRecord[]>;
+}
+/**
+ * A predefined block a module asks `cms` to keep in place — feature 075 / D-87.
+ *
+ * Two modules ship one: `newsletter` owns the registration-form consent label
+ * and `google_analytics` owns the cookie-banner message. In both the *text* is
+ * the asking module's business and the *storage* is this one's, which is why
+ * the descriptor carries content and nothing else — no channel list, no block
+ * id, no version. The seam is "keep this block in place", not "write to my
+ * tables".
+ */
+export interface CmsSeededBlock {
+    /**
+     * The block's stable code, and the only identity this seam has. A second call
+     * under the same code inserts nothing and updates nothing, so an operator who
+     * has edited the seeded text keeps that edit across every restart.
+     */
+    readonly code: string;
+    /** The admin-facing block name. Used only where the block is first created. */
+    readonly name: string;
+    /** The language codes the block ships content for, e.g. `['en-US', 'pl-PL']`. */
+    readonly languages: readonly string[];
+    /** The per-language Puck trees, in the envelope the CMS stores. */
+    readonly content: CmsContentEnvelope;
+}
+/**
+ * Container name: `cmsBlockSeedPort`. Owner: `cms`.
+ *
+ * The idempotent seeding seam for a predefined block, and deliberately nothing
+ * wider: a module that ships one needs it to exist and to resolve on every
+ * sales channel, and needs no other write into the CMS. `newsletter` and
+ * `google_analytics` reached `cms_blocks` and `cms_block_sales_channels` in raw
+ * SQL until feature 075 — four ledgered reaches that named no import specifier,
+ * so the boundary they crossed compiled and returned rows.
+ *
+ * **Called once per boot, from the asking module's route registration.** There
+ * rather than from a migration because a block resolves per sales channel and
+ * the system-default channel is created at boot rather than by schema; and
+ * re-run every boot because a channel created later has to be bound too.
+ *
+ * **When `cms` is switched off**, the gate on this registration answers 503
+ * `MODULE_DISABLED` instead of handing back a live service. A caller reaching
+ * it before the first request — which is where a seed runs — therefore decides
+ * presence first with `effectiveState.isPresent('cms')` and skips the seed: a
+ * gate's "no" at route registration stops the next start rather than one
+ * request. Skipping costs nothing that is not recovered. Deactivation drops no
+ * rows, so an already-seeded block outlives the flip, and the first boot after
+ * `cms` comes back binds it to whatever channels appeared meanwhile.
+ */
+export interface CmsBlockSeedPort {
+    /**
+     * Insert `block` where no block carries its code, then bind it to every sales
+     * channel it is not already bound to. Both halves are idempotent, so the call
+     * is: a re-run inserts nothing and binds nothing.
+     */
+    ensureSeededBlock(block: CmsSeededBlock): Promise<void>;
+}
+/**
+ * A CMS block as a consumer outside `cms` reads it — never the ORM entity
+ * (FR-011).
+ *
+ * Three fields, because three is what the demand is. `content` is deliberately
+ * absent: the whole point of {@link CmsBlockReadPort.findLocalizedById} is that a
+ * consumer never holds the per-language envelope, so shipping it here would make
+ * the narrow read pointless and hand every caller a shape whose key layout is
+ * this module's storage decision.
+ */
+export interface CmsBlockRecord {
+    id: string;
+    /** The block's stable, operator-visible code. */
+    code: string;
+    /**
+     * An operator can deactivate a block. It is on the record rather than applied
+     * as a hidden filter because the two consumers disagree about it on purpose:
+     * an admin-side existence check accepts a deactivated block (an operator may
+     * be editing it), and a storefront render does not.
+     */
+    active: boolean;
+}
+/**
+ * One block's authored content in **one** language.
+ *
+ * `data` is the Puck tree, opaque here exactly as it is in
+ * {@link CmsContentEnvelope} — this boundary carries content, it does not
+ * interpret it. What does not cross is the envelope itself: which key a language
+ * hangs off, whether a legacy `schema_version` rides along, and what an absent
+ * language means are `cms`' storage decisions, and a consumer that had to know
+ * them would be reading this module's columns with extra steps.
+ */
+export interface CmsLocalizedBlockRecord {
+    id: string;
+    code: string;
+    /** The language actually resolved — the one asked for, never a fallback. */
+    language: string;
+    data: unknown;
+}
+/**
+ * Container name: `cmsBlockReadPort`. Owner: `cms`.
+ *
+ * `megamenu` reads blocks twice, and the two reads are different questions
+ * rather than one question at two widths (`specs/110-instance-repository/`
+ * T118c). Both were raw `select … from cms_blocks` in a composition root until
+ * this port existed, which is why the interface is shaped by the demand and not
+ * by the table:
+ *
+ * - {@link findById} answers *does this block exist?* for the admin-side target
+ *   validator, which refuses a menu item pointing at a block that is not there.
+ *   It does not filter on `active`, and the record carries the flag so the
+ *   caller can.
+ * - {@link findLocalizedById} answers *what does this block render as, here?*
+ *   for the storefront resolver, which inlines the tree into the menu payload.
+ *
+ * Two methods rather than one wide read: a validator that took the localized
+ * record would pull a content tree per menu item to test a row for existence,
+ * and a storefront that took the plain record would have to open the envelope
+ * itself. Nothing else `cms` knows about blocks is published — the module's own
+ * admin surface is much larger and stays where it is.
+ *
+ * **Owner off:** the seam fails closed — resolving this port throws
+ * `ModuleDisabledError` and the call answers 503 `MODULE_DISABLED`, so nothing
+ * half-executes. That is the honest answer for both consumers: an operator who
+ * has switched the CMS off has switched off the thing that owns the block a menu
+ * item names, and a menu that quietly dropped the embed would be reporting the
+ * content as gone rather than as unavailable.
+ */
+export interface CmsBlockReadPort {
+    findById(id: string): Promise<CmsBlockRecord | null>;
+    /**
+     * The block's content in `language`, or `null` when there is no active block
+     * with that id **or** it carries nothing for that language. The two are one
+     * answer on purpose: a caller that inlines a block has the same thing to do in
+     * either case, and distinguishing them would put "what does an absent language
+     * mean" — which is the envelope's shape — back on the caller.
+     */
+    findLocalizedById(id: string, language: string): Promise<CmsLocalizedBlockRecord | null>;
+}
+//# sourceMappingURL=cms.d.ts.map