pagepilot-visual-editor 1.0.28 → 1.0.30

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

@@ -1 +1,227 @@
 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;
+/**
+ * "Change template": apply the incoming template's styling — both the root
+ * canvas AND every individual block (menu, header, buttons, images, etc.) —
+ * while leaving user content and structure exactly as they were.
+ *
+ * Root overlay: root-level style keys copied via `PURE_STYLE_KEYS` (the wide
+ * list — "Change template" is the confirm-gated aggressive restyle).
+ * Per-block overlay: `overlayBlockStylesFromTemplate`.
+ *
+ * Confirmation copy the user sees before this fires:
+ *   "You can change the template, but please note that only the common
+ *    fields will be retained; any unused data will be removed."
+ * "Common fields" is the form-fields half — see
+ * `mergeTemplateFormFieldsPreservingValues`.
+ */
+export declare const applyChangeTemplate: (configuration: any, document: any, resetDocument: (doc: any) => void) => void;
+/**
+ * Sidebar-side counterpart to `applyChangeTemplate`. The user's blocks
+ * stay on the canvas, so any `{{token}}` they already contain must keep
+ * a matching form-field entry — otherwise the token renders as an unbound
+ * "Add X" pill. This helper therefore takes the union approach:
+ *
+ *   - Every existing form field the user has is retained VERBATIM (id,
+ *     type, value, everything). Tokens keep resolving to the values the
+ *     user typed.
+ *   - Any field the incoming template defines that the user doesn't
+ *     already have is appended with its prefilled default. New template
+ *     structure that references brand-new tokens still lights up.
+ *   - Nothing is deleted. "Unused data will be removed" from the confirm
+ *     copy cannot apply here: removing a field whose token still lives
+ *     on the canvas would break the very content we just promised not
+ *     to touch.
+ *
+ * Container-repeat fields (`type === 'array'` with `sourceBlockId`)
+ * follow the same "already there? keep it" rule; the underlying
+ * container blocks weren't remapped by `applyChangeTemplate`, so
+ * `sourceBlockId` and `rowIds` stay valid.
+ */
+export declare function mergeTemplateFormFieldsPreservingValues(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` — same donor-matching + prop
+ * overlay "Change template" uses; 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/AiFillAllDialog.d.ts

@@ -0,0 +1,21 @@
+import { TemplateFormField } from '../../../documents/editor/templateVariables';
+import { VariableGroup } from '../../../documents/blocks/helpers/documentUtils';
+type Props = {
+    open: boolean;
+    onClose: () => void;
+    groups: VariableGroup[];
+    forms: TemplateFormField[];
+    document: any;
+    updateField: (index: number, patch: Partial<TemplateFormField>) => void;
+    updateFields: (patches: {
+        index: number;
+        patch: Partial<TemplateFormField>;
+    }[]) => void;
+};
+/**
+ * Every variable group's fields in one dialog, with a single "Generate with AI"
+ * that fills them all. Mirrors VariableGroupDialog: edits apply live, Cancel
+ * restores the snapshot taken on open, Save keeps them.
+ */
+export default function AiFillAllDialog({ open, onClose, groups, forms, document, updateField, updateFields, }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,14 @@
+import { AiTargetField, AiValue } from './aiFill';
+type AiGenerateButtonProps = {
+    /** The fields eligible for AI fill — id/name/type. */
+    fields: AiTargetField[];
+    onGenerated: (values: AiValue[]) => void;
+};
+/**
+ * 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 }: AiGenerateButtonProps): import("react/jsx-runtime").JSX.Element;
+export {};

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,36 @@
+import { 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;
+/**
+ * One prompt → values for every field. Returns null (after toasting) when the
+ * request fails or yields nothing usable.
+ */
+export declare function requestAiFill(prompt: string, fields: AiTargetField[]): 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/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/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/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;

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

@@ -0,0 +1 @@
+export default function useIsTemplateEditorRoute(): boolean;

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

@@ -0,0 +1,9 @@
+export declare const INSPECTOR_RAIL_WIDTH = 88;
+declare const useStretch: () => {
+    inspectorWidth: number;
+    handleMouseDown: (e: React.MouseEvent) => void;
+    isPanelCollapsed: boolean;
+    toggleCollapsed: () => void;
+    handleOpenPanel: () => void;
+};
+export default useStretch;

package/dist/editor-sample/App/shared/UploadImage.d.ts

@@ -0,0 +1,4 @@
+declare const UploadImage: ({ onImageSelect }: {
+    onImageSelect: any;
+}) => import("react/jsx-runtime").JSX.Element;
+export default UploadImage;

package/dist/editor-sample/App/shared/editor.styles.d.ts

@@ -18,4 +18,14 @@ export declare const widthUnitSelectSx: {
         paddingBottom: string;
     };
 };
-export declare const BorderedIconButton: import('@emotion/styled').StyledComponent<import('@mui/material').IconButtonOwnProps & Omit<import('@mui/material').ButtonBaseOwnProps, "classes"> & import('@mui/material/OverridableComponent').CommonProps & Omit<import('react').DetailedHTMLProps<import('react').ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "style" | "children" | "className" | "size" | "color" | "disabled" | "action" | "tabIndex" | "loading" | "classes" | "sx" | "centerRipple" | "disableRipple" | "disableTouchRipple" | "focusRipple" | "focusVisibleClassName" | "LinkComponent" | "onFocusVisible" | "TouchRippleProps" | "touchRippleRef" | "disableFocusRipple" | "edge" | "loadingIndicator"> & import('@mui/system').MUIStyledCommonProps<import('@mui/material').Theme>, {}, {}>;
+export declare const BorderedIconButton: import('@emotion/styled').StyledComponent<import('@mui/material').IconButtonOwnProps & Omit<import('@mui/material').ButtonBaseOwnProps, "classes"> & import('@mui/material/OverridableComponent').CommonProps & Omit<import('react').DetailedHTMLProps<import('react').ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "style" | "children" | "className" | "size" | "color" | "disabled" | "action" | "tabIndex" | "classes" | "sx" | "loading" | "centerRipple" | "disableRipple" | "disableTouchRipple" | "focusRipple" | "focusVisibleClassName" | "LinkComponent" | "onFocusVisible" | "TouchRippleProps" | "touchRippleRef" | "disableFocusRipple" | "edge" | "loadingIndicator"> & import('@mui/system').MUIStyledCommonProps<import('@mui/material').Theme>, {}, {}>;
+export declare const zoomButtonSx: {
+    borderRadius: string;
+    transition: string;
+    '&:hover': {
+        backgroundColor: string;
+        boxShadow: string;
+    };
+};
+export declare const AutoSaveContentToggleWrapper: import('@emotion/styled').StyledComponent<import('@mui/system').MUIStyledCommonProps<import('@mui/material').Theme>, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const AutoSaveContentIndicatorBox: import('@emotion/styled').StyledComponent<import('@mui/system').MUIStyledCommonProps<import('@mui/material').Theme>, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

package/dist/editor-sample/documents/blocks/Container/ContainerPropsSchema.d.ts

@@ -2,7 +2,7 @@ import { z } from 'zod';
 declare const ContainerPropsSchema: z.ZodObject<{
     style: z.ZodNullable<z.ZodOptional<z.ZodObject<{
         backgroundColor: z.ZodPreprocess<z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodString, z.ZodString, z.ZodLiteral<"transparent">]>>>>;
-        backgroundImage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        backgroundImage: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodString]>>>;
         backgroundSize: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         backgroundRepeat: z.ZodNullable<z.ZodOptional<z.ZodEnum<{
             repeat: "repeat";
@@ -71,8 +71,8 @@ declare const ContainerPropsSchema: z.ZodObject<{
         widthTablet: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
         widthMobile: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
         height: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
-        heightTablet: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
-        heightMobile: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        heightTablet: z.ZodNullable<z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"auto">]>>>;
+        heightMobile: z.ZodNullable<z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"auto">]>>>;
         overflow: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
         alignment: z.ZodNullable<z.ZodOptional<z.ZodEnum<{
             right: "right";
@@ -147,4 +147,6 @@ declare const ContainerPropsSchema: z.ZodObject<{
     }, z.core.$strip>>>;
 }, z.core.$strip>;
 export default ContainerPropsSchema;
-export type ContainerProps = z.infer<typeof ContainerPropsSchema>;
+export type ContainerProps = z.infer<typeof ContainerPropsSchema> & {
+    blockId?: string;
+};