@levo-so/site-runtime 0.1.113 → 0.2.1

package/index.d.ts

@@ -0,0 +1,674 @@
+import { ILemaCollection } from '@levo-so/core';
+import { ILevoClient } from '@levo-so/core';
+import { ILevoInsights } from '@levo-so/insights';
+import { JSX } from 'react/jsx-runtime';
+import { LevoQuery } from '@levo-so/core';
+
+/**
+ * Build the site's `levoHead` from its `site.json`. Each route passes its OWN imported
+ * meta file (`head: levoHead(meta)`) — no path matching anywhere; the import IS the
+ * pairing. The argument default lets a meta-less route render pure site defaults.
+ *
+ * Dynamic (`$slug`) routes pass a second argument naming the record fields that feed the
+ * head (`head: levoHead(meta, { source: "post", title: "title", … })`), so every slug
+ * gets its own title/description/share image instead of the route's shared static meta.
+ * Pages that set no `canonical` get a self-referencing one derived from the site domain
+ * + request path (og:url follows it in pageHead) — per-slug correct on dynamic routes.
+ */
+export declare const createLevoHead: (site: ISiteJson) => (meta?: IPlatformMetaFile, dynamic?: ILevoDynamicHead) => (ctx?: IHeadCtx) => IComposedHead;
+
+/**
+ * Build the one-line route loader (`loader: levoLoader(dataSources)`): prefetch the
+ * page's declared data sources on the server so SSR ships fully-rendered HTML, and
+ * return them keyed by source key — that map is the route's `loaderData`, which
+ * `levoHead`'s dynamic config reads for per-record heads. An empty `dataSources` ({})
+ * resolves to an empty map. Context is typed structurally (just `queryClient`) so the
+ * scaffold's router types never enter the package.
+ */
+export declare const createLevoLoader: (config: ILevoSiteConfig) => (sources: ILevoDataSources) => ({ context, params, }: {
+    context: {
+        queryClient: IQueryClientLike;
+    };
+    params?: Record<string, string>;
+}) => Promise<Record<string, unknown>>;
+
+/**
+ * Build the site's core Levo client from config, or `null` when the site isn't wired to a
+ * backend yet (no `apiUrl`). SSR-safe — `createLevoClient` guards its window/document reads.
+ *
+ * Explicit return type on purpose: inference would inline core-internal names its rolled-up
+ * d.ts doesn't export → TS4023 on declaration emit.
+ */
+export declare const createSiteClient: (config?: ILevoSiteConfig) => ILevoClient | null;
+
+export declare interface IComposedHead {
+    meta: IHeadEntry[];
+    links: IHeadEntry[];
+    scripts: IHeadEntry[];
+}
+
+/** Editor → preview (received by `onMessage`; dashboard's `IOutboundMessage`). */
+export declare type IEditorToPreview = {
+    type: "set-inspect";
+    enabled: boolean;
+} | {
+    type: "set-text-edit";
+    enabled: boolean;
+} | {
+    type: "clear-selection";
+} | {
+    type: "select-element";
+    element: IElementLocator;
+} | {
+    type: "edit-element";
+    element: IElementLocator;
+} | {
+    type: "highlight-element";
+    element: IElementLocator;
+} | {
+    type: "clear-highlight";
+} | {
+    type: "request-layers";
+} | {
+    type: "request-sources";
+} | {
+    type: "revert-text";
+    element: IElementLocator;
+} | {
+    type: "navigate";
+    route: string;
+} | {
+    type: "stage-style";
+    stageId: string;
+    element: IElementLocator;
+    styles: Record<string, string>;
+    media?: string;
+} | {
+    type: "stage-text";
+    stageId: string;
+    element: IElementLocator;
+    value: string;
+} | {
+    type: "clear-staged";
+    stageId?: string;
+};
+
+/** A nested element locator — `file:line:col` + occurrence index. Never top-level. */
+export declare interface IElementLocator {
+    source: string;
+    index?: number;
+}
+
+/**
+ * The slice of the router's head-fn context we read. Structural on purpose (like
+ * IQueryClientLike) so the package never depends on the router's types: `loaderData` is
+ * the loader's return value — `prefetchLevoSources`' source-keyed map — and
+ * `match.pathname` is the request path. Both read defensively; absent = skipped.
+ */
+declare interface IHeadCtx {
+    loaderData?: unknown;
+    match?: {
+        pathname?: string;
+    };
+}
+
+declare interface IHeadEntry {
+    [attr: string]: string | undefined;
+}
+
+export declare type IHistoryFn = History["pushState"];
+
+export declare interface ILayersNode {
+    tag: string;
+    source?: string;
+    index?: number;
+    text?: string;
+    /** The element carries the `hidden` utility (display:none) — a reachability hint the
+     * Layers panel surfaces. Live + class-based, so it covers component internals too
+     * (the dashboard no longer parses JSX for this). Present only when true. */
+    hidden?: boolean;
+    childCount: number;
+    children: ILayersNode[];
+}
+
+/** The shape a page exports so its route loader can prefetch every binding it renders. */
+export declare type ILevoDataSources = Record<string, ILevoSourceDef>;
+
+/**
+ * Per-record head config for a dynamic (`$slug`) route — `levoHead`'s optional second
+ * argument. A static literal (AI/editor-written, next to the route's meta import); each
+ * field names a FIELD on the loaded record (the `dataSources` entry named by `source`).
+ * At request time the record's values override the static meta file per-field, so every
+ * slug ships its own title, description, and share image.
+ */
+export declare interface ILevoDynamicHead {
+    /** Key in the page's `dataSources` whose loaded record feeds the head. */
+    source: string;
+    /** Record field holding the page title (the site name is appended automatically). */
+    title?: string;
+    /** Record field holding the description. */
+    description?: string;
+    /** Record field holding the share image (platform image object or URL). */
+    image?: string;
+}
+
+/**
+ * A form binding — the fields + submit for a collection. `LevoForm` renders it (the schema
+ * drives which inputs appear); submissions go to the collection. Forms only bind to
+ * collections, so there's no `module` variance — but it's kept for symmetry with the other
+ * configs and so the editor binding reads uniformly.
+ */
+export declare interface ILevoFormConfig {
+    module: "collection";
+    /** Collection key. */
+    identifier: string;
+}
+
+export declare interface ILevoFormProps {
+    /** The form binding. Declare it in the page's `dataSources` (`mode: "form"`) so the route loader prefetches the schema SSR, then pass that entry here. */
+    source: ILevoFormConfig;
+    /** Submit-button label. */
+    submitLabel?: string;
+    /** Field keys to hide from the rendered form (matched against field key/id, recursively into nested fields). */
+    hiddenFields?: string[];
+    /** Layout: all fields at once, one-at-a-time (Typeform), or stepped by section. */
+    formVariant?: "default" | "single-field" | "steps" | "steps-2";
+    /** Success-screen copy + the post-submit action (show a message, let them submit another, or redirect). */
+    successConfig?: {
+        title?: string;
+        message?: string;
+        action?: {
+            type: "none" | "submit_another" | "redirect";
+            value?: string;
+        };
+    };
+    /** Brand the form. Optional — defaults to the site theme; only override the few colors you want to diverge. */
+    theme?: ILevoFormTheme;
+    className?: string;
+}
+
+export declare interface ILevoFormResult {
+    /** The collection schema (`sections[].fields[]`) the form renders. null until loaded / unwired. */
+    schema: ILemaCollection | null;
+    isLoading: boolean;
+    error: string | null;
+    /** Spread onto the form container — stamps the editor binding. */
+    bind: {
+        "data-levo-source": string;
+    };
+}
+
+/**
+ * Per-form color/radius overrides. Every value is any CSS color/length — pass a site token
+ * (`"var(--color-brand)"`) or a literal (`"#0ea5e9"`). Omitted keys fall through to the site
+ * theme (see `DEFAULT_FORM_TOKENS`), so a form auto-matches the brand without any theme prop.
+ */
+declare interface ILevoFormTheme {
+    colors?: Partial<{
+        /** Buttons, focus accents. */
+        primary: string;
+        /** Text/icon on `primary`. */
+        primaryForeground: string;
+        /** Body text. */
+        foreground: string;
+        /** Field + card backgrounds. */
+        input: string;
+        /** Field borders + dividers. */
+        border: string;
+        /** Focus ring. */
+        ring: string;
+        /** Error text + invalid fields. */
+        destructive: string;
+    }>;
+    /** Corner radius for inputs/buttons (default: the site's `--radius-token`). */
+    radius?: string;
+    /** Vertical space between fields (default: `1.5rem`). Tighten with `"1rem"`, open up with `"2rem"`. */
+    gap?: string;
+}
+
+/** A single-record binding — one collection record / blog post / event by `slug` (a detail page). */
+export declare interface ILevoRecordConfig {
+    module: "collection" | "blog" | "event";
+    /** Collection key / blog key / event series id. Round-tripped; the event single endpoint is flat (slug only). */
+    identifier: string;
+    /**
+     * Reserved for field projection. The slug endpoints return the whole record today, so
+     * this is round-tripped through the binding but not yet sent to the API.
+     */
+    query?: Pick<LevoQuery.FindQuery, "select" | "include">;
+}
+
+export declare interface ILevoRecordResult<T = Record<string, unknown>> {
+    data: T | null;
+    isLoading: boolean;
+    error: string | null;
+    bind: {
+        "data-levo-source": string;
+    };
+}
+
+/** Site-level Levo config — the scaffold shim fills this from Vite env. */
+export declare interface ILevoSiteConfig {
+    /** Origin of the Levo public API / proxy the site's data calls go through. */
+    apiUrl?: string;
+    /** The site's workspace id (`W…`). Invalid/absent → client runs workspace-less. */
+    workspace?: string;
+    /** The site's id, stamped onto analytics events. */
+    siteId?: string;
+    /**
+     * Analytics reverse-proxy URL. Absent/null → identity + DOM trackers still run
+     * (popup triggers work) but nothing is sent — queued events are dropped.
+     */
+    insightsUrl?: string | null;
+    /** Forwarded to the client's APP_MODE; defaults to "production". */
+    appMode?: string;
+}
+
+/** A list binding — collection records, blog posts, or events matching `query`. */
+export declare interface ILevoSourceConfig {
+    /** "collection" | "blog" | "event". Community has no core client module yet. */
+    module: "collection" | "blog" | "event";
+    /** Collection key / blog key / event series id. */
+    identifier: string;
+    /** where / sort / limit / page / search. `limit: -1` = all. */
+    query?: LevoQuery.FindQuery;
+    /** Reserved (blog sub-module identifiers etc.); round-tripped through the binding. */
+    options?: Record<string, unknown>;
+}
+
+/**
+ * One entry in a page's `dataSources` export — a list, record, or form binding, discriminated
+ * by `mode`. The route loader reads these to prefetch; the page passes each to its hook. `mode`
+ * is optional for lists (the default); required for records (so the loader uses the route slug)
+ * and forms (so the loader prefetches the collection schema instead of content).
+ */
+export declare type ILevoSourceDef = (ILevoSourceConfig & {
+    mode?: "list";
+}) | (ILevoRecordConfig & {
+    mode: "record";
+}) | (ILevoFormConfig & {
+    mode: "form";
+});
+
+export declare interface ILevoSourceResult<T = Record<string, unknown>> {
+    /** null until loaded, on error, and on an unwired site. */
+    data: T[] | null;
+    meta: {
+        total: number;
+        pages: number;
+    } | null;
+    isLoading: boolean;
+    error: string | null;
+    /** Spread onto the container that renders the list — stamps the editor binding. */
+    bind: {
+        "data-levo-source": string;
+    };
+}
+
+export declare function Inspector(): null;
+
+/** One page's head metadata. Every field optional — site defaults fill gaps per-field. */
+export declare interface IPageMeta {
+    title?: string;
+    description?: string;
+    /** Absolute URL. Rendered as `<link rel="canonical">`. */
+    canonical?: string;
+    /** e.g. "index,follow" / "noindex,nofollow". */
+    robots?: string;
+    og?: {
+        title?: string;
+        description?: string;
+        image?: string;
+        /** Absolute share URL. Falls back to `canonical` when unset. */
+        url?: string;
+        /** Defaults to "website" when any og field is present. */
+        type?: string;
+    };
+    twitter?: {
+        /** Defaults to "summary_large_image" when any twitter field is present. */
+        card?: string;
+        title?: string;
+        description?: string;
+        image?: string;
+    };
+    /** JSON-LD object(s) — each becomes a `<script type="application/ld+json">`. */
+    ldJson?: Record<string, unknown> | Array<Record<string, unknown>>;
+    /**
+     * Raw head snippet for THIS page. v1 supports `<script>`, `<meta>` and `<link>` tags
+     * only (the analytics / verification / preload cases) — anything else is dropped by
+     * `parseRawHead`, since arbitrary markup can't be expressed as document metadata.
+     */
+    customHead?: string;
+}
+
+/**
+ * One platform-data binding found on the page — a `data-levo-source` container. Emitted in
+ * `sources-list` (reply to `request-sources`) so the editor's page-level Data manager can list
+ * every binding without a selection. `element` is the container's own `data-tsd-source` locator
+ * (a data edit targets the hook call site); `config` is the parsed binding, omitted when the
+ * attribute is malformed JSON.
+ */
+export declare interface IPageSource {
+    raw: string;
+    config?: unknown;
+    element: IElementLocator;
+    tag: string;
+    label: string;
+}
+
+export declare interface IPatchedHistoryFn {
+    (this: History, ...args: Parameters<IHistoryFn>): ReturnType<IHistoryFn>;
+    __inspectorPatched?: boolean;
+    __orig?: IHistoryFn;
+}
+
+/** The full `meta/<route>.json` shape: page identity (platform-owned) + the SEO object. */
+export declare interface IPlatformMetaFile {
+    title?: string;
+    description?: string;
+    meta?: IPlatformPageMeta;
+}
+
+/** The platform's per-page SEO object — the `meta` key of `meta/<route>.json`. */
+export declare interface IPlatformPageMeta {
+    meta_title?: string;
+    meta_description?: string;
+    keywords?: string;
+    og_title?: string;
+    og_description?: string;
+    /** Plain URL string, or the platform media object (older rows) — `.location` is read. */
+    og_image?: string | {
+        location?: string;
+    } | null;
+    og_url?: string;
+    canonical?: string;
+    twitter_card?: string;
+    /** JSON-LD structured data — rendered as an `application/ld+json` script tag. */
+    ld_json?: Record<string, unknown> | Array<Record<string, unknown>>;
+    /** Page-scoped raw head snippet — script/meta/link tags only. */
+    head_code?: string;
+    disable_indexing?: boolean;
+    robots?: string;
+}
+
+/** Preview → editor (emitted by `send`; dashboard's `IInboundMessage`). */
+export declare type IPreviewToEditor = {
+    type: "ready";
+} | {
+    type: "inspect-state";
+    enabled: boolean;
+} | {
+    type: "text-edit-state";
+    enabled: boolean;
+} | {
+    type: "element-selected";
+    element: ISelectedElement;
+} | {
+    type: "element-text-changed";
+    element: ITextChangedElement;
+}
+/**
+* `route` is the pathname (always present). `file` is the route's repo-relative source
+* file (e.g. `src/routes/pricing.tsx`, no leading slash, no `:line:col`) — reserved:
+* the runtime doesn't emit it yet; the dashboard falls back to url → file mapping.
+*/
+| {
+    type: "route";
+    route: string;
+    file?: string;
+} | {
+    type: "staged-ack";
+    stageId: string;
+} | {
+    type: "layers-tree";
+    tree: ILayersNode;
+    truncated: boolean;
+} | {
+    type: "sources-list";
+    sources: IPageSource[];
+} | {
+    type: "select-miss";
+    element: IElementLocator;
+} | {
+    type: "highlight-miss";
+    element: IElementLocator;
+};
+
+/**
+ * The minimal QueryClient surface `prefetchLevoSources` needs. Structural on purpose — a
+ * branded `QueryClient` type in the public API would clash whenever the consuming site
+ * resolves a different `@tanstack/react-query` copy/version than the one this package was
+ * built against (peer dep). Any real QueryClient satisfies this.
+ */
+export declare interface IQueryClientLike {
+    ensureQueryData: (options: {
+        queryKey: readonly unknown[];
+        queryFn: () => Promise<unknown>;
+    }) => Promise<unknown>;
+}
+
+/** The element-selected payload — see `selectedPayload`. */
+export declare interface ISelectedElement {
+    tag: string;
+    classes: string;
+    text: string;
+    label: string;
+    path: string;
+    /** null when the element carries no `data-tsd-source` stamp. */
+    source: string | null;
+    index: number;
+    occurrences: number;
+    ancestors: {
+        tag: string;
+        text: string;
+        source?: string;
+    }[];
+    /** Whole normalized textContent — present ONLY for text-mode-editable nodes. */
+    fullText?: string;
+    /**
+     * The nearest `data-levo-source` binding container above the selection (inclusive) — a
+     * platform-data-bound region (`useLevoSource`/`useLevoRecord`). Present only when the
+     * selection sits inside one. `config` is the parsed binding ({mode, module, identifier,
+     * query,…}), omitted when the attribute is malformed JSON. `element` is the binding
+     * CONTAINER's own locator, so a data edit targets the hook call site — not the clicked
+     * child. Lets the editor's "Integrate" dialog open pre-filled without parsing JSX.
+     */
+    sourceBinding?: {
+        raw: string;
+        config?: unknown;
+        element: IElementLocator;
+    };
+}
+
+/** The slice of the project's root `site.json` the runtime reads. */
+export declare interface ISiteJson {
+    id?: string;
+    workspace_id?: string;
+    name?: string;
+    description?: string;
+    /** The site's live URL host (with or without protocol) — feeds auto-canonicals. */
+    domain?: string;
+    settings?: {
+        head_code?: string;
+    };
+    levo?: {
+        api_url?: string;
+        insights_url?: string | null;
+        app_mode?: string;
+    };
+}
+
+/** Site-wide defaults + site-wide raw head, from `src/pages/_site.meta.ts`. */
+export declare interface ISiteMeta extends IPageMeta {
+    /** "%s · Acme" — %s is the page title. Applied only when the page provides a title. */
+    titleTemplate?: string;
+}
+
+export declare type IStagedEntry = IStagedStyleEntry | IStagedTextEntry;
+
+export declare interface IStagedStyleEntry {
+    kind: "style";
+    source: string;
+    index: number;
+    styles: Record<string, string>;
+    media?: string;
+}
+
+export declare interface IStagedTextEntry {
+    kind: "text";
+    source: string;
+    index: number;
+    value: string;
+}
+
+/** The element-text-changed payload — see `commit`. */
+export declare interface ITextChangedElement {
+    source: string | null;
+    index: number;
+    tag: string;
+    value: string;
+    previous?: string;
+    occurrences: number;
+}
+
+/**
+ * Self-contained event registration widget for generated Studio v3 sites — ticket
+ * selection, coupons, attendee details, payment (Razorpay by default; Stripe Embedded
+ * Checkout when the booking API returns `provider: "stripe"`), and a booking confirmation.
+ *
+ * The AI drops this onto an event page and NEVER rebuilds the flow: it owns the entire
+ * booking + payment path against the Levo event API. The site client (`useLevoSite`)
+ * auto-stamps the workspace on every request, so no auth/workspace wiring is needed.
+ * `external` turns it into a plain link out to a third-party ticketing URL.
+ */
+export declare const LevoEventRegister: ({ eventID, title, external, buttonText, }: {
+    /** Event id (or slug the single-event endpoint resolves). */
+    eventID: string;
+    /** Event name, shown in the modal header. */
+    title?: string;
+    /** External ticketing URL — when set, renders a link out instead of the modal flow. */
+    external?: string;
+    buttonText?: string;
+}) => JSX.Element;
+
+/**
+ * A collection-backed form for generated Studio v3 sites — renders the collection's fields
+ * (from its SSR-prefetched schema) and submits entries into that collection. The AI drops it
+ * in and never rebuilds the form engine.
+ *
+ * Colors follow the site theme (`src/styles/theme.css`) by default, so a form matches the
+ * brand out of the box; `theme` overrides per form. `CollectionFormRenderer` resolves its
+ * client via `@levo-so/react`'s `useLevo()` — the same context `LevoSiteProvider` mounts at
+ * the site root, so no per-form provider is needed. Declare the form in the page's
+ * `dataSources` as `mode: "form"` so the loader prefetches the schema (no field-flash, SSR-safe).
+ */
+export declare const LevoForm: React.FC<ILevoFormProps>;
+
+/**
+ * Mounts the Levo client + insights for a generated site. Rendered once from the
+ * scaffold's `__root` (via the env-reading shim); SSR-safe — construction guards its
+ * window/document reads, and `insights.init()` (client-side only by contract) runs in
+ * an effect after mount.
+ */
+export declare const LevoSiteProvider: React.FC<{
+    config?: ILevoSiteConfig;
+    children: React.ReactNode;
+}>;
+
+/**
+ * Renders a page's metadata as document tags. Pages include it anywhere in their JSX —
+ * React 19 hoists <title>/<meta>/<link> into <head> (SSR too); scripts render in place
+ * (see the file header caveat). The studio wires this automatically on a page's first
+ * meta save:
+ *
+ *   import meta from "./about.meta";
+ *   import siteMeta from "./_site.meta";
+ *   import { PageHead } from "../lib/pageHead";
+ *   …
+ *   <PageHead meta={meta} site={siteMeta} />
+ */
+export declare function PageHead({ meta, site }: {
+    meta?: IPageMeta;
+    site?: ISiteMeta;
+}): JSX.Element;
+
+/**
+ * Compose one page's document metadata from its sidecar + the site defaults. Page
+ * values win per-FIELD (an empty page og.title still inherits the site og.title).
+ * The object shape doubles as a TanStack Start route `head()` result for when the
+ * scaffold wires routes directly.
+ */
+export declare const pageHead: (meta?: IPageMeta, site?: ISiteMeta) => IComposedHead;
+
+/**
+ * Tolerant extraction of `<script>` / `<meta>` / `<link>` tags from a raw head snippet.
+ * Unsupported tags are DROPPED (documented v1 limitation) — silently at runtime; the
+ * editor warns at save time.
+ */
+export declare const parseRawHead: (raw: string) => IComposedHead;
+
+/**
+ * Prefetch every binding a page declares into the router's QueryClient — call it (awaited)
+ * from the route `loader` so SSR renders fully-populated HTML. Builds its own client from
+ * the site config (loaders run outside React, so `useLevoSite` isn't available). Record
+ * bindings pull their slug from the route `params` (`$slug`). Resilient: a single failed
+ * source resolves to null so it doesn't blank the whole page — the hook surfaces that
+ * binding's error while the rest render.
+ *
+ * Returns the fetched values keyed by source key (records as the record object, lists as
+ * `{data, meta}`). The route loader returns this map, making it the route's `loaderData` —
+ * which `levoHead`'s dynamic config reads for per-record titles/descriptions/share images.
+ */
+export declare const prefetchLevoSources: ({ queryClient, config, sources, params, }: {
+    queryClient: IQueryClientLike;
+    /** Site env config — same object the LevoSiteProvider receives. */
+    config: ILevoSiteConfig | undefined;
+    /** The page's `dataSources` export (undefined = page has none). */
+    sources: ILevoDataSources | undefined;
+    /** Route params; record bindings read `params.slug`. */
+    params?: Record<string, string>;
+}) => Promise<Record<string, unknown>>;
+
+/**
+ * The site's Levo client config from its `site.json`. The platform stamps that file at
+ * provision and re-syncs it on settings saves; the `?.` on `levo` is load-bearing — a
+ * site provisioned before the block shipped degrades to an inert client, never a crash.
+ */
+export declare const siteConfigFromJson: (site: ISiteJson) => ILevoSiteConfig;
+
+/**
+ * Load a collection's SCHEMA so `LevoForm` can render its fields. Like the other hooks the
+ * config is a static literal (the editor binding); it reads the warm cache the route loader
+ * filled via `prefetchLevoSources`, so a form declared in `dataSources` renders SSR with no
+ * fetch flash. `schema` is null until loaded and on an unwired site.
+ */
+export declare const useLevoForm: (config: ILevoFormConfig) => ILevoFormResult;
+
+/** The site's insights (analytics/track), or `null` on an unwired site. */
+export declare const useLevoInsights: () => ILevoInsights | null;
+
+/**
+ * Render ONE record by slug — a detail page. `slug` is a RUNTIME arg (the page's route
+ * param), kept OUT of the config literal so the binding stays static and editable. No slug
+ * (or unwired site) → inert. `data` null after load = not found: render a friendly fallback.
+ */
+export declare const useLevoRecord: <T = Record<string, unknown>>(config: ILevoRecordConfig, slug: string | undefined) => ILevoRecordResult<T>;
+
+/**
+ * The site's Levo client, or `null` when the site isn't wired to a Levo backend yet
+ * (no `apiUrl` in config — e.g. env not injected at provision). Consumers no-op on null.
+ *
+ * Explicit return type on purpose: inference would inline core-internal names
+ * (`IPageContext`) that the rolled-up d.ts doesn't export → TS4023 on declaration emit.
+ */
+export declare const useLevoSite: () => ILevoClient | null;
+
+/**
+ * Render a LIST of platform content. The config is a static literal (the editor rewrites
+ * it). Reads the router QueryClient: if the route loader prefetched this binding, the first
+ * render has data (SSR ships it); otherwise it fetches client-side. Always render a loading
+ * and an empty state — `data` is null before the first load and on unwired sites.
+ */
+export declare const useLevoSource: <T = Record<string, unknown>>(config: ILevoSourceConfig) => ILevoSourceResult<T>;
+
+export { }