pagepilot-visual-editor 1.0.29 → 1.0.30

package/dist/editor-sample/documents/editor/templateVariables.d.ts

@@ -1,9 +1,140 @@
 import { TEditorConfiguration } from './core';
-import { TemplateFormField } from '../../../render-core/templateBaking';
-export { bakeTemplateValues, substituteBlockText, applyVariables, buildRepeatRowIndex, getTemplateForms, getTextFieldsForType, TEMPLATE_SCALAR_TYPES, } from '../../../render-core/templateBaking';
-export type { TemplateScalarType, TemplateFormType, TemplateItemFieldDef, TemplateArrayRow, TemplateFormField, } from '../../../render-core/templateBaking';
-export type { DateFormatPreset, TimeFormatPreset } from '../../../render-core/dateFormats';
-export { DATE_FORMAT_PRESETS, DEFAULT_DATE_FORMAT, DEFAULT_TIME_FORMAT, formatDateValue, formatRelativeDate, formatTimeValue, TIME_FORMAT_PRESETS, } from '../../../render-core/dateFormats';
+import { DateFormatPreset, TimeFormatPreset } from '../../../host-stubs/utils/dateFormats';
+/**
+ * The kinds of single-value template field. `array` is repeatable and handled
+ * separately. `text` / `textarea` substitute as plain strings, `number` as a
+ * numeric string, `image` as an image URL (used in Image/Avatar/Logo blocks),
+ * `date` an ISO date string rendered through a display format (see `dateFormat`).
+ * `time` an ISO date string rendered as just its time portion (see `timeFormat`).
+ * `datetime` one ISO string exposing TWO sub-tokens — `{{id.date}}` (formatted
+ *   via `dateFormat`) and `{{id.time}}` (via `timeFormat`) — so a single value /
+ *   API mapping can print its date and time in separate blocks.
+ */
+export type TemplateScalarType = 'text' | 'textarea' | 'number' | 'image' | 'date' | 'time' | 'datetime';
+export type TemplateFormType = TemplateScalarType | 'array';
+/** All scalar types — used by both top-level fields and array sub-fields. */
+export declare const TEMPLATE_SCALAR_TYPES: TemplateScalarType[];
+export type TemplateItemFieldDef = {
+    id: string;
+    name: string;
+    /** Sub-field input kind. Defaults to `text` when absent (legacy rows). */
+    type?: TemplateScalarType;
+    /** Author-set default value, used to prefill the row when a template is applied. */
+    defaultValue?: string;
+    /** `date` sub-fields only — see the same fields on TemplateFormField. */
+    dateFormat?: DateFormatPreset;
+    /** `time` sub-fields only — 24h / AM/PM. Timezone reuses `dateTz`. */
+    timeFormat?: TimeFormatPreset;
+    dateTz?: string;
+};
+export type TemplateArrayRow = Record<string, string>;
+export type TemplateFormField = {
+    id: string;
+    name: string;
+    type: TemplateFormType;
+    value?: string | TemplateArrayRow[];
+    defaultValue?: string;
+    itemFields?: TemplateItemFieldDef[];
+    sourceBlockId?: string;
+    rowIds?: string[];
+    /**
+     * `date` fields only. How the ISO `value` is displayed:
+     *   - `relative` (default) → "Today" / "Tomorrow" / "Mar 25", recomputed in the
+     *     reader's browser at view time (emitted as a `data-ahd-date` marker span,
+     *     NOT baked to a fixed string). Uses the reader's local timezone.
+     *   - any absolute preset → a fixed string ("9th Sep 2026" …) resolved at bake
+     *     time in `dateTz`.
+     * See src/utils/dateFormats.ts for the preset list.
+     */
+    dateFormat?: DateFormatPreset;
+    /**
+     * `time` fields only. How the ISO `value`'s time portion is displayed:
+     *   - `24h` (default) → "20:42"
+     *   - `12h` → "8:42 PM"
+     * Always baked to a fixed string (no relative mode). Rendered in `dateTz`.
+     */
+    timeFormat?: TimeFormatPreset;
+    /**
+     * `date` fields with an absolute `dateFormat`, and all `time` fields. IANA
+     * timezone the value is rendered in (e.g. "America/New_York"). Ignored by
+     * `date`'s `relative` preset.
+     */
+    dateTz?: string;
+    /**
+     * Set on a container-repeat array field driven from the Variables tab's
+     * "Repeatable container" flow: the id of the Grid/FlexColumns/ColumnsContainer
+     * whose EMPTY slots get stamped with clones of `sourceBlockId`'s subtree.
+     * (`sourceBlockId` = the block sitting in the container's first filled slot;
+     * `rowIds` = the stamped clones' roots, one per filled empty slot.)
+     */
+    containerId?: string;
+    /**
+     * Set on a direct items-array data-source field: the id of
+     * the block whose OWN `data.props.items` gets seeded straight from the Data
+     * Reference source. Unlike `sourceBlockId`, there's no cloned subtree —
+     * `itemsBlockId` points at the block itself, and rows write directly into
+     * its `items` array. Presence of `itemsBlockId` (instead of `sourceBlockId`)
+     * is what routes ArrayFieldEditor/DataReferencePanel down the items-array
+     * path instead of the container-repeat path.
+     */
+    itemsBlockId?: string;
+    /**
+     * Author flag set from "Set template details" → Template Fields: marks this
+     * field's content as intended to be repeated once the template is applied
+     * (e.g. across grid cells / carousel slides). Pure metadata — carried through
+     * from the saved template record, doesn't drive any runtime behavior itself.
+     */
+    repeatable?: boolean;
+    /**
+     * The id of the block template this repeatable field is bound to — captured
+     * when the field's block is saved via the Variables-panel "Save as New
+     * Template" shortcut. Gives a reference to WHICH template drives this grid so
+     * the "Change Template" flow can key-match form fields on replace, and the
+     * Data Reference tab knows the source template.
+     */
+    templateId?: string;
+    /**
+     * "Data Reference" binding for a repeatable field: where the repetition data
+     * comes from. `custom` = the manual rows editor (default). `api`/`menu` pull
+     * an array of objects whose keys map to this field's sub-field ids; each
+     * object seeds one repeated copy. `customJson` holds the pasted JSON text for
+     * the `custom-json` source. Only meaningful when `repeatable` is set.
+     */
+    dataSource?: {
+        /** `api` = fetch an array of objects from a REST endpoint. */
+        type: 'custom' | 'custom-json' | 'api' | 'menu';
+        /** Raw JSON text for `custom-json`. */
+        customJson?: string;
+        /** Endpoint URL for the `api` source. Persisted in config. */
+        apiUrl?: string;
+        /** HTTP method for the `api` source. Only GET works today; POST is planned. */
+        apiMethod?: 'GET' | 'POST';
+        /**
+         * Optional dot-path (e.g. "data.ALL.games") into the response body where
+         * the array of objects lives. When empty, the array is auto-detected from
+         * common wrapper keys (data / rows / results / items / records).
+         */
+        apiResponsePath?: string;
+        /**
+         * REPEATABLE fields: optional dot-path applied to EACH array element before
+         * its keys are matched to sub-field ids. Use it when the fields you want are
+         * nested inside a wrapper on every row, e.g. `[{ "event": { "nextStart": … } }]`
+         * → set `apiItemPath: "event"` so `nextStart` maps directly.
+         * Works for the `api` and `custom-json` sources.
+         */
+        apiItemPath?: string;
+        /** Selected menu id for `menu`. */
+        menuId?: string;
+        /**
+         * SCALAR fields only: dot-path into the fetched object for THIS field's
+         * value, overriding the default key lookup by field id. e.g. field `name`
+         * with `apiObjectPath: "user.fullName"` reads `body.user.fullName`.
+         * (`apiResponsePath` still points at the object itself within the response.)
+         */
+        apiObjectPath?: string;
+    };
+};
+export declare function buildRepeatRowIndex(document: TEditorConfiguration | null | undefined, fields: TemplateFormField[] | null | undefined): Map<string, TemplateArrayRow>;
 /**
  * Apply `sourceHtml`'s formatting shell to `targetHtml`'s text. If the source
  * has no formatting, returns the target unchanged (keeps the copy's text as-is).
@@ -15,15 +146,6 @@ export declare function applyRowFormatting(sourceHtml: string, targetHtml: strin
  * each row's text). Returns a new `fields` array; unrelated fields pass through.
  */
 export declare function syncRepeatRowFormatting(fields: TemplateFormField[], document: TEditorConfiguration | null | undefined, sourceRootId: string): TemplateFormField[];
-/**
- * Split the HTML around a `{{token}}` into the wrapper the block put around it
- * (the opening tags/styles before the token) and the trailing wrapper (the
- * closing tags after it). Used by the sidebar's mini-rich-text editor so a
- * value edited inside the popover can be re-composed back into the wrapping
- * `<font color=...><span style=...>…</span></font>` chain the inline editor
- * committed the token with — otherwise the sidebar edit would strip that
- * formatting on save. Returns empty prefix+suffix if no token is present.
- */
 export declare function splitTokenWrapper(rawText: string): {
     prefix: string;
     suffix: string;
@@ -71,4 +193,19 @@ export declare function resolveEditableTokenField(rawText: string, blockId: stri
  * Returns the SAME reference when nothing changed so callers can skip a write.
  */
 export declare function pruneOrphanFormFields(document: TEditorConfiguration | null | undefined, fields: TemplateFormField[] | null | undefined): TemplateFormField[];
+export declare function getTextFieldsForType(type: string | undefined): string[] | undefined;
+export declare function getTemplateForms(document: TEditorConfiguration | null | undefined): TemplateFormField[];
+export declare function applyVariables(input: string | null | undefined, fields: TemplateFormField[] | null | undefined, rowContext?: TemplateArrayRow | null): string;
+export declare function substituteBlockText(block: any, fields: TemplateFormField[] | null | undefined, rowContext?: TemplateArrayRow | null, rowIndex?: Map<string, TemplateArrayRow> | null): any;
+/**
+ * Permanently substitute every token into the document and drop `formFields`
+ * from `root.data`. Used on publish/save.
+ *
+ * One deliberate exception to "bake = final text": a `date` field whose
+ * `dateFormat` is `relative` bakes to a `<span data-ahd-date="<iso>" …>` marker
+ * (via `buildContext` → `markDateVar`), not to "Today". The saved-HTML runtime
+ * in `renderers/pageScripts.ts` formats it in the reader's browser so the label
+ * stays correct on any later view. Absolute date formats bake to a fixed string.
+ */
+export declare function bakeTemplateValues<T extends TEditorConfiguration>(document: T, fields: TemplateFormField[] | null | undefined): T;
 export declare function withPersistedFormFields<T extends TEditorConfiguration>(document: T, fields: TemplateFormField[] | null | undefined): T;

package/dist/editor-sample/documents/editor/useRootFontFamily.d.ts

@@ -1 +1,11 @@
+/**
+ * Font every block inherits when it has no explicit `fontFamily` of its own:
+ * the page root's font, else the workspace brand default.
+ *
+ * Deliberately NOT in EditorContext. That module is the editor's store and is
+ * imported by nearly every editor component; pulling the redux-backed brand
+ * lookup into it formed an import cycle that left EditorContext partially
+ * initialised at eval time (which is what broke the add-block "+" button).
+ * Keeping the resolution in its own leaf module breaks the cycle.
+ */
 export declare function useRootFontFamily(): string;

package/dist/editor-sample/utils/editorStorageKey.d.ts

@@ -0,0 +1,2 @@
+export declare function editorStorageKey(effectiveType: string | undefined, recordId: string | undefined): string;
+export declare function allEditorStorageKeys(recordId: string): string[];

package/dist/editor-sample/utils/localStoragePref.d.ts

@@ -0,0 +1,2 @@
+export declare function getBooleanPref(key: string, defaultValue: boolean): boolean;
+export declare function setBooleanPref(key: string, value: boolean): void;

package/dist/email-builder-core/blocks/Container/ContainerPropsSchema.d.ts

@@ -2,7 +2,7 @@ import { z } from 'zod';
 export 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";

package/dist/email-builder-core/blocks/EmailLayout/EmailLayoutReader.d.ts

@@ -1,3 +1,3 @@
 import { default as React } from 'react';
 import { EmailLayoutProps } from './EmailLayoutPropsSchema';
-export default function EmailLayoutReader(props: EmailLayoutProps): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode>> | import("react/jsx-runtime").JSX.Element;
+export default function EmailLayoutReader(props: EmailLayoutProps): string | number | bigint | boolean | import("react/jsx-runtime").JSX.Element | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode>>;

package/dist/email-builder-core/blocks/TabsBlock/TabsBlockPropsSchema.d.ts

@@ -12,6 +12,12 @@ export declare const TabsBlockPropsSchema: z.ZodObject<{
     style: z.ZodNullable<z.ZodOptional<z.ZodObject<{
         backgroundColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
         borderColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        borderWidth: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+            top: z.ZodNumber;
+            right: z.ZodNumber;
+            bottom: z.ZodNumber;
+            left: z.ZodNumber;
+        }, z.core.$strip>>>;
         borderRadius: z.ZodNullable<z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodObject<{
             topLeft: z.ZodNumber;
             topRight: z.ZodNumber;

package/dist/email-builder-core/index.d.ts

@@ -1,5 +1,3 @@
 export { default as renderToStaticMarkup } from './renderers/renderToStaticMarkup';
 export type { TReaderBlock, TReaderDocument, TReaderBlockProps, TReaderProps, } from './Reader/core';
 export { ReaderBlockSchema, ReaderDocumentSchema, ReaderBlock, default as Reader, } from './Reader/core';
-export { buildGeneratedThemeMarkup } from './renderers/pageScripts';
-export { GENERATED_THEME_ATTR, GENERATED_THEME_AUTO } from './renderers/themeTokens';

package/dist/email-builder-core/renderers/pageScripts.d.ts

@@ -13,4 +13,3 @@ export declare const PAGINATION_SCRIPT_URL = "https://pagepilot.fabbuilder.com/s
 export declare const DEMO_SCALE_SCRIPT_URL = "https://pagepilot.fabbuilder.com/scripts/pagePilotDemoScale.js";
 export declare const TIMER_SCRIPT_URL = "https://pagepilot.fabbuilder.com/scripts/pagePilotTimer.js";
 export declare const ANIMATION_SCRIPT_URL = "https://pagepilot.fabbuilder.com/scripts/pagePilotAnimation.js";
-export declare const buildGeneratedThemeMarkup: () => string;

package/dist/email-builder-core/renderers/themeTokens.d.ts

@@ -1,143 +1,9 @@
 /**
- * Theme tokens for the generated (published) HTML.
- *
- * ## Why this exists
- *
- * A published page is a BODY FRAGMENT injected into a host application we
- * don't control (see ConfigureDialog's integration snippets — hosts do
- * `container.insertAdjacentHTML(...)`). There is no `<head>` to put a
- * stylesheet in and no guarantee any host CSS exists, so everything the page
- * needs to render dark must ship inside the fragment itself.
- *
- * ## Why not `filter: invert()`
- *
- * The previous implementation inverted the whole subtree with
- * `filter: invert(1) hue-rotate(180deg)`. That is not dark mode: it rotates
- * every author-picked hue 180deg, so a brand blue publishes as orange. It also
- * forced a fragile web of counter-inversions to keep photos from looking like
- * negatives. This module replaces it with real per-color dark values.
- *
- * ## How it works
- *
- * Each distinct authored color is issued a token. The block renders
- * `var(--ahd-c-N, <original>)` instead of the raw color, and the token is
- * defined once in a `<style>` scoped to the fragment root:
- *
- *   [data-ahd-theme] { --ahd-c-3: light-dark(#0a5fcc, #5aa2ff); }
- *
- * `light-dark()` resolves against the nearest `color-scheme`, which the
- * fragment root sets from the author's Light/Dark/Auto choice. That means a
- * host can flip an embedded page by changing one attribute — no re-fetch, no
- * media-query re-evaluation.
- *
- * Two independent fallbacks keep an unsupported browser rendering exactly what
- * it renders today:
- *   1. The `var()` fallback carries the original color, so a browser that
- *      drops the custom property still paints the light value.
- *   2. `emitTokenCss` writes a plain light-value declaration before the
- *      `light-dark()` one, so a browser that understands custom properties but
- *      not `light-dark()` uses the light value rather than an invalid
- *      declaration.
- */
-export type GeneratedTheme = 'light' | 'dark' | 'auto';
-export declare const GENERATED_THEME_ATTR = "data-ahd-theme";
-/**
- * Published pages always follow the visitor's device setting.
- *
- * This is the only mode the renderer emits: there is no author-facing
- * light/dark switch, because a published page has no opinion about the
- * visitor's environment - the visitor's browser does. `light` and `dark`
- * remain in the type because a HOST APP can override a rendered fragment at
- * runtime by setting this attribute (see the snippet in ConfigureDialog).
- */
-export declare const GENERATED_THEME_AUTO: GeneratedTheme;
-/**
- * Derive a dark-mode counterpart for an authored light color.
- *
- * The rule is: PRESERVE HUE AND SATURATION, INVERT LIGHTNESS ONLY. That is the
- * entire difference from the `hue-rotate` approach this replaces — a brand blue
- * stays blue and simply becomes lighter so it reads against a dark surface.
- *
- * Two deliberate departures from a naive `l -> 1 - l`:
- *
- * - Near-neutral colors (very low saturation) are the page's surfaces and text.
- *   A straight flip sends #ffffff to #000000, which is harsher than good dark
- *   UI: pure black raises perceived contrast and causes halation against light
- *   text. They're mapped into a softer range instead (about #121212 to #ededed),
- *   matching the app's own dark palette (`src/theme/colors/dark.ts` uses
- *   #121212 for background).
- *
- * - Saturated colors get a compressed flip. A mid-lightness brand color
- *   (l ~ 0.5) should stay close to where it is rather than swing to the
- *   opposite extreme, so the result is pulled toward a legible band and floored
- *   so it never lands too dark to see on a dark surface.
- *
- * Alpha is carried through untouched.
- *
- * Returns `null` for anything that is not a single solid color — gradients,
- * `transparent`, keywords, unparseable values. Those are left exactly as the
- * author wrote them (see `token`).
- */
-export declare function deriveDarkColor(value: string): string | null;
-export type TokenRegistry = {
-    /**
-     * Issue (or reuse) a token for `raw` and return the value a block should
-     * render.
-     *
-     * Returns `raw` unchanged when there is nothing to theme — null/undefined,
-     * `transparent`, `currentColor`, a gradient, or anything unparseable. Callers
-     * can therefore pipe every color through this without pre-checking, EXCEPT
-     * that a caller which BRANCHES on whether a value is a gradient must do that
-     * classification on the raw value first (see `isGradientColor` in
-     * blocks/helpers/blockStyleHelpers).
-     *
-     * GRADIENTS ARE NEVER THEMED. An author-picked gradient renders identically
-     * in light and dark mode — it is returned byte-for-byte unchanged, so the
-     * published CSS carries the author's exact value in both themes.
-     */
-    token(raw: string | null | undefined): string | undefined;
-    /** CSS defining every token issued so far. Empty when none, or theme light. */
-    css(theme: GeneratedTheme): string;
-    /** Number of distinct colors tokenized (for tests/diagnostics). */
-    size(): number;
-};
-export declare function createTokenRegistry(): TokenRegistry;
-/**
- * CSS for a fragment that issued no tokens (or chose light).
- *
- * Still worth emitting for `dark`/`auto`: `color-scheme` alone makes form
- * controls, scrollbars and the canvas behind the fragment follow the theme.
- */
-export declare function baseThemeCss(theme: GeneratedTheme): string;
-export declare const ThemeTokenProvider: import('react').Provider<TokenRegistry>;
-/**
- * Theme a single color value.
- *
- * Safe to call unconditionally: outside a publish render it returns `raw`
- * unchanged. See `TokenRegistry.token` for what is and isn't themed — notably,
- * gradients pass through byte-for-byte.
- *
- * A caller that BRANCHES on whether a color is a gradient must classify the
- * RAW value first (via `isGradientColor`) and only then tokenize, or the
- * branch will misfire on the returned `var(...)` string.
+ * Author colors are rendered exactly as picked: there is no light/dark theming
+ * of published output. These helpers are identity pass-throughs, kept so block
+ * components can keep calling them without per-block churn.
  */
 export declare function useColorToken(raw: string | null | undefined): string | undefined;
-/**
- * A themer for colors that live in a LIST.
- *
- * `useColorToken` is a hook, so it cannot be called from inside `.map()` or any
- * other loop — blocks whose colors come from per-row data (breadcrumb items,
- * menu entries, pagination buttons) have no fixed number of colors to theme and
- * would break the rules of hooks. This returns a plain function instead: call
- * the hook once at the top of the component, then apply the result per item.
- *
- * Outside a publish render it is the identity function, exactly like
- * `useColorToken`.
- */
+/** Plain-function form for colors that live in a list (no hook rules). */
 export declare function useColorTokenizer(): (raw: string | null | undefined) => string | undefined;
-export declare function themeAuthorHtml(html: string, registry: TokenRegistry | null): string;
-/**
- * Hook form of `themeAuthorHtml`, for blocks that render author HTML.
- * Outside a publish render this returns the input unchanged.
- */
 export declare function useThemedHtml(html: string): string;

package/dist/host-stubs/history.d.ts

@@ -0,0 +1,5 @@
+declare const History: {
+    navigate: (_path: string, ..._rest: unknown[]) => void;
+    push: (path: string, ...rest: unknown[]) => void;
+};
+export default History;

package/dist/host-stubs/hooks/useTenantFeatureCutoff.d.ts

@@ -0,0 +1,8 @@
+export declare const LEGACY_FEATURE_CUTOFFS: {
+    readonly legacyTextBlocks: Date;
+};
+export type LegacyFeatureKey = keyof typeof LEGACY_FEATURE_CUTOFFS;
+/** True when the feature is hidden for this tenant (created on/after the cutoff). */
+export declare const isLegacyFeatureHidden: (tenant: any, feature: LegacyFeatureKey) => boolean;
+export declare const useIsLegacyFeatureHidden: (feature: LegacyFeatureKey) => boolean;
+export default useIsLegacyFeatureHidden;

package/dist/host-stubs/hooks/useTenantPlan.d.ts

@@ -0,0 +1,18 @@
+import { isProOrAboveTenant } from '../../api/useTenantPlan';
+export { isProOrAboveTenant };
+export declare const useCurrentTenantPlan: () => {
+    currentTenant: {
+        [key: string]: any;
+        id?: string;
+        plan?: string;
+    };
+    isPlanProOrAbove: boolean;
+};
+export declare const isTemplateLockedForPlan: (supportedPlans: string[] | undefined | null, tenantPlan: string | undefined | null) => boolean;
+export declare const useTemplatePlanLock: () => {
+    tenantPlan: string;
+    isTemplateLocked: (template: {
+        supportedPlans?: string[];
+    } | null | undefined) => boolean;
+};
+export default useCurrentTenantPlan;

package/dist/host-stubs/i18nAhdDefaults.d.ts

@@ -0,0 +1 @@
+export declare const AHD_EN_DEFAULTS: Record<string, string>;

package/dist/host-stubs/modules/auth/authCurrentTenant.d.ts

@@ -0,0 +1,6 @@
+declare const AuthCurrentTenant: {
+    get(): string | null;
+    set(_tenant: unknown): void;
+    clear(): void;
+};
+export default AuthCurrentTenant;

package/dist/host-stubs/modules/forms/formsService.d.ts

@@ -4,7 +4,9 @@ declare const FormsService: {
         count: number;
     }>;
     find: () => Promise<any>;
-    getViewUrl: (_id: string, _tenantId?: string) => string;
     getCreateUrl: () => string;
+    getEditUrl: (id: string, tenantId?: string) => string;
+    getViewUrl: (id: string, tenantId?: string) => string;
+    getStatsUrl: (id: string, tenantId?: string) => string;
 };
 export default FormsService;

package/dist/host-stubs/modules/forms/useFormsList.d.ts

@@ -3,10 +3,13 @@ export type FormRow = {
     name?: string;
     tenantId?: string;
 };
-export default function useFormsList(): {
+export default function useFormsList(_options?: {
+    enabled?: boolean;
+}): {
     forms: FormRow[];
     options: {
         label: string;
         value: string;
     }[];
+    isLoading: boolean;
 };

package/dist/host-stubs/modules/menu/menuService.d.ts

@@ -0,0 +1,4 @@
+export default class MenuService {
+    static update(id: string, data: Record<string, unknown>): Promise<any>;
+    static list(filter?: Record<string, unknown>, orderBy?: string | null, limit?: number, offset?: number): Promise<import('../../..').PageListResponse>;
+}

package/dist/host-stubs/modules/page/pageService.d.ts

@@ -0,0 +1,11 @@
+export default class PageService {
+    static find(id: string): Promise<any>;
+    static upsert(data: Record<string, unknown>): Promise<any>;
+    static update(id: string, data: Record<string, unknown>): Promise<any>;
+    static create(data: Record<string, unknown>): Promise<any>;
+    /** Page listing isn't exposed by the pagepilot API client. */
+    static list(_filter?: Record<string, unknown>, _orderBy?: string | null, _limit?: number, _offset?: number): Promise<{
+        rows: any[];
+        count: number;
+    }>;
+}

package/dist/host-stubs/modules/settings/settingsActions.d.ts

@@ -0,0 +1,2 @@
+declare const settingsActions: any;
+export default settingsActions;

package/dist/host-stubs/modules/settings/settingsSelectors.d.ts

@@ -1,5 +1,9 @@
 declare const settingsSelectors: {
+    selectRaw: (_state: unknown) => any;
     selectSettings: (_state: unknown) => any;
     selectBranding: (_state: unknown) => any;
+    selectInitLoading: (_state: unknown) => boolean;
+    selectSaveLoading: (_state: unknown) => boolean;
+    selectBrandingLoaded: (_state: unknown) => boolean;
 };
 export default settingsSelectors;

package/dist/host-stubs/modules/shared/axios/authAxios.d.ts

@@ -0,0 +1,16 @@
+type AxiosLikeConfig = {
+    headers?: Record<string, string>;
+    params?: Record<string, unknown>;
+};
+type AxiosLikeResponse<T = any> = {
+    data: T;
+    status: number;
+};
+declare const authAxios: {
+    get: <T = any>(url: string, config?: AxiosLikeConfig) => Promise<AxiosLikeResponse<T>>;
+    delete: <T = any>(url: string, config?: AxiosLikeConfig) => Promise<AxiosLikeResponse<T>>;
+    post: <T = any>(url: string, body?: unknown, config?: AxiosLikeConfig) => Promise<AxiosLikeResponse<T>>;
+    put: <T = any>(url: string, body?: unknown, config?: AxiosLikeConfig) => Promise<AxiosLikeResponse<T>>;
+    patch: <T = any>(url: string, body?: unknown, config?: AxiosLikeConfig) => Promise<AxiosLikeResponse<T>>;
+};
+export default authAxios;

package/dist/host-stubs/modules/shared/constants.d.ts

@@ -0,0 +1,14 @@
+export declare const CR_TENANT_ID: string | undefined;
+export declare const STUDIO_TENANT_ID: string | undefined;
+export declare const MIN_CHAR_LIMIT = 50;
+export declare const MAX_CHAR_LIMIT = 200;
+export declare const DEFAULT_CALENDLY_URL = "https://calendly.com/ishaan-fabbuilder/30min";
+export declare const DOCS_BASE_URL = "https://fab-builder.github.io/pagepilot-vanilla-react-app";
+export declare const DOCS_LINK_PAGE_TO_MENU = "https://fab-builder.github.io/pagepilot-vanilla-react-app/pages/link-page-to-menu";
+export declare const DOCS_TEMPLATE_VARIABLES = "https://fab-builder.github.io/pagepilot-vanilla-react-app/pages/template-variables";
+export declare const DOCS_WEBINAR_REGISTRATION = "https://fab-builder.github.io/pagepilot-vanilla-react-app/webinar#registration";
+export declare const DOCS_WEBINAR_PAID = "https://fab-builder.github.io/pagepilot-vanilla-react-app/webinar#paid-webinar";
+export declare const DOCS_PREVIEW_MODE = "https://fab-builder.github.io/pagepilot-vanilla-react-app/pages/fetch-pages#preview-mode";
+export declare const PRODUCT_DOCS_BASE_URL = "https://pagepilot-docs.fabbuilder.com";
+export declare const FORM_BUILDER_API_BASE = "https://cs.fabbuilder.com/cs-app/form-builder/api";
+export declare const FORM_BUILDER_FE_BASE = "https://cs-app-form-builder-fe.web.app";

package/dist/host-stubs/modules/store.d.ts

@@ -1,3 +1,7 @@
 export type AppDispatch = (action: unknown) => void;
 declare const getStore: () => any;
+/** Host router history — none in the standalone build (navigation is a no-op). */
+export declare const getHistory: () => {
+    push: (path: string) => void;
+} | null;
 export default getStore;

package/dist/host-stubs/modules/template/templateEnumerators.d.ts

@@ -0,0 +1,19 @@
+export declare enum TemplateVisibility {
+    Global = "global",
+    Private = "private"
+}
+declare const templateEnumerators: {
+    type: string[];
+    visibility: string[];
+    tags: string[];
+    pageCategory: string[];
+    tagsByType: {
+        page: string[];
+        tour: string[];
+        banner: string[];
+        tooltip: string[];
+        appbanner: string[];
+        'app-banner': string[];
+    };
+};
+export default templateEnumerators;

package/dist/host-stubs/modules/tour/injectTourIntoPage.d.ts

@@ -0,0 +1,20 @@
+export declare const stripAhdIntegration: (html: string) => string;
+/** Returns the exact AHD integration block from a chunk of HTML, or '' if absent. */
+export declare const extractAhdIntegrationBlock: (html: string) => string;
+export declare const buildAhdIntegrationSnippet: (tenantId: string, slug: string) => string;
+export declare const injectAhdIntegration: (html: string, slug: string, tenantId?: string) => string;
+type LinkedPageSources = {
+    tourData?: any;
+    record?: any;
+    searchParams?: URLSearchParams | null;
+};
+/**
+ * Resolves the linked page's slug and id from tour data, record, and URL search params
+ * (in that order). When `mode === 'remove'`, strips the AHD integration block from the
+ * linked page's first section. Otherwise (re)injects it.
+ */
+export declare function injectPageGuideIntoLinkedPage(tourId: string | undefined, sources: LinkedPageSources, mode?: 'inject' | 'remove'): Promise<void>;
+/** Strips the AHD integration block from every section of the linked page. */
+export declare const removeTourFromPage: (pageSlug: string, pageId?: string) => Promise<void>;
+export declare const injectTourIntoPage: (pageSlug: string, _tourId?: string, pageId?: string) => Promise<void>;
+export {};