@shoplix-ai/sdui-schema 1.0.0

package/dist/primitives.d.ts

@@ -0,0 +1,1206 @@
+import { z } from 'zod';
+import { type SemanticTokenKey, type ThemeStyle } from './tokens.js';
+/** The closed vocabulary a Composed Block may use. */
+export declare const PRIMITIVE_TYPES: readonly ["stack", "row", "grid", "spacer", "divider", "text", "image", "icon", "badge", "button", "repeater", "price", "availability"];
+export type PrimitiveType = (typeof PRIMITIVE_TYPES)[number];
+export declare const SETTING_KEY_PATTERN: RegExp;
+export declare const settingKeySchema: z.ZodString;
+export declare const HEX_COLOR_PATTERN: RegExp;
+export declare const hexColorSchema: z.ZodString;
+/** A reference to one of the Shop's semantic token roles, by role name. */
+export declare const tokenReferenceSchema: z.ZodObject<{
+    token: z.ZodString;
+}, z.core.$strict>;
+export type TokenReference = z.infer<typeof tokenReferenceSchema>;
+/** The fields of the repeater's current item a text value may read. */
+export declare const ITEM_TEXT_FIELDS: readonly ["title", "handle", "vendor", "product_type", "description"];
+export type ItemTextField = (typeof ITEM_TEXT_FIELDS)[number];
+/** The one field of the current item an image value may read. */
+export declare const ITEM_IMAGE_FIELD = "image";
+export type ValueSlot = 'text' | 'color' | 'dimension' | 'number' | 'count' | 'boolean' | 'enum' | 'asset' | 'action';
+/**
+ * Every attribute of a Primitive is a tagged value: a literal, one of the
+ * block's settings, one of the Shop's token roles, or a field of the
+ * repeater's current item. Which of the four a slot takes depends on the
+ * slot; the body never carries a bare value.
+ */
+interface ValueForms {
+    readonly setting: boolean;
+    readonly token: boolean;
+    readonly item?: readonly [string, ...string[]];
+}
+/** The tagged value a slot accepts, as its forms allow: the type says exactly what the schema takes. */
+type TaggedValue<T extends z.ZodType, F extends ValueForms> = {
+    literal: z.infer<T>;
+} | (F['setting'] extends true ? {
+    setting: string;
+} : never) | (F['token'] extends true ? {
+    token: string;
+} : never) | (F['item'] extends readonly string[] ? {
+    item: F['item'][number];
+} : never);
+/**
+ * "show when" on any node: one member of a closed condition union, never an
+ * expression. A node whose condition is false draws nothing, and neither do
+ * its children.
+ */
+export declare const SHOW_WHEN_CONDITIONS: readonly ["setting_on", "item_has_image", "item_available", "language_is"];
+export type ShowWhenConditionName = (typeof SHOW_WHEN_CONDITIONS)[number];
+export declare const showWhenSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    condition: z.ZodLiteral<"setting_on">;
+    setting: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    condition: z.ZodLiteral<"item_has_image">;
+}, z.core.$strict>, z.ZodObject<{
+    condition: z.ZodLiteral<"item_available">;
+}, z.core.$strict>, z.ZodObject<{
+    condition: z.ZodLiteral<"language_is">;
+    language: z.ZodString;
+}, z.core.$strict>], "condition">;
+export type ShowWhen = z.infer<typeof showWhenSchema>;
+/** The two conditions that read the repeater's current item. */
+export declare function readsItem(condition: ShowWhen): boolean;
+export declare const LAYOUT_ALIGNMENTS: readonly ["start", "center", "end", "stretch"];
+export declare const TEXT_SIZES: readonly ["sm", "md", "lg", "xl"];
+export declare const TEXT_WEIGHTS: readonly ["regular", "medium", "bold"];
+export declare const TEXT_ALIGNMENTS: readonly ["start", "center", "end"];
+export declare const IMAGE_SHAPES: readonly ["square", "rounded", "circle"];
+/** How many columns a grid lays out; named as text so a select setting can feed it. */
+export declare const GRID_COLUMNS: readonly ["2", "3"];
+export declare const BUTTON_STYLES: readonly ["solid", "outline", "ghost"];
+/** Padding, gap, alignment, background, radius and border: what every layout Primitive takes. */
+declare const layoutAttributes: {
+    padding: z.ZodOptional<z.ZodType<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown>>>;
+    gap: z.ZodOptional<z.ZodType<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown>>>;
+    width: z.ZodOptional<z.ZodType<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown>>>;
+    align: z.ZodOptional<z.ZodType<TaggedValue<z.ZodEnum<{
+        start: "start";
+        center: "center";
+        end: "end";
+        stretch: "stretch";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodEnum<{
+        start: "start";
+        center: "center";
+        end: "end";
+        stretch: "stretch";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown>>>;
+    background: z.ZodOptional<z.ZodType<TaggedValue<z.ZodString, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodString, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown>>>;
+    radius: z.ZodOptional<z.ZodType<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown>>>;
+    border: z.ZodOptional<z.ZodObject<{
+        width: z.ZodType<TaggedValue<z.ZodNumber, {
+            readonly setting: true;
+            readonly token: true;
+        }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodNumber, {
+            readonly setting: true;
+            readonly token: true;
+        }>, unknown>>;
+        color: z.ZodType<TaggedValue<z.ZodString, {
+            readonly setting: true;
+            readonly token: true;
+        }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodString, {
+            readonly setting: true;
+            readonly token: true;
+        }>, unknown>>;
+    }, z.core.$strict>>;
+    when: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        condition: z.ZodLiteral<"setting_on">;
+        setting: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"item_has_image">;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"item_available">;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"language_is">;
+        language: z.ZodString;
+    }, z.core.$strict>], "condition">>;
+};
+/** A row may run off the side; with snap on, each child settles under the finger. */
+declare const rowAttributes: {
+    scroll: z.ZodOptional<z.ZodType<TaggedValue<z.ZodBoolean, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodBoolean, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown>>>;
+    snap: z.ZodOptional<z.ZodType<TaggedValue<z.ZodBoolean, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodBoolean, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown>>>;
+    padding: z.ZodOptional<z.ZodType<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown>>>;
+    gap: z.ZodOptional<z.ZodType<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown>>>;
+    width: z.ZodOptional<z.ZodType<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown>>>;
+    align: z.ZodOptional<z.ZodType<TaggedValue<z.ZodEnum<{
+        start: "start";
+        center: "center";
+        end: "end";
+        stretch: "stretch";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodEnum<{
+        start: "start";
+        center: "center";
+        end: "end";
+        stretch: "stretch";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown>>>;
+    background: z.ZodOptional<z.ZodType<TaggedValue<z.ZodString, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodString, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown>>>;
+    radius: z.ZodOptional<z.ZodType<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown>>>;
+    border: z.ZodOptional<z.ZodObject<{
+        width: z.ZodType<TaggedValue<z.ZodNumber, {
+            readonly setting: true;
+            readonly token: true;
+        }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodNumber, {
+            readonly setting: true;
+            readonly token: true;
+        }>, unknown>>;
+        color: z.ZodType<TaggedValue<z.ZodString, {
+            readonly setting: true;
+            readonly token: true;
+        }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodString, {
+            readonly setting: true;
+            readonly token: true;
+        }>, unknown>>;
+    }, z.core.$strict>>;
+    when: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        condition: z.ZodLiteral<"setting_on">;
+        setting: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"item_has_image">;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"item_available">;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"language_is">;
+        language: z.ZodString;
+    }, z.core.$strict>], "condition">>;
+};
+declare const gridAttributes: {
+    columns: z.ZodOptional<z.ZodType<TaggedValue<z.ZodEnum<{
+        2: "2";
+        3: "3";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodEnum<{
+        2: "2";
+        3: "3";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown>>>;
+    padding: z.ZodOptional<z.ZodType<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown>>>;
+    gap: z.ZodOptional<z.ZodType<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown>>>;
+    width: z.ZodOptional<z.ZodType<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown>>>;
+    align: z.ZodOptional<z.ZodType<TaggedValue<z.ZodEnum<{
+        start: "start";
+        center: "center";
+        end: "end";
+        stretch: "stretch";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodEnum<{
+        start: "start";
+        center: "center";
+        end: "end";
+        stretch: "stretch";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown>>>;
+    background: z.ZodOptional<z.ZodType<TaggedValue<z.ZodString, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodString, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown>>>;
+    radius: z.ZodOptional<z.ZodType<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown>>>;
+    border: z.ZodOptional<z.ZodObject<{
+        width: z.ZodType<TaggedValue<z.ZodNumber, {
+            readonly setting: true;
+            readonly token: true;
+        }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodNumber, {
+            readonly setting: true;
+            readonly token: true;
+        }>, unknown>>;
+        color: z.ZodType<TaggedValue<z.ZodString, {
+            readonly setting: true;
+            readonly token: true;
+        }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodString, {
+            readonly setting: true;
+            readonly token: true;
+        }>, unknown>>;
+    }, z.core.$strict>>;
+    when: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        condition: z.ZodLiteral<"setting_on">;
+        setting: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"item_has_image">;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"item_available">;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"language_is">;
+        language: z.ZodString;
+    }, z.core.$strict>], "condition">>;
+};
+export declare const spacerPrimitiveSchema: z.ZodObject<{
+    primitive: z.ZodLiteral<"spacer">;
+    size: z.ZodOptional<z.ZodType<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown>>>;
+    when: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        condition: z.ZodLiteral<"setting_on">;
+        setting: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"item_has_image">;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"item_available">;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"language_is">;
+        language: z.ZodString;
+    }, z.core.$strict>], "condition">>;
+}, z.core.$strict>;
+/** A hairline across the parent's width; thickness and color, nothing else. */
+export declare const dividerPrimitiveSchema: z.ZodObject<{
+    primitive: z.ZodLiteral<"divider">;
+    thickness: z.ZodOptional<z.ZodType<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown>>>;
+    color: z.ZodOptional<z.ZodType<TaggedValue<z.ZodString, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodString, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown>>>;
+    when: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        condition: z.ZodLiteral<"setting_on">;
+        setting: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"item_has_image">;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"item_available">;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"language_is">;
+        language: z.ZodString;
+    }, z.core.$strict>], "condition">>;
+}, z.core.$strict>;
+/** One glyph out of the app's icon set, sized and tinted like the text beside it. */
+export declare const iconPrimitiveSchema: z.ZodObject<{
+    primitive: z.ZodLiteral<"icon">;
+    name: z.ZodType<TaggedValue<z.ZodEnum<{
+        image: "image";
+        search: "search";
+        home: "home";
+        leaf: "leaf";
+        bell: "bell";
+        "book-open": "book-open";
+        camera: "camera";
+        compass: "compass";
+        "credit-card": "credit-card";
+        gem: "gem";
+        gift: "gift";
+        globe: "globe";
+        headphones: "headphones";
+        heart: "heart";
+        info: "info";
+        "layout-grid": "layout-grid";
+        "life-buoy": "life-buoy";
+        lock: "lock";
+        "map-pin": "map-pin";
+        menu: "menu";
+        "message-circle": "message-circle";
+        newspaper: "newspaper";
+        package: "package";
+        percent: "percent";
+        phone: "phone";
+        "refresh-cw": "refresh-cw";
+        shield: "shield";
+        shirt: "shirt";
+        "shopping-bag": "shopping-bag";
+        sparkles: "sparkles";
+        star: "star";
+        store: "store";
+        tag: "tag";
+        truck: "truck";
+        user: "user";
+        zap: "zap";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodEnum<{
+        image: "image";
+        search: "search";
+        home: "home";
+        leaf: "leaf";
+        bell: "bell";
+        "book-open": "book-open";
+        camera: "camera";
+        compass: "compass";
+        "credit-card": "credit-card";
+        gem: "gem";
+        gift: "gift";
+        globe: "globe";
+        headphones: "headphones";
+        heart: "heart";
+        info: "info";
+        "layout-grid": "layout-grid";
+        "life-buoy": "life-buoy";
+        lock: "lock";
+        "map-pin": "map-pin";
+        menu: "menu";
+        "message-circle": "message-circle";
+        newspaper: "newspaper";
+        package: "package";
+        percent: "percent";
+        phone: "phone";
+        "refresh-cw": "refresh-cw";
+        shield: "shield";
+        shirt: "shirt";
+        "shopping-bag": "shopping-bag";
+        sparkles: "sparkles";
+        star: "star";
+        store: "store";
+        tag: "tag";
+        truck: "truck";
+        user: "user";
+        zap: "zap";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown>>;
+    size: z.ZodOptional<z.ZodType<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown>>>;
+    color: z.ZodOptional<z.ZodType<TaggedValue<z.ZodString, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodString, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown>>>;
+    when: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        condition: z.ZodLiteral<"setting_on">;
+        setting: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"item_has_image">;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"item_available">;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"language_is">;
+        language: z.ZodString;
+    }, z.core.$strict>], "condition">>;
+}, z.core.$strict>;
+/** Text over a background: the small pill a card carries for "new" or "-20%". */
+export declare const badgePrimitiveSchema: z.ZodObject<{
+    uppercase: z.ZodOptional<z.ZodType<TaggedValue<z.ZodBoolean, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodBoolean, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown>>>;
+    background: z.ZodOptional<z.ZodType<TaggedValue<z.ZodString, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodString, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown>>>;
+    padding: z.ZodOptional<z.ZodType<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown>>>;
+    radius: z.ZodOptional<z.ZodType<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown>>>;
+    when: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        condition: z.ZodLiteral<"setting_on">;
+        setting: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"item_has_image">;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"item_available">;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"language_is">;
+        language: z.ZodString;
+    }, z.core.$strict>], "condition">>;
+    size: z.ZodOptional<z.ZodType<TaggedValue<z.ZodEnum<{
+        sm: "sm";
+        md: "md";
+        lg: "lg";
+        xl: "xl";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodEnum<{
+        sm: "sm";
+        md: "md";
+        lg: "lg";
+        xl: "xl";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown>>>;
+    weight: z.ZodOptional<z.ZodType<TaggedValue<z.ZodEnum<{
+        regular: "regular";
+        medium: "medium";
+        bold: "bold";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodEnum<{
+        regular: "regular";
+        medium: "medium";
+        bold: "bold";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown>>>;
+    align: z.ZodOptional<z.ZodType<TaggedValue<z.ZodEnum<{
+        start: "start";
+        center: "center";
+        end: "end";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodEnum<{
+        start: "start";
+        center: "center";
+        end: "end";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown>>>;
+    color: z.ZodOptional<z.ZodType<TaggedValue<z.ZodString, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodString, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown>>>;
+    primitive: z.ZodLiteral<"badge">;
+    text: z.ZodType<TaggedValue<z.ZodRecord<z.ZodString, z.ZodString>, {
+        readonly setting: true;
+        readonly token: false;
+        readonly item: readonly ["title", "handle", "vendor", "product_type", "description"];
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodRecord<z.ZodString, z.ZodString>, {
+        readonly setting: true;
+        readonly token: false;
+        readonly item: readonly ["title", "handle", "vendor", "product_type", "description"];
+    }>, unknown>>;
+}, z.core.$strict>;
+/**
+ * A label the buyer taps, dressed from the Shop's tokens, carrying one member
+ * of the closed action set. The runtime hands the action to the same router a
+ * platform block's action goes through, so a button opens a screen, the cart
+ * or a link and nothing else.
+ */
+export declare const buttonPrimitiveSchema: z.ZodObject<{
+    primitive: z.ZodLiteral<"button">;
+    label: z.ZodType<TaggedValue<z.ZodRecord<z.ZodString, z.ZodString>, {
+        readonly setting: true;
+        readonly token: false;
+        readonly item: readonly ["title", "handle", "vendor", "product_type", "description"];
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodRecord<z.ZodString, z.ZodString>, {
+        readonly setting: true;
+        readonly token: false;
+        readonly item: readonly ["title", "handle", "vendor", "product_type", "description"];
+    }>, unknown>>;
+    action: z.ZodType<TaggedValue<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"open_screen">;
+        screenId: z.ZodUUID;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"open_cart">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"open_url">;
+        url: z.ZodURL;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"none">;
+    }, z.core.$strip>], "type">, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"open_screen">;
+        screenId: z.ZodUUID;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"open_cart">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"open_url">;
+        url: z.ZodURL;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"none">;
+    }, z.core.$strip>], "type">, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown>>;
+    style: z.ZodOptional<z.ZodType<TaggedValue<z.ZodEnum<{
+        solid: "solid";
+        outline: "outline";
+        ghost: "ghost";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodEnum<{
+        solid: "solid";
+        outline: "outline";
+        ghost: "ghost";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown>>>;
+    size: z.ZodOptional<z.ZodType<TaggedValue<z.ZodEnum<{
+        sm: "sm";
+        md: "md";
+        lg: "lg";
+        xl: "xl";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodEnum<{
+        sm: "sm";
+        md: "md";
+        lg: "lg";
+        xl: "xl";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown>>>;
+    background: z.ZodOptional<z.ZodType<TaggedValue<z.ZodString, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodString, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown>>>;
+    color: z.ZodOptional<z.ZodType<TaggedValue<z.ZodString, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodString, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown>>>;
+    padding: z.ZodOptional<z.ZodType<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown>>>;
+    radius: z.ZodOptional<z.ZodType<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown>>>;
+    when: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        condition: z.ZodLiteral<"setting_on">;
+        setting: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"item_has_image">;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"item_available">;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"language_is">;
+        language: z.ZodString;
+    }, z.core.$strict>], "condition">>;
+}, z.core.$strict>;
+export declare const textPrimitiveSchema: z.ZodObject<{
+    uppercase: z.ZodOptional<z.ZodType<TaggedValue<z.ZodBoolean, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodBoolean, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown>>>;
+    when: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        condition: z.ZodLiteral<"setting_on">;
+        setting: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"item_has_image">;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"item_available">;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"language_is">;
+        language: z.ZodString;
+    }, z.core.$strict>], "condition">>;
+    size: z.ZodOptional<z.ZodType<TaggedValue<z.ZodEnum<{
+        sm: "sm";
+        md: "md";
+        lg: "lg";
+        xl: "xl";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodEnum<{
+        sm: "sm";
+        md: "md";
+        lg: "lg";
+        xl: "xl";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown>>>;
+    weight: z.ZodOptional<z.ZodType<TaggedValue<z.ZodEnum<{
+        regular: "regular";
+        medium: "medium";
+        bold: "bold";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodEnum<{
+        regular: "regular";
+        medium: "medium";
+        bold: "bold";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown>>>;
+    align: z.ZodOptional<z.ZodType<TaggedValue<z.ZodEnum<{
+        start: "start";
+        center: "center";
+        end: "end";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodEnum<{
+        start: "start";
+        center: "center";
+        end: "end";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown>>>;
+    color: z.ZodOptional<z.ZodType<TaggedValue<z.ZodString, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodString, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown>>>;
+    primitive: z.ZodLiteral<"text">;
+    text: z.ZodType<TaggedValue<z.ZodRecord<z.ZodString, z.ZodString>, {
+        readonly setting: true;
+        readonly token: false;
+        readonly item: readonly ["title", "handle", "vendor", "product_type", "description"];
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodRecord<z.ZodString, z.ZodString>, {
+        readonly setting: true;
+        readonly token: false;
+        readonly item: readonly ["title", "handle", "vendor", "product_type", "description"];
+    }>, unknown>>;
+}, z.core.$strict>;
+export declare const imagePrimitiveSchema: z.ZodObject<{
+    primitive: z.ZodLiteral<"image">;
+    asset: z.ZodType<TaggedValue<z.ZodUUID, {
+        readonly setting: true;
+        readonly token: false;
+        readonly item: readonly ["image"];
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodUUID, {
+        readonly setting: true;
+        readonly token: false;
+        readonly item: readonly ["image"];
+    }>, unknown>>;
+    shape: z.ZodOptional<z.ZodType<TaggedValue<z.ZodEnum<{
+        square: "square";
+        rounded: "rounded";
+        circle: "circle";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodEnum<{
+        square: "square";
+        rounded: "rounded";
+        circle: "circle";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown>>>;
+    aspectRatio: z.ZodOptional<z.ZodType<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodNumber, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown>>>;
+    when: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        condition: z.ZodLiteral<"setting_on">;
+        setting: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"item_has_image">;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"item_available">;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"language_is">;
+        language: z.ZodString;
+    }, z.core.$strict>], "condition">>;
+}, z.core.$strict>;
+/**
+ * The current item's price as the Provider formatted it, in the buyer's
+ * country and language. The compare-at price rides alongside when the item
+ * carries one and the body asks for it.
+ */
+export declare const pricePrimitiveSchema: z.ZodObject<{
+    compareAt: z.ZodOptional<z.ZodType<TaggedValue<z.ZodBoolean, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodBoolean, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown>>>;
+    compareAtColor: z.ZodOptional<z.ZodType<TaggedValue<z.ZodString, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodString, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown>>>;
+    when: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        condition: z.ZodLiteral<"setting_on">;
+        setting: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"item_has_image">;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"item_available">;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"language_is">;
+        language: z.ZodString;
+    }, z.core.$strict>], "condition">>;
+    size: z.ZodOptional<z.ZodType<TaggedValue<z.ZodEnum<{
+        sm: "sm";
+        md: "md";
+        lg: "lg";
+        xl: "xl";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodEnum<{
+        sm: "sm";
+        md: "md";
+        lg: "lg";
+        xl: "xl";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown>>>;
+    weight: z.ZodOptional<z.ZodType<TaggedValue<z.ZodEnum<{
+        regular: "regular";
+        medium: "medium";
+        bold: "bold";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodEnum<{
+        regular: "regular";
+        medium: "medium";
+        bold: "bold";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown>>>;
+    align: z.ZodOptional<z.ZodType<TaggedValue<z.ZodEnum<{
+        start: "start";
+        center: "center";
+        end: "end";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodEnum<{
+        start: "start";
+        center: "center";
+        end: "end";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown>>>;
+    color: z.ZodOptional<z.ZodType<TaggedValue<z.ZodString, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodString, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown>>>;
+    primitive: z.ZodLiteral<"price">;
+}, z.core.$strict>;
+/**
+ * The current item's availability as a label the definition supplies in
+ * every language; the runtime picks which of the two to draw.
+ */
+export declare const availabilityPrimitiveSchema: z.ZodObject<{
+    soldOutColor: z.ZodOptional<z.ZodType<TaggedValue<z.ZodString, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodString, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown>>>;
+    when: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        condition: z.ZodLiteral<"setting_on">;
+        setting: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"item_has_image">;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"item_available">;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"language_is">;
+        language: z.ZodString;
+    }, z.core.$strict>], "condition">>;
+    size: z.ZodOptional<z.ZodType<TaggedValue<z.ZodEnum<{
+        sm: "sm";
+        md: "md";
+        lg: "lg";
+        xl: "xl";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodEnum<{
+        sm: "sm";
+        md: "md";
+        lg: "lg";
+        xl: "xl";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown>>>;
+    weight: z.ZodOptional<z.ZodType<TaggedValue<z.ZodEnum<{
+        regular: "regular";
+        medium: "medium";
+        bold: "bold";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodEnum<{
+        regular: "regular";
+        medium: "medium";
+        bold: "bold";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown>>>;
+    align: z.ZodOptional<z.ZodType<TaggedValue<z.ZodEnum<{
+        start: "start";
+        center: "center";
+        end: "end";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodEnum<{
+        start: "start";
+        center: "center";
+        end: "end";
+    }>, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown>>>;
+    color: z.ZodOptional<z.ZodType<TaggedValue<z.ZodString, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodString, {
+        readonly setting: true;
+        readonly token: true;
+    }>, unknown>>>;
+    primitive: z.ZodLiteral<"availability">;
+    inStock: z.ZodType<TaggedValue<z.ZodRecord<z.ZodString, z.ZodString>, {
+        readonly setting: true;
+        readonly token: false;
+        readonly item: readonly ["title", "handle", "vendor", "product_type", "description"];
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodRecord<z.ZodString, z.ZodString>, {
+        readonly setting: true;
+        readonly token: false;
+        readonly item: readonly ["title", "handle", "vendor", "product_type", "description"];
+    }>, unknown>>;
+    soldOut: z.ZodType<TaggedValue<z.ZodRecord<z.ZodString, z.ZodString>, {
+        readonly setting: true;
+        readonly token: false;
+        readonly item: readonly ["title", "handle", "vendor", "product_type", "description"];
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodRecord<z.ZodString, z.ZodString>, {
+        readonly setting: true;
+        readonly token: false;
+        readonly item: readonly ["title", "handle", "vendor", "product_type", "description"];
+    }>, unknown>>;
+}, z.core.$strict>;
+export type SpacerPrimitive = z.infer<typeof spacerPrimitiveSchema>;
+export type DividerPrimitive = z.infer<typeof dividerPrimitiveSchema>;
+export type IconPrimitive = z.infer<typeof iconPrimitiveSchema>;
+export type BadgePrimitive = z.infer<typeof badgePrimitiveSchema>;
+export type ButtonPrimitive = z.infer<typeof buttonPrimitiveSchema>;
+export type TextPrimitive = z.infer<typeof textPrimitiveSchema>;
+export type ImagePrimitive = z.infer<typeof imagePrimitiveSchema>;
+export type PricePrimitive = z.infer<typeof pricePrimitiveSchema>;
+export type AvailabilityPrimitive = z.infer<typeof availabilityPrimitiveSchema>;
+type LayoutAttributes = z.infer<z.ZodObject<typeof layoutAttributes>>;
+type RowAttributes = z.infer<z.ZodObject<typeof rowAttributes>>;
+type GridAttributes = z.infer<z.ZodObject<typeof gridAttributes>>;
+declare const repeaterAttributes: {
+    limit: z.ZodOptional<z.ZodType<TaggedValue<z.ZodInt, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown, z.core.$ZodTypeInternals<TaggedValue<z.ZodInt, {
+        readonly setting: true;
+        readonly token: false;
+    }>, unknown>>>;
+    when: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        condition: z.ZodLiteral<"setting_on">;
+        setting: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"item_has_image">;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"item_available">;
+    }, z.core.$strict>, z.ZodObject<{
+        condition: z.ZodLiteral<"language_is">;
+        language: z.ZodString;
+    }, z.core.$strict>], "condition">>;
+};
+type RepeaterAttributes = z.infer<z.ZodObject<typeof repeaterAttributes>>;
+export interface StackPrimitive extends LayoutAttributes {
+    primitive: 'stack';
+    children: PrimitiveNode[];
+}
+export interface RowPrimitive extends RowAttributes {
+    primitive: 'row';
+    children: PrimitiveNode[];
+}
+/** Two or three columns of equal width, each child taking one cell in order. */
+export interface GridPrimitive extends GridAttributes {
+    primitive: 'grid';
+    children: PrimitiveNode[];
+}
+/**
+ * The block's Binding, one item at a time. `children` is the template drawn
+ * once per item; `empty` is what the block shows instead when the Binding
+ * resolves to nothing. The repeater lays nothing out itself — its parent
+ * does — so a ring strip is a row holding one, and a list is a stack.
+ */
+export interface RepeaterPrimitive extends RepeaterAttributes {
+    primitive: 'repeater';
+    children: PrimitiveNode[];
+    empty?: PrimitiveNode[];
+}
+export type PrimitiveNode = StackPrimitive | RowPrimitive | GridPrimitive | RepeaterPrimitive | SpacerPrimitive | DividerPrimitive | TextPrimitive | ImagePrimitive | IconPrimitive | BadgePrimitive | ButtonPrimitive | PricePrimitive | AvailabilityPrimitive;
+/**
+ * Discriminated on the `primitive` tag so later vocabulary is one more member,
+ * never a rewrite. A tag outside the vocabulary is refused at parse.
+ */
+export declare const primitiveNodeSchema: z.ZodType<PrimitiveNode>;
+/**
+ * A node whose tag this build does not know: a newer Primitive frozen into a
+ * Release by a newer api. It parses and keeps its content so a phone can draw
+ * nothing for it and the rest of the body, which is the no-crash rule a
+ * Release needs to stay readable by every build that ever read it.
+ */
+export interface UnlistedPrimitiveNode {
+    primitive: string;
+    [attribute: string]: unknown;
+}
+export interface EnvelopeStackPrimitive extends LayoutAttributes {
+    primitive: 'stack';
+    children: EnvelopePrimitiveNode[];
+}
+export interface EnvelopeRowPrimitive extends RowAttributes {
+    primitive: 'row';
+    children: EnvelopePrimitiveNode[];
+}
+export interface EnvelopeGridPrimitive extends GridAttributes {
+    primitive: 'grid';
+    children: EnvelopePrimitiveNode[];
+}
+export interface EnvelopeRepeaterPrimitive extends RepeaterAttributes {
+    primitive: 'repeater';
+    children: EnvelopePrimitiveNode[];
+    empty?: EnvelopePrimitiveNode[];
+}
+/** A body as it travels in an envelope: every known Primitive strict, an unknown tag kept. */
+export type EnvelopePrimitiveNode = EnvelopeStackPrimitive | EnvelopeRowPrimitive | EnvelopeGridPrimitive | EnvelopeRepeaterPrimitive | SpacerPrimitive | DividerPrimitive | TextPrimitive | ImagePrimitive | IconPrimitive | BadgePrimitive | ButtonPrimitive | PricePrimitive | AvailabilityPrimitive | UnlistedPrimitiveNode;
+/**
+ * Known tags parse strictly; an unknown tag falls back to the tolerant shape.
+ * A malformed known node never slips through as unknown.
+ */
+export declare const envelopePrimitiveNodeSchema: z.ZodType<EnvelopePrimitiveNode, unknown>;
+export declare function isListedPrimitive(tag: string): tag is PrimitiveType;
+/** The two slots a node holds other nodes in; both walk the same way. */
+declare const CHILD_SLOTS: readonly ["children", "empty"];
+export type PrimitiveChildSlot = (typeof CHILD_SLOTS)[number];
+/** Which slots each Primitive holds other nodes in; a leaf holds none. */
+export declare const PRIMITIVE_CHILD_SLOTS: Readonly<Record<PrimitiveType, readonly PrimitiveChildSlot[]>>;
+export interface UnknownPrimitive {
+    readonly path: readonly (string | number)[];
+    readonly primitive: string;
+}
+/**
+ * Every node whose tag is outside the vocabulary, walked over the raw body
+ * before any parse so the refusal can name the tag and where it sits.
+ */
+export declare function unknownPrimitivesOf(body: unknown): UnknownPrimitive[];
+/** Where a reference sits, and whether a repeater's current item is in scope there. */
+interface BodyPosition {
+    readonly path: readonly (string | number)[];
+    readonly inRepeater: boolean;
+}
+export interface ComposedBodyReference extends BodyPosition {
+    readonly reference: {
+        setting: string;
+    } | {
+        token: string;
+    };
+    readonly slot: ValueSlot;
+}
+/** One place the body reads the repeater's current item, and what reads it. */
+export interface ComposedBodyItemUse extends BodyPosition {
+    readonly use: string;
+}
+export interface ComposedBodyCondition extends BodyPosition {
+    readonly condition: ShowWhen;
+}
+export interface ComposedBodyRepeater extends BodyPosition {
+    readonly nested: boolean;
+}
+/** Every setting and token the body reads, with the slot each feeds. */
+export declare function composedBodyReferences(body: PrimitiveNode): ComposedBodyReference[];
+/**
+ * Every place the body reads the repeater's current item: a value naming one
+ * of its fields, a commerce leaf, or a condition asking about it.
+ */
+export declare function composedBodyItemUses(body: PrimitiveNode): ComposedBodyItemUse[];
+/** Every "show when" the body carries, with where it sits. */
+export declare function composedBodyConditions(body: PrimitiveNode): ComposedBodyCondition[];
+/** Every repeater the body carries; `nested` marks one standing inside another. */
+export declare function composedBodyRepeaters(body: PrimitiveNode): ComposedBodyRepeater[];
+/** The options an enum slot accepts, for a select setting bound to it. */
+export declare function enumSlotValues(node: {
+    primitive: string;
+}, attribute: string): readonly string[] | null;
+/** One asset a body names outright, and the attribute that names it. */
+export interface BodyAssetReference {
+    readonly assetId: string;
+    readonly path: readonly (string | number)[];
+}
+/** Every asset the body names outright, with the path of the attribute naming it. */
+export declare function composedBodyAssetReferences(body: unknown): readonly BodyAssetReference[];
+export declare function composedBodyAssetIds(body: unknown): readonly string[];
+export declare function composedBodyShape(body: PrimitiveNode): {
+    nodes: number;
+    depth: number;
+};
+/** The node at a body path, for a caller holding a reference's path. */
+export declare function nodeAtBodyPath(body: PrimitiveNode, path: readonly (string | number)[]): PrimitiveNode | undefined;
+export declare function isTokenRole(role: string): role is SemanticTokenKey;
+/** One role's value off a resolved theme style; undefined for a role that is not one. */
+export declare function tokenRoleValue(style: ThemeStyle, role: string): string | number | undefined;
+export {};
+//# sourceMappingURL=primitives.d.ts.map