pagepilot-visual-editor 1.0.29 → 1.0.33

package/dist/editor-sample/App/InspectorDrawer/LayoutPanel/SectionsModal.d.ts

@@ -1,15 +1,7 @@
 interface SectionsModalProps {
     open: boolean;
     onClose: () => void;
-    /**
-     * Kept for API parity with ahd-fe. Ignored in the standalone build —
-     * every click goes through `applyIndividualBlockTemplate` /
-     * `applyFullDocumentTemplate` regardless of caller. The `onInsert`
-     * splice path in ahd-fe requires a `remapBlocks` step we don't want
-     * to duplicate here; the helper-based path already handles both
-     * individual-block and full-doc templates correctly.
-     */
     onInsert?: (block: any, preassignedId?: string) => void;
 }
-export default function SectionsModal({ open, onClose }: SectionsModalProps): import("react/jsx-runtime").JSX.Element;
-export {};
+declare const SectionsModal: React.FC<SectionsModalProps>;
+export default SectionsModal;

package/dist/editor-sample/App/InspectorDrawer/LayoutPanel/icons/index.d.ts

@@ -27,8 +27,10 @@ declare const TabsIcon: (props?: SvgIconProps) => import("react/jsx-runtime").JS
 declare const AccordionIcon: (props?: SvgIconProps) => import("react/jsx-runtime").JSX.Element;
 declare const YoutubeUrlIcon: (props?: SvgIconProps) => import("react/jsx-runtime").JSX.Element;
 declare const MenuPickerIcon: (props?: SvgIconProps) => import("react/jsx-runtime").JSX.Element;
+declare const BreadcrumbIcon: (props?: SvgIconProps) => import("react/jsx-runtime").JSX.Element;
 declare const IframeIcon: (props?: SvgIconProps) => import("react/jsx-runtime").JSX.Element;
 declare const FormIcon: (props?: SvgIconProps) => import("react/jsx-runtime").JSX.Element;
+declare const ListBlockIcon: (props?: SvgIconProps) => import("react/jsx-runtime").JSX.Element;
 declare const SkipToMainIcon: (props?: SvgIconProps) => import("react/jsx-runtime").JSX.Element;
 /**
  * Generic layout-preset glyph: draws one outlined rect per cell, positioned
@@ -48,8 +50,4 @@ export declare const GridPresetIcon: (props: SvgIconProps & {
     cells: PresetIconCell[];
 }) => import("react/jsx-runtime").JSX.Element;
 declare const TableIcon: (props?: SvgIconProps) => import("react/jsx-runtime").JSX.Element;
-declare const ProgressBarIcon: (props?: SvgIconProps) => import("react/jsx-runtime").JSX.Element;
-declare const TimerBlockIcon: (props?: SvgIconProps) => import("react/jsx-runtime").JSX.Element;
-declare const ListBlockIcon: (props?: SvgIconProps) => import("react/jsx-runtime").JSX.Element;
-declare const BreadcrumbIcon: (props?: SvgIconProps) => import("react/jsx-runtime").JSX.Element;
-export { ContainerIcon, GridIcon, ImageIcon, TextIcon, ButtonIcon, HtmlIcon, VideoIcon, DividerIcon, DragIcon, HeadingIcon, StepperIcon, AvatarIcon, SpacerIcon, QuillEditorIcon, MarkDownIcon, VideoBlockIcon, LogoBlockIcon, FlexColumnsIcon, ColumnsIcon, GridBlockIcon, ContainerBlockIcon, SpacerBlockIcon, ButtonBlockIcon, ButtonGroupIcon, TabsIcon, AccordionIcon, YoutubeUrlIcon, MenuPickerIcon, IframeIcon, FormIcon, SkipToMainIcon, TableIcon, ProgressBarIcon, TimerBlockIcon, ListBlockIcon, BreadcrumbIcon, };
+export { ContainerIcon, GridIcon, ImageIcon, TextIcon, ButtonIcon, HtmlIcon, VideoIcon, DividerIcon, DragIcon, HeadingIcon, StepperIcon, AvatarIcon, SpacerIcon, QuillEditorIcon, MarkDownIcon, VideoBlockIcon, LogoBlockIcon, FlexColumnsIcon, ColumnsIcon, GridBlockIcon, ContainerBlockIcon, SpacerBlockIcon, ButtonBlockIcon, ButtonGroupIcon, TabsIcon, AccordionIcon, YoutubeUrlIcon, MenuPickerIcon, BreadcrumbIcon, IframeIcon, FormIcon, SkipToMainIcon, ListBlockIcon, TableIcon, };

package/dist/editor-sample/App/InspectorDrawer/LayoutPanel/templateHelpers.d.ts

@@ -1 +1,199 @@
 export declare const generateBlockId: () => string;
+/**
+ * Return the authored `formFields` for a template record no matter where the
+ * record stashes them. The save flow now writes fields exclusively inside
+ * `configuration` — page templates on `configuration.root.data.formFields`,
+ * block templates on `configuration.formFields`, tour/demo per step under
+ * `configuration.steps[i].contentMetadata.document.root.data.formFields`,
+ * tooltip on `configuration.step.contentMetadata.document.root.data.formFields`,
+ * and carousel per slide under `configuration.slides[i].…`. Older templates
+ * still keep a top-level `templateRecord.formFields` mirror; we check that as
+ * a fallback so applying legacy records keeps working. The order below
+ * matters: the fresher, configuration-scoped location wins over the legacy
+ * mirror. Multi-slot shapes concatenate every slot's fields (dedup by id)
+ * because apply operates on the whole template, not one step at a time.
+ */
+export declare function resolveTemplateFormFields(templateRecord: any): any[];
+/**
+ * Unwraps a saved template's `configuration` down to the raw document
+ * (`{root, ...}`) that `applyFullDocumentTemplate`/`applyTemplateStylesOnly`
+ * expect. Saved templates for multi-slide/step types wrap the document as
+ * `{type, slides: [{contentMetadata}]}` (app-banner — slides is an array) or
+ * `{type, step: {contentMetadata}}` (tooltip — step is a single object, not
+ * an array); page/faq wrap it as `{type, content: {contentMetadata}}`. Tour
+ * templates are handled separately via applyTourTemplate and never reach
+ * this helper.
+ *
+ * Backward compatible with templates saved before this wrapping existed,
+ * where `configuration` was already the raw document (or, briefly, a full
+ * un-trimmed step/slide object carrying `contentMetadata` alongside other
+ * fields) — every branch checks `configuration.root` first and returns it
+ * as-is before attempting to unwrap, so older records are never mistaken
+ * for the new wrapped shape.
+ */
+export declare const normalizeTemplateConfiguration: (configuration: any, effectivePageType: string, isTypeDemo: boolean) => any;
+/**
+ * Rewrite all internal child-id references inside a single block using `idMapping`.
+ * Exported so callers (e.g. SectionsModal) can reuse the same remapping logic
+ * without duplicating the switch/case.
+ */
+export declare function remapBlockChildIds(block: any, idMapping: Record<string, string>): any;
+/**
+ * Given a `blocks` map and an `idMapping` (oldId → newId), deep-clone every
+ * block, remap its child references, and return the new blocks map.
+ */
+export declare function remapBlocks(blocks: Record<string, any>, idMapping: Record<string, string>): Record<string, any>;
+export declare const applyIndividualBlockTemplate: (configuration: any, document: any, resetDocument: (doc: any) => void, replace?: boolean) => {
+    idMapping: {
+        [oldId: string]: string;
+    };
+};
+/**
+ * Remap a saved template's container-repeat fields onto a destination document.
+ * `sourceBlockId` is rewritten to the new (remapped) block id.
+ *
+ * `rowIds` carry the OTHER existing container blocks the author wired as extra
+ * rows (e.g. grid cell 2, carousel slide 3 — "Other blocks already on the
+ * canvas"). They are remapped through `idMapping` too so each pre-existing block
+ * keeps its own row + default values after apply. Any rowId not in the mapping
+ * (its block didn't come along) is dropped, and its matching `value` row with it.
+ *
+ * Non-repeat fields pass through unchanged. Repeat fields whose source isn't in
+ * the idMapping are dropped (their block didn't come along).
+ */
+export declare function remapTemplateFormFields(formFields: any, idMapping: {
+    [oldId: string]: string;
+}): any[];
+/**
+ * Replace the current session's formFields with the incoming template's fields,
+ * then jump to the Variables tab. Used by "Choose design" / full template apply
+ * — a fresh slate. Shared by SavedTemplates, Templates, and SectionsModal so the
+ * Variables panel reliably surfaces the fields (it only renders what's written
+ * into editor state via setTemplateForms — not fields sitting on the API record).
+ *
+ * `idMapping` is required when the apply path remaps block ids (individual-block
+ * apply); it rewrites container-repeat fields' `sourceBlockId` so the applied
+ * container stays repeatable from the Variables tab.
+ */
+export declare function mergeTemplateFormFields(templateRecord: any, idMapping?: {
+    [oldId: string]: string;
+}): void;
+/**
+ * Merge incoming formFields into the existing ones. Used by "Add this section"
+ * so adding Template B that shares {{name}} with Template A keeps the typed
+ * value and only appends B's new fields. Then jumps to Variables.
+ *
+ * Two dedupe rules — different because these fields mean different things:
+ *
+ *  - Scalar / plain-array fields are dedupe'd by `id`. A page-level `{{name}}`
+ *    is a single slot; inserting Template B that also references `{{name}}`
+ *    should reuse Template A's (possibly user-filled) value, not stomp it.
+ *
+ *  - Container-repeat fields (`type === 'array' && sourceBlockId`) are dedupe'd
+ *    by `sourceBlockId`. Each such field is scoped to ONE container instance
+ *    (a specific Grid / FlexColumns / Carousel), and its `sourceBlockId` gets
+ *    remapped per insertion. Inserting a testimonial section twice produces
+ *    two independent grid instances; BOTH need their own field or the second
+ *    grid's `{{this.subField}}` tokens can't find their row in
+ *    `buildRepeatRowIndex` (which keys off sourceBlockId/rowIds) and render as
+ *    bare pills. Same-token-id but different sourceBlockId → different field.
+ *
+ * When a new container-repeat field's id collides with an already-registered
+ * field (either a scalar sharing that name, or the same section inserted
+ * before), we suffix the id with its sourceBlockId so `buildContext` doesn't
+ * silently overwrite the earlier field. Sub-field tokens (`{{this.X}}`) are
+ * resolved via the row index by block id, so they don't care about the outer
+ * field's id.
+ */
+export declare function appendTemplateFormFields(templateRecord: any, idMapping?: {
+    [oldId: string]: string;
+}): void;
+export declare const applyFullDocumentTemplate: (configuration: any, document: any, resetDocument: (doc: any) => void) => void;
+/**
+ * Build the document "Change template" would produce, without touching the
+ * editor. `applyChangeTemplate` commits it; the template preview dialog
+ * renders it beside the current page.
+ */
+export declare const buildChangeTemplateDocument: (configuration: any, document: any, templateRecord?: any) => {
+    doc: any;
+    fields: any[];
+    current: any;
+} | null;
+export declare const applyChangeTemplate: (configuration: any, document: any, resetDocument: (doc: any) => void, templateRecord?: any) => void;
+/**
+ * "Use this Styles" for non-tour modules (pages, FAQ, app-banner, tooltip,
+ * template). Applies the template's styling — the root canvas AND every
+ * individual block (header, buttons, images, …) — while leaving the user's
+ * content and structure exactly as they were: text, links, image URLs, layout,
+ * block count and order are all untouched. Only visual props move (colours,
+ * typography, borders, spacing, alignment).
+ *
+ * Root: overlays the stricter `STYLE_ONLY_ROOT_KEYS` (typography / colours /
+ * border), then re-pins every user-owned root key via `preserveUserRootKeys`
+ * so the canvas geometry, background, CTA-existence and block list stay the
+ * user's — the page never resizes and no root CTA button appears/moves.
+ *
+ * Per-block: `overlayBlockStylesFromTemplate` — donor-matching + prop
+ * overlay; nothing is added, removed or re-keyed.
+ *
+ * History: a much older version of this function matched blocks by type,
+ * replaced each with the template's, and DELETED every unmatched block —
+ * clicking "Use this Styles" silently rewrote button labels / image URLs /
+ * column structure. `overlayStyle` + `CONTENT_AND_STRUCTURAL_KEYS` is what
+ * keeps the current version content-safe.
+ */
+export declare const applyTemplateStylesOnly: (configuration: any, document: any, resetDocument: (doc: any) => void) => void;
+export declare const applyTourTemplateStylesOnly: (configuration: any, record: any, activeStepIndex: number, onUpdateRecord: (record: any) => void, resetDocumentFn: (doc: any, options?: {
+    sideEffect?: {
+        undo: () => void;
+        redo: () => void;
+    };
+}) => void) => void;
+/**
+ * "Add this section" for a tour template. Replaces the ACTIVE step's
+ * document with the template's first step's document, while preserving the
+ * existing step's user-configured metadata (title, selector, behaviour,
+ * background). Other tour steps are untouched.
+ *
+ * Why "replace document, keep metadata":
+ *   - The user has already set up the step's selector / position /
+ *     behaviour for their app — those describe WHERE the tooltip anchors,
+ *     not WHAT it says. A new visual design shouldn't lose that.
+ *   - The template's CONTENT (blocks, layout, root style) is exactly what
+ *     the user is opting into when they pick a design preview.
+ *
+ * Falling through to `appendFullDocumentTemplate` here (the previous
+ * behaviour) merged the template's blocks INTO the user's existing
+ * content, doubling what's on the canvas. "Add this section" should hand
+ * over a clean section, not stack two on top of each other.
+ */
+export declare const replaceCurrentStepFromTourTemplate: (configuration: any, record: any, activeStepIndex: number, onUpdateRecord: (record: any) => void, resetDocumentFn: (doc: any, options?: {
+    sideEffect?: {
+        undo: () => void;
+        redo: () => void;
+    };
+}) => void) => void;
+export declare const applyTourTemplate: (configuration: any, record: any, activeStepIndex: number, onUpdateRecord: (record: any) => void, resetDocumentFn: (doc: any, options?: {
+    sideEffect?: {
+        undo: () => void;
+        redo: () => void;
+    };
+}) => void) => void;
+/**
+ * "Use this template" for app-banner (carousel) templates. Mirrors
+ * `applyTourTemplate` exactly, but keyed on `slides` instead of `steps` —
+ * app-banner carousels are multi-slide the same way tours are multi-step,
+ * so every slide in the template must land in the record, not just the
+ * first one.
+ */
+export declare const applyAppBannerTemplate: (configuration: any, record: any, activeStepIndex: number, onUpdateRecord: (record: any) => void, resetDocumentFn: (doc: any, options?: {
+    sideEffect?: {
+        undo: () => void;
+        redo: () => void;
+    };
+}) => void) => void;
+export declare const appendFullDocumentTemplate: (configuration: any, document: any, resetDocument: (doc: any) => void) => {
+    idMapping: {
+        [oldId: string]: string;
+    };
+};

package/dist/editor-sample/App/InspectorDrawer/LayoutPanel/useDebouncedValue.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns `value` delayed by `delay` ms, resetting the timer on every change.
+ *
+ * Used to keep server-side template search from firing a request per keystroke:
+ * the debounced value feeds the react-query `filter` (part of the query key),
+ * so a new request only goes out once typing pauses.
+ */
+export default function useDebouncedValue<T>(value: T, delay?: number): T;

package/dist/editor-sample/App/InspectorDrawer/VariablesPanel/AiGenerateButton.d.ts

@@ -0,0 +1,18 @@
+import { AiTargetField, AiValue } from './aiFill';
+type AiGenerateButtonProps = {
+    /** The fields eligible for AI fill — id/name/type. */
+    fields: AiTargetField[];
+    onGenerated: (values: AiValue[]) => void;
+    /** Overrides the default text-button trigger (label, look) and popover side. */
+    label?: string;
+    variant?: 'text' | 'outlined';
+    popoverBelow?: boolean;
+};
+/**
+ * Footer-level "Generate with AI" button for the variable group dialog. One
+ * prompt fills every eligible text/textarea field in the group at once — the
+ * fields are sent as `context.formFields` and the AI returns the same array
+ * back with `value` populated, at `generation.data.response.data.formFields`.
+ */
+export default function AiGenerateButton({ fields, onGenerated, label, variant, popoverBelow, }: AiGenerateButtonProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/editor-sample/App/InspectorDrawer/VariablesPanel/ItemsArrayRepeatSection.d.ts

@@ -5,9 +5,8 @@
  * `TemplateFormField` bound to this block's own items via `itemsBlockId`,
  * seeded from whatever items already exist.
  *
- * No block type currently opts in (see `ITEMS_ARRAY_BLOCK_TYPES` in
- * documentUtils), so this renders for nothing today — kept alongside the
- * block-agnostic helpers for the next items-array block.
+ * Opt-in list: `ITEMS_ARRAY_BLOCK_TYPES` in documentUtils (today MenuPicker,
+ * custom-menu mode).
  */
 export default function ItemsArrayRepeatSection({ blockId }: {
     blockId: string;

package/dist/editor-sample/App/InspectorDrawer/VariablesPanel/ScalarFieldRow.d.ts

@@ -1,12 +1,15 @@
+import { ReactNode } from 'react';
 import { TemplateFormField } from '../../../documents/editor/templateVariables';
 type Props = {
     field: TemplateFormField;
     onPatch: (patch: Partial<TemplateFormField>) => void;
+    /** Optional control rendered at the right of the label row (e.g. "locate in canvas"). */
+    headerAction?: ReactNode;
 };
 /**
  * One scalar variable row: name, a type selector (Text / Number / Date / Time /
  * Image), the value input, and — for `date` / `time` — the format + timezone
  * controls.
  */
-export default function ScalarFieldRow({ field, onPatch }: Props): import("react/jsx-runtime").JSX.Element;
+export default function ScalarFieldRow({ field, onPatch, headerAction }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/editor-sample/App/InspectorDrawer/VariablesPanel/VariableGroupDialog.d.ts

@@ -0,0 +1,19 @@
+import { TemplateFormField } from '../../../documents/editor/templateVariables';
+import { VariableGroup } from '../../../documents/blocks/helpers/documentUtils';
+import { VisibleForm } from './aiFill';
+type VariableGroupDialogProps = {
+    open: boolean;
+    group: VariableGroup | null;
+    groups: VariableGroup[];
+    onClose: () => void;
+    containerId: string | null;
+    itemsArrayBlockId: string | null;
+    visibleForms: VisibleForm[];
+    updateField: (index: number, patch: Partial<TemplateFormField>) => void;
+    updateFields: (patches: {
+        index: number;
+        patch: Partial<TemplateFormField>;
+    }[]) => void;
+};
+export default function VariableGroupDialog({ open, group, groups, onClose, containerId, itemsArrayBlockId, visibleForms, updateField, updateFields, }: VariableGroupDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/editor-sample/App/InspectorDrawer/VariablesPanel/VariableGroupList.d.ts

@@ -1,4 +1,9 @@
 import { VariableGroup } from '../../../documents/blocks/helpers/documentUtils';
+export declare function groupIcon(group: VariableGroup): import('@mui/material/OverridableComponent').OverridableComponent<import('@mui/material').SvgIconTypeMap<{}, "svg">> & {
+    muiName: string;
+};
+export declare function groupLabel(group: VariableGroup, groups: VariableGroup[]): string;
+export declare function groupSubtitle(group: VariableGroup): string;
 type Props = {
     groups: VariableGroup[];
     onOpen: (group: VariableGroup) => void;

package/dist/editor-sample/App/InspectorDrawer/VariablesPanel/aiFill.d.ts

@@ -0,0 +1,75 @@
+import { TemplateArrayRow, TemplateFormField, TemplateScalarType } from '../../../documents/editor/templateVariables';
+export type VisibleForm = {
+    field: TemplateFormField;
+    index: number;
+};
+export type AiTargetField = {
+    id: string;
+    name: string;
+    type?: TemplateScalarType;
+};
+export type AiValue = {
+    id: string;
+    value: string;
+};
+type UpdateFields = (patches: {
+    index: number;
+    patch: Partial<TemplateFormField>;
+}[]) => void;
+/**
+ * Fields eligible for AI fill. Scalars keep their own id. Repeated-block
+ * (array) fields get one entry per row/sub-field, id namespaced as
+ * "<fieldIndex>::<rowIndex>::<subFieldId>" so same-named sub-fields across
+ * rows/blocks don't collide in the flat AI response.
+ */
+export declare function buildAiFields(visibleForms: VisibleForm[]): {
+    aiFields: AiTargetField[];
+    scalarIndexById: Map<string, number>;
+};
+/** Writes generated values back onto scalar fields and array rows. */
+export declare function applyAiValues(values: AiValue[], visibleForms: VisibleForm[], scalarIndexById: Map<string, number>, updateFields: UpdateFields): void;
+/**
+ * Template variables (root.data.formFields) serialized for an AI request's
+ * `context.formFields`, so text generation can see field names + current values.
+ * Same per-field shape `requestAiFill` sends; array fields also carry their
+ * sub-field defs and current rows.
+ */
+export declare function toAiFormFieldsContext(forms: TemplateFormField[]): ({
+    itemFields: {
+        id: string;
+        name: string;
+        type: TemplateScalarType;
+    }[];
+    value: TemplateArrayRow[];
+    id: string;
+    name: string;
+    type: import('../../../documents/editor/templateVariables').TemplateFormType;
+    defaultValue: string;
+} | {
+    value: string;
+    id: string;
+    name: string;
+    type: import('../../../documents/editor/templateVariables').TemplateFormType;
+    defaultValue: string;
+})[];
+/**
+ * Only the fields whose `{{id}}` (or `{{#each id}}`) token appears in `text` —
+ * i.e. the variables a single block actually uses. Same token pattern as
+ * templateVariables' collectUsedTokenIds.
+ */
+export declare function formFieldsUsedInText(text: string, forms: TemplateFormField[]): TemplateFormField[];
+/**
+ * AI-fill only the variables a block's text uses, writing the generated values
+ * onto root.data.formFields — the block text itself (with its {{tokens}}) is
+ * left untouched. Returns null when the text uses no variables (caller falls
+ * back to generating the text), false when the request failed (already
+ * toasted), true once values are written.
+ */
+export declare function fillTextFormFieldsWithAi(prompt: string, text: string, extraContext?: Record<string, unknown>): Promise<boolean | null>;
+export declare function requestRichTextAi(prompt: string, content: string, fieldId?: string): Promise<string | null>;
+/**
+ * One prompt → values for every field. Returns null (after toasting) when the
+ * request fails or yields nothing usable; null silently when `signal` aborts it.
+ */
+export declare function requestAiFill(prompt: string, fields: AiTargetField[], signal?: AbortSignal, extraContext?: Record<string, unknown>): Promise<AiValue[] | null>;
+export {};

package/dist/editor-sample/App/InspectorDrawer/VariablesPanel/styles.d.ts

@@ -6,7 +6,19 @@ export declare const panelDescription: SxProps<Theme>;
 export declare const panelContent: SxProps<Theme>;
 export declare const panelLearnMore: SxProps<Theme>;
 export declare const emptyState: SxProps<Theme>;
+export declare const paywallOverlay: SxProps<Theme>;
+export declare const paywallGhostContent: SxProps<Theme>;
+export declare const paywallGhostHeader: SxProps<Theme>;
+export declare const paywallGhostTitleText: SxProps<Theme>;
+export declare const paywallGhostSubText: SxProps<Theme>;
+export declare const paywallGhostFieldLabel: SxProps<Theme>;
+export declare const paywallGhostInput: SxProps<Theme>;
+export declare const paywallTitle: SxProps<Theme>;
+export declare const paywallDescription: SxProps<Theme>;
+export declare const paywallButton: SxProps<Theme>;
+export declare const paywallLearnMore: SxProps<Theme>;
 export declare const groupListWrap: SxProps<Theme>;
+export declare const standaloneFieldsWrap: SxProps<Theme>;
 export declare const groupListCaption: SxProps<Theme>;
 export declare const groupCard: SxProps<Theme>;
 export declare const groupCardHead: SxProps<Theme>;
@@ -26,19 +38,10 @@ export declare const groupRowChevron: SxProps<Theme>;
 export declare const backRow: SxProps<Theme>;
 export declare const backIcon: SxProps<Theme>;
 export declare const backLabel: SxProps<Theme>;
-export declare const paywallOverlay: SxProps<Theme>;
-export declare const paywallGhostContent: SxProps<Theme>;
-export declare const paywallGhostHeader: SxProps<Theme>;
-export declare const paywallGhostTitleText: SxProps<Theme>;
-export declare const paywallGhostSubText: SxProps<Theme>;
-export declare const paywallGhostFieldLabel: SxProps<Theme>;
-export declare const paywallGhostInput: SxProps<Theme>;
-export declare const paywallTitle: SxProps<Theme>;
-export declare const paywallDescription: SxProps<Theme>;
-export declare const paywallButton: SxProps<Theme>;
-export declare const paywallLearnMore: SxProps<Theme>;
 export declare const arrayFieldWrap: SxProps<Theme>;
 export declare const scalarFieldWrap: SxProps<Theme>;
+export declare const variableRowHighlightColor: (theme: Theme) => string;
+export declare const locateFieldButton: SxProps<Theme>;
 export declare const fieldLabel: SxProps<Theme>;
 export declare const containerSection: SxProps<Theme>;
 export declare const containerHeaderIcon: SxProps<Theme>;

package/dist/editor-sample/App/InspectorDrawer/VariablesPanel/upgradeDialog.d.ts

@@ -1,12 +1,11 @@
-export declare function setUpgradeHandler(handler: (() => void) | null | undefined): void;
-/**
- * Consumer hook used by every paywall trigger (VariablesPaywall etc.).
- * Returns a single `openUpgrade` function that:
- *   - Delegates to the host callback if one is registered, OR
- *   - Opens the built-in `<UpgradeDialog>` otherwise.
- */
+/** Optional copy for the dialog — same shape as ahd-fe's `UpgradeDialogContent`. */
+export type UpgradeDialogContent = {
+    title?: string;
+    description?: string;
+};
+export declare function setUpgradeHandler(handler: ((content?: UpgradeDialogContent) => void) | null | undefined): void;
 export declare function useUpgradeDialog(): {
-    openUpgrade: () => void;
+    openUpgrade: (content?: UpgradeDialogContent | unknown) => void;
 };
 /**
  * Reader hook used by the built-in `<UpgradeDialog>` mount to subscribe to
@@ -15,5 +14,6 @@ export declare function useUpgradeDialog(): {
  */
 export declare function useUpgradeStore(): {
     open: boolean;
+    content: UpgradeDialogContent | undefined;
     close: () => void;
 };

package/dist/editor-sample/App/InspectorDrawer/VariablesPanel/useAutoRegisterTokenFields.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A `{{token}}` typed anywhere on the page becomes a variable right away — not
+ * only once the page is saved as a template. Appends a field for every scalar
+ * token with no matching form field. Once added it's no longer "missing", so
+ * this can't loop. Mounted from the always-present inspector drawer so the
+ * variable already exists when the Variables tab is opened.
+ */
+export default function useAutoRegisterTokenFields(): void;

package/dist/editor-sample/App/InspectorDrawer/behaviourFields.d.ts

@@ -0,0 +1,30 @@
+export declare const BehaviourFieldTypes: {
+    ELEMENT_ID: string;
+    LINK: string;
+    POSITION: string;
+    TRIGGER_BEHAVIOUR: string;
+    TRIGGER_MODE: string;
+    TRIGGER_LABEL: string;
+    TRIGGER_ICON: string;
+    ANIMATION: string;
+    SHOW_STEP: string;
+    DELAY: string;
+    NAVIGATION_MODE: string;
+    DISMISS_SETTINGS: string;
+    ICON_CLOSE_COLOR: string;
+    SHOW_CLOSE_ICON: string;
+    VISIBILITY: string;
+    TOOLTIP_ADDONS: string;
+    FLOATER_POSITION: string;
+    FLOATER_OFFSET: string;
+};
+export type BehaviourFieldType = (typeof BehaviourFieldTypes)[keyof typeof BehaviourFieldTypes];
+export type BehaviourField = {
+    type: BehaviourFieldType;
+    label?: string;
+    sectionLabel?: string;
+    valueFrom?: string;
+    updateKey?: string;
+    placeholder?: string;
+};
+export declare const getBehaviourFields: (pageType?: string, subType?: string) => BehaviourField[];

package/dist/editor-sample/App/InspectorDrawer/components/RichTextAiButton.d.ts

@@ -0,0 +1,7 @@
+type Props = {
+    content: string;
+    fieldId?: string;
+    onGenerated: (html: string) => void;
+};
+export default function RichTextAiButton({ content, fieldId, onGenerated }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/editor-sample/App/InspectorDrawer/index.d.ts

@@ -2,6 +2,8 @@ import { EditorPanelToggles } from './EditorBehavior';
 export declare const INSPECTOR_DRAWER_WIDTH = 413;
 interface InspectorDrawerProps {
     record: any;
+    needsAiSync?: boolean;
+    onAiSynced?: () => void;
     onTogglePreview: () => void;
     activeStepIndex: number;
     onBackgroundChange: (image: string) => void;
@@ -11,6 +13,11 @@ interface InspectorDrawerProps {
     onNavigateBranding?: () => void;
     /** Toggle visibility of the four side panels. */
     panels?: EditorPanelToggles;
+    inspectorWidth: number;
+    handleMouseDown: (e: React.MouseEvent) => void;
+    isPanelCollapsed: boolean;
+    toggleCollapsed: () => void;
+    handleOpenPanel: () => void;
 }
-export default function InspectorDrawer({ record, onTogglePreview, activeStepIndex, onBackgroundChange, onUpdateRecord, onSaveChanges, isExternalSection, onNavigateBranding, panels, }: InspectorDrawerProps): import("react/jsx-runtime").JSX.Element;
+export default function InspectorDrawer({ record, needsAiSync, onAiSynced, onTogglePreview, activeStepIndex, onBackgroundChange, onUpdateRecord, onSaveChanges, isExternalSection, onNavigateBranding, panels, inspectorWidth, handleMouseDown, isPanelCollapsed, toggleCollapsed, handleOpenPanel, }: InspectorDrawerProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/editor-sample/App/InspectorDrawer/publish/BackgroundPanel.d.ts

@@ -0,0 +1,6 @@
+interface BackgroundPanelProps {
+    record?: any;
+    onBackgroundChange?: (url: string | null) => void;
+}
+declare const BackgroundPanel: ({ record, onBackgroundChange }: BackgroundPanelProps) => import("react/jsx-runtime").JSX.Element;
+export default BackgroundPanel;

package/dist/editor-sample/App/InspectorDrawer/renderBehaviourField.d.ts

@@ -0,0 +1,7 @@
+import { BehaviourField } from './behaviourFields';
+type Props = {
+    field: BehaviourField;
+    context: any;
+};
+export declare const renderBehaviourField: ({ field, context }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/editor-sample/App/TemplatePanel/hooks/useMainBoxStyles.d.ts

@@ -7,6 +7,7 @@ interface GetMainBoxSxProps {
     isPreviewOpen: boolean;
     selectedScreenSize: string;
     layoutData: any;
+    isPageType?: boolean;
 }
-export declare const useMainBoxStyles: ({ pageType, backgroundImage, pageHtml, isPreviewOpen, selectedScreenSize, layoutData, }: GetMainBoxSxProps) => SxProps;
+export declare const useMainBoxStyles: ({ pageType, backgroundImage, pageHtml, isPreviewOpen, selectedScreenSize, layoutData, isPageType: isPageTypeProp, }: GetMainBoxSxProps) => SxProps;
 export {};

package/dist/editor-sample/App/TemplatePanel/index.d.ts

@@ -11,6 +11,7 @@ interface TemplatePanelProps {
     activeSection?: PageSection;
     activeSectionIndex?: number;
     onAddSection?: () => void;
+    sidebarWidth?: number;
 }
-export default function TemplatePanel({ record, isPreviewOpen, activeStepIndex, fetchTooltip, backgroundImage, pageHtml, isPageHtmlFetching, loading, activeSectionIndex, onAddSection, }: TemplatePanelProps): import("react/jsx-runtime").JSX.Element;
+export default function TemplatePanel({ record, isPreviewOpen, activeStepIndex, fetchTooltip, backgroundImage, pageHtml, isPageHtmlFetching, loading, activeSectionIndex, onAddSection, sidebarWidth, }: TemplatePanelProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/editor-sample/App/TemplatePanel/minimap/useMiniMapSync.d.ts

@@ -11,8 +11,8 @@ type Options = {
  * Reads scroll geometry off whichever element is actually scrolling in the
  * host DOM. The resolved element is locked onto the first real scroll
  * event received on the page and kept until it either leaves the DOM or
- * stops being scrollable — so pagepilot's Shell wrapper and ahd-fe's
- * `mainBoxSx` both work without the caller having to know.
+ * stops being scrollable — so both ahd-fe's `mainBoxSx` and pagepilot's
+ * Shell wrapper work without the caller having to know which is which.
  */
 export declare function useMiniMapSync({ scrollBoxRef, contentRef, enabled }: Options): {
     viewportRect: ViewportRect;

package/dist/editor-sample/App/TemplatePanel/pageGuide/iframeSrcDoc.d.ts

@@ -1,6 +1,3 @@
-/**
- * Builds the `srcDoc` HTML for the iframe that shows the saved page as the page-tour
- * editor backdrop. Strips anything that would execute the live tour on top of the preview
- * (our injected integration block, stray <script>/<noscript> tags).
- */
-export declare function buildIframeSrcDoc(pageHtml: string): string;
+export declare function buildIframeSrcDoc(pageHtml: string, opts?: {
+    ppTheme?: 'light' | 'dark';
+}): string;

package/dist/editor-sample/App/hooks/page/saveMenuHrefEdits.d.ts

@@ -1 +1 @@
-export declare const saveMenuHrefEdits: (_doc: Record<string, any>) => Promise<void>;
+export declare const saveMenuHrefEdits: (document: Record<string, any>) => Promise<void>;

package/dist/editor-sample/App/hooks/page/useSaveHandler.d.ts

@@ -2,6 +2,7 @@ type UseSaveHandlerReturn = {
     onShowHtml: (type: 'live' | 'draft' | null, options?: {
         injectTabsScrollSyncScript?: boolean;
         injectCarouselScript?: boolean;
+        injectPaginationScript?: boolean;
         injectAnimationScript?: boolean;
         schedule?: {
             startDate?: Date | null;

package/dist/editor-sample/App/hooks/useAutosave.d.ts

@@ -1,10 +1,15 @@
 export type UseAutosaveOptions = {
     isDirty: boolean;
-    onSave: () => Promise<any> | void;
+    onSave: () => void | Promise<unknown>;
     enabled?: boolean;
     isSaving?: boolean;
     intervalMs?: number;
 };
+export type UseAutosaveResult = {
+    contentEnabled: boolean;
+    contentToggleLoading: boolean;
+    toggleContentEnabled: (checked: boolean) => Promise<void>;
+};
 export declare const AUTOSAVE_ENABLED = true;
-export declare const AUTOSAVE_INTERVAL_MS = 60000;
-export default function useAutosave({ isDirty, onSave, enabled, isSaving, intervalMs, }: UseAutosaveOptions): void;
+export declare const AUTOSAVE_INTERVAL_MS = 90000;
+export default function useAutosave({ isDirty, onSave, enabled, isSaving, intervalMs, }: UseAutosaveOptions): UseAutosaveResult;