@pagehub/sdk 0.1.0

package/dist/utils/atoms.d.ts

@@ -0,0 +1,1217 @@
+import { atom } from '@zedux/react';
+export { atom };
+/**
+ * Zedux doesn't have a dedicated set-only hook like Recoil's useSetRecoilState.
+ * This wrapper uses useAtomState but only returns the setter, keeping the same API.
+ */
+export declare const useSetAtomState: (atomTemplate: any) => import('@zedux/atoms').ExportsInfusedSetter<any, Record<string, any>>;
+/** Site settings injected by the host app. */
+export type SiteSettings = {
+    _id?: string;
+    draftId?: string;
+    name?: string;
+    [key: string]: any;
+};
+export declare const SettingsAtom: import('@zedux/atoms').AtomTemplate<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: SiteSettings;
+    Store: import('@zedux/core').Store<SiteSettings>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: SiteSettings;
+    Store: import('@zedux/core').Store<SiteSettings>;
+}, import('@zedux/atoms').AtomTemplateBase<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: SiteSettings;
+    Store: import('@zedux/core').Store<SiteSettings>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: SiteSettings;
+    Store: import('@zedux/core').Store<SiteSettings>;
+}, any>>>>;
+/** Auth token injected by the host app (nullable). */
+export declare const SessionTokenAtom: import('@zedux/atoms').AtomTemplate<{
+    State: import('@zedux/atoms').PromiseState<any>;
+    Params: [];
+    Exports: Record<string, never>;
+    Store: import('@zedux/core').Store<import('@zedux/atoms').PromiseState<any>>;
+    Promise: Promise<any>;
+}, import('@zedux/atoms').AtomInstance<{
+    State: import('@zedux/atoms').PromiseState<any>;
+    Params: [];
+    Exports: Record<string, never>;
+    Store: import('@zedux/core').Store<import('@zedux/atoms').PromiseState<any>>;
+    Promise: Promise<any>;
+}, import('@zedux/atoms').AtomTemplateBase<{
+    State: import('@zedux/atoms').PromiseState<any>;
+    Params: [];
+    Exports: Record<string, never>;
+    Store: import('@zedux/core').Store<import('@zedux/atoms').PromiseState<any>>;
+    Promise: Promise<any>;
+}, import('@zedux/atoms').AtomInstance<{
+    State: import('@zedux/atoms').PromiseState<any>;
+    Params: [];
+    Exports: Record<string, never>;
+    Store: import('@zedux/core').Store<import('@zedux/atoms').PromiseState<any>>;
+    Promise: Promise<any>;
+}, any>>>>;
+/** AI credit usage tracking. */
+export declare const UserUsageAtom: import('@zedux/atoms').AtomTemplate<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: {
+        creditBalance: number;
+        totalTokens: number;
+        lastUsed: any;
+    };
+    Store: import('@zedux/core').Store<{
+        creditBalance: number;
+        totalTokens: number;
+        lastUsed: any;
+    }>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: {
+        creditBalance: number;
+        totalTokens: number;
+        lastUsed: any;
+    };
+    Store: import('@zedux/core').Store<{
+        creditBalance: number;
+        totalTokens: number;
+        lastUsed: any;
+    }>;
+}, import('@zedux/atoms').AtomTemplateBase<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: {
+        creditBalance: number;
+        totalTokens: number;
+        lastUsed: any;
+    };
+    Store: import('@zedux/core').Store<{
+        creditBalance: number;
+        totalTokens: number;
+        lastUsed: any;
+    }>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: {
+        creditBalance: number;
+        totalTokens: number;
+        lastUsed: any;
+    };
+    Store: import('@zedux/core').Store<{
+        creditBalance: number;
+        totalTokens: number;
+        lastUsed: any;
+    }>;
+}, any>>>>;
+export declare const SectionPickerDialogAtom: import('@zedux/atoms').AtomTemplate<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: {
+        isOpen: boolean;
+        nodeId: any;
+        position: any;
+        parent: any;
+    };
+    Store: import('@zedux/core').Store<{
+        isOpen: boolean;
+        nodeId: any;
+        position: any;
+        parent: any;
+    }>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: {
+        isOpen: boolean;
+        nodeId: any;
+        position: any;
+        parent: any;
+    };
+    Store: import('@zedux/core').Store<{
+        isOpen: boolean;
+        nodeId: any;
+        position: any;
+        parent: any;
+    }>;
+}, import('@zedux/atoms').AtomTemplateBase<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: {
+        isOpen: boolean;
+        nodeId: any;
+        position: any;
+        parent: any;
+    };
+    Store: import('@zedux/core').Store<{
+        isOpen: boolean;
+        nodeId: any;
+        position: any;
+        parent: any;
+    }>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: {
+        isOpen: boolean;
+        nodeId: any;
+        position: any;
+        parent: any;
+    };
+    Store: import('@zedux/core').Store<{
+        isOpen: boolean;
+        nodeId: any;
+        position: any;
+        parent: any;
+    }>;
+}, any>>>>;
+export declare const BatchOperationAtom: import('@zedux/atoms').AtomTemplate<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomTemplateBase<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, any>>>>;
+export declare const ShowGridLinesAtom: import('@zedux/atoms').AtomTemplate<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomTemplateBase<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, any>>>>;
+export declare const AssistantVisibleAtom: import('@zedux/atoms').AtomTemplate<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomTemplateBase<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, any>>>>;
+export type AssistantMode = "docked" | "popout";
+export declare const AssistantModeAtom: import('@zedux/atoms').AtomTemplate<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: AssistantMode;
+    Store: import('@zedux/core').Store<AssistantMode>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: AssistantMode;
+    Store: import('@zedux/core').Store<AssistantMode>;
+}, import('@zedux/atoms').AtomTemplateBase<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: AssistantMode;
+    Store: import('@zedux/core').Store<AssistantMode>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: AssistantMode;
+    Store: import('@zedux/core').Store<AssistantMode>;
+}, any>>>>;
+/** Save / static HTML issues (e.g. invalid tree). Dismiss sets to null. */
+export declare const EditorSaveBannerAtom: import('@zedux/atoms').AtomTemplate<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: {
+        message: string;
+    };
+    Store: import('@zedux/core').Store<{
+        message: string;
+    }>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: {
+        message: string;
+    };
+    Store: import('@zedux/core').Store<{
+        message: string;
+    }>;
+}, import('@zedux/atoms').AtomTemplateBase<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: {
+        message: string;
+    };
+    Store: import('@zedux/core').Store<{
+        message: string;
+    }>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: {
+        message: string;
+    };
+    Store: import('@zedux/core').Store<{
+        message: string;
+    }>;
+}, any>>>>;
+/** AI assistant scope — resolved per request from pins / media task / chips (client sends to agent). */
+export type AssistantScope = "design" | "text" | "media";
+export type AssistantMediaIntent = "generate-image" | "analyze-metadata";
+export type AssistantMediaContext = {
+    intent: AssistantMediaIntent;
+    mediaId?: string;
+    imageUrl?: string;
+    filename?: string;
+};
+/** Nodes pinned from the canvas or chat for the next assistant message. */
+export type AiChatAttachedNode = {
+    id: string;
+    displayName: string;
+};
+export declare const AssistantOpenAtom: import('@zedux/atoms').AtomTemplate<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: {
+        /** Node to select before chatting */
+        nodeId?: string;
+        /** "edit" pre-fills an edit hint; "create" is default */
+        mode?: "create" | "edit";
+        /** Optional prompt hint shown in the input */
+        promptHint?: string;
+        /** Default assistant scope for the next send (inline text / Text settings → text). */
+        assistantScope?: AssistantScope;
+        /**
+         * When true: clear chat + stream state and pin context to a single node (copy / text flows).
+         * Does not run for generic "open assistant" dispatches.
+         */
+        freshChat?: boolean;
+        /** With `freshChat`, set pinned context to this node only (skips querying Craft). */
+        contextNode?: AiChatAttachedNode;
+        /** Insert position context (for add-section flows) */
+        addAfter?: boolean;
+        parentNodeId?: string;
+        position?: "top" | "bottom";
+        /**
+         * When true: user explicitly requested the assistant panel (nav, wand, pin, etc.).
+         * If the user previously closed Clippy (`ph-clippy-open` is "false"), the panel still opens.
+         * Omit or false when the dispatch must not override a dismissed panel.
+         */
+        revealPanel?: boolean;
+        /** Optional media context for media-scope assistant actions. */
+        mediaContext?: AssistantMediaContext;
+    };
+    Store: import('@zedux/core').Store<{
+        /** Node to select before chatting */
+        nodeId?: string;
+        /** "edit" pre-fills an edit hint; "create" is default */
+        mode?: "create" | "edit";
+        /** Optional prompt hint shown in the input */
+        promptHint?: string;
+        /** Default assistant scope for the next send (inline text / Text settings → text). */
+        assistantScope?: AssistantScope;
+        /**
+         * When true: clear chat + stream state and pin context to a single node (copy / text flows).
+         * Does not run for generic "open assistant" dispatches.
+         */
+        freshChat?: boolean;
+        /** With `freshChat`, set pinned context to this node only (skips querying Craft). */
+        contextNode?: AiChatAttachedNode;
+        /** Insert position context (for add-section flows) */
+        addAfter?: boolean;
+        parentNodeId?: string;
+        position?: "top" | "bottom";
+        /**
+         * When true: user explicitly requested the assistant panel (nav, wand, pin, etc.).
+         * If the user previously closed Clippy (`ph-clippy-open` is "false"), the panel still opens.
+         * Omit or false when the dispatch must not override a dismissed panel.
+         */
+        revealPanel?: boolean;
+        /** Optional media context for media-scope assistant actions. */
+        mediaContext?: AssistantMediaContext;
+    }>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: {
+        /** Node to select before chatting */
+        nodeId?: string;
+        /** "edit" pre-fills an edit hint; "create" is default */
+        mode?: "create" | "edit";
+        /** Optional prompt hint shown in the input */
+        promptHint?: string;
+        /** Default assistant scope for the next send (inline text / Text settings → text). */
+        assistantScope?: AssistantScope;
+        /**
+         * When true: clear chat + stream state and pin context to a single node (copy / text flows).
+         * Does not run for generic "open assistant" dispatches.
+         */
+        freshChat?: boolean;
+        /** With `freshChat`, set pinned context to this node only (skips querying Craft). */
+        contextNode?: AiChatAttachedNode;
+        /** Insert position context (for add-section flows) */
+        addAfter?: boolean;
+        parentNodeId?: string;
+        position?: "top" | "bottom";
+        /**
+         * When true: user explicitly requested the assistant panel (nav, wand, pin, etc.).
+         * If the user previously closed Clippy (`ph-clippy-open` is "false"), the panel still opens.
+         * Omit or false when the dispatch must not override a dismissed panel.
+         */
+        revealPanel?: boolean;
+        /** Optional media context for media-scope assistant actions. */
+        mediaContext?: AssistantMediaContext;
+    };
+    Store: import('@zedux/core').Store<{
+        /** Node to select before chatting */
+        nodeId?: string;
+        /** "edit" pre-fills an edit hint; "create" is default */
+        mode?: "create" | "edit";
+        /** Optional prompt hint shown in the input */
+        promptHint?: string;
+        /** Default assistant scope for the next send (inline text / Text settings → text). */
+        assistantScope?: AssistantScope;
+        /**
+         * When true: clear chat + stream state and pin context to a single node (copy / text flows).
+         * Does not run for generic "open assistant" dispatches.
+         */
+        freshChat?: boolean;
+        /** With `freshChat`, set pinned context to this node only (skips querying Craft). */
+        contextNode?: AiChatAttachedNode;
+        /** Insert position context (for add-section flows) */
+        addAfter?: boolean;
+        parentNodeId?: string;
+        position?: "top" | "bottom";
+        /**
+         * When true: user explicitly requested the assistant panel (nav, wand, pin, etc.).
+         * If the user previously closed Clippy (`ph-clippy-open` is "false"), the panel still opens.
+         * Omit or false when the dispatch must not override a dismissed panel.
+         */
+        revealPanel?: boolean;
+        /** Optional media context for media-scope assistant actions. */
+        mediaContext?: AssistantMediaContext;
+    }>;
+}, import('@zedux/atoms').AtomTemplateBase<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: {
+        /** Node to select before chatting */
+        nodeId?: string;
+        /** "edit" pre-fills an edit hint; "create" is default */
+        mode?: "create" | "edit";
+        /** Optional prompt hint shown in the input */
+        promptHint?: string;
+        /** Default assistant scope for the next send (inline text / Text settings → text). */
+        assistantScope?: AssistantScope;
+        /**
+         * When true: clear chat + stream state and pin context to a single node (copy / text flows).
+         * Does not run for generic "open assistant" dispatches.
+         */
+        freshChat?: boolean;
+        /** With `freshChat`, set pinned context to this node only (skips querying Craft). */
+        contextNode?: AiChatAttachedNode;
+        /** Insert position context (for add-section flows) */
+        addAfter?: boolean;
+        parentNodeId?: string;
+        position?: "top" | "bottom";
+        /**
+         * When true: user explicitly requested the assistant panel (nav, wand, pin, etc.).
+         * If the user previously closed Clippy (`ph-clippy-open` is "false"), the panel still opens.
+         * Omit or false when the dispatch must not override a dismissed panel.
+         */
+        revealPanel?: boolean;
+        /** Optional media context for media-scope assistant actions. */
+        mediaContext?: AssistantMediaContext;
+    };
+    Store: import('@zedux/core').Store<{
+        /** Node to select before chatting */
+        nodeId?: string;
+        /** "edit" pre-fills an edit hint; "create" is default */
+        mode?: "create" | "edit";
+        /** Optional prompt hint shown in the input */
+        promptHint?: string;
+        /** Default assistant scope for the next send (inline text / Text settings → text). */
+        assistantScope?: AssistantScope;
+        /**
+         * When true: clear chat + stream state and pin context to a single node (copy / text flows).
+         * Does not run for generic "open assistant" dispatches.
+         */
+        freshChat?: boolean;
+        /** With `freshChat`, set pinned context to this node only (skips querying Craft). */
+        contextNode?: AiChatAttachedNode;
+        /** Insert position context (for add-section flows) */
+        addAfter?: boolean;
+        parentNodeId?: string;
+        position?: "top" | "bottom";
+        /**
+         * When true: user explicitly requested the assistant panel (nav, wand, pin, etc.).
+         * If the user previously closed Clippy (`ph-clippy-open` is "false"), the panel still opens.
+         * Omit or false when the dispatch must not override a dismissed panel.
+         */
+        revealPanel?: boolean;
+        /** Optional media context for media-scope assistant actions. */
+        mediaContext?: AssistantMediaContext;
+    }>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: {
+        /** Node to select before chatting */
+        nodeId?: string;
+        /** "edit" pre-fills an edit hint; "create" is default */
+        mode?: "create" | "edit";
+        /** Optional prompt hint shown in the input */
+        promptHint?: string;
+        /** Default assistant scope for the next send (inline text / Text settings → text). */
+        assistantScope?: AssistantScope;
+        /**
+         * When true: clear chat + stream state and pin context to a single node (copy / text flows).
+         * Does not run for generic "open assistant" dispatches.
+         */
+        freshChat?: boolean;
+        /** With `freshChat`, set pinned context to this node only (skips querying Craft). */
+        contextNode?: AiChatAttachedNode;
+        /** Insert position context (for add-section flows) */
+        addAfter?: boolean;
+        parentNodeId?: string;
+        position?: "top" | "bottom";
+        /**
+         * When true: user explicitly requested the assistant panel (nav, wand, pin, etc.).
+         * If the user previously closed Clippy (`ph-clippy-open` is "false"), the panel still opens.
+         * Omit or false when the dispatch must not override a dismissed panel.
+         */
+        revealPanel?: boolean;
+        /** Optional media context for media-scope assistant actions. */
+        mediaContext?: AssistantMediaContext;
+    };
+    Store: import('@zedux/core').Store<{
+        /** Node to select before chatting */
+        nodeId?: string;
+        /** "edit" pre-fills an edit hint; "create" is default */
+        mode?: "create" | "edit";
+        /** Optional prompt hint shown in the input */
+        promptHint?: string;
+        /** Default assistant scope for the next send (inline text / Text settings → text). */
+        assistantScope?: AssistantScope;
+        /**
+         * When true: clear chat + stream state and pin context to a single node (copy / text flows).
+         * Does not run for generic "open assistant" dispatches.
+         */
+        freshChat?: boolean;
+        /** With `freshChat`, set pinned context to this node only (skips querying Craft). */
+        contextNode?: AiChatAttachedNode;
+        /** Insert position context (for add-section flows) */
+        addAfter?: boolean;
+        parentNodeId?: string;
+        position?: "top" | "bottom";
+        /**
+         * When true: user explicitly requested the assistant panel (nav, wand, pin, etc.).
+         * If the user previously closed Clippy (`ph-clippy-open` is "false"), the panel still opens.
+         * Omit or false when the dispatch must not override a dismissed panel.
+         */
+        revealPanel?: boolean;
+        /** Optional media context for media-scope assistant actions. */
+        mediaContext?: AssistantMediaContext;
+    }>;
+}, any>>>>;
+export declare const AssistantMediaMetadataResultAtom: import('@zedux/atoms').AtomTemplate<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: {
+        mediaId: string;
+        title?: string;
+        alt?: string;
+        description?: string;
+        requestId?: string;
+    };
+    Store: import('@zedux/core').Store<{
+        mediaId: string;
+        title?: string;
+        alt?: string;
+        description?: string;
+        requestId?: string;
+    }>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: {
+        mediaId: string;
+        title?: string;
+        alt?: string;
+        description?: string;
+        requestId?: string;
+    };
+    Store: import('@zedux/core').Store<{
+        mediaId: string;
+        title?: string;
+        alt?: string;
+        description?: string;
+        requestId?: string;
+    }>;
+}, import('@zedux/atoms').AtomTemplateBase<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: {
+        mediaId: string;
+        title?: string;
+        alt?: string;
+        description?: string;
+        requestId?: string;
+    };
+    Store: import('@zedux/core').Store<{
+        mediaId: string;
+        title?: string;
+        alt?: string;
+        description?: string;
+        requestId?: string;
+    }>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: {
+        mediaId: string;
+        title?: string;
+        alt?: string;
+        description?: string;
+        requestId?: string;
+    };
+    Store: import('@zedux/core').Store<{
+        mediaId: string;
+        title?: string;
+        alt?: string;
+        description?: string;
+        requestId?: string;
+    }>;
+}, any>>>>;
+export declare const AiChatAttachedNodesAtom: import('@zedux/atoms').AtomTemplate<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: AiChatAttachedNode[];
+    Store: import('@zedux/core').Store<AiChatAttachedNode[]>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: AiChatAttachedNode[];
+    Store: import('@zedux/core').Store<AiChatAttachedNode[]>;
+}, import('@zedux/atoms').AtomTemplateBase<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: AiChatAttachedNode[];
+    Store: import('@zedux/core').Store<AiChatAttachedNode[]>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: AiChatAttachedNode[];
+    Store: import('@zedux/core').Store<AiChatAttachedNode[]>;
+}, any>>>>;
+/** Whether the docked Layers panel at the bottom of the sidebar is expanded. */
+export declare const SidebarLayersPanelAtom: import('@zedux/atoms').AtomTemplate<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomTemplateBase<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, any>>>>;
+/** Whether the pinned inspector sections dock (above Layers) is expanded. */
+export declare const InspectorPinDockOpenAtom: import('@zedux/atoms').AtomTemplate<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomTemplateBase<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, any>>>>;
+/** Whether the floating Layers dialog is open. Shared atom so both Header and SidebarLayersPanel can control it. */
+export declare const LayersDialogOpenAtom: import('@zedux/atoms').AtomTemplate<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomTemplateBase<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, any>>>>;
+/** Whether the Media Manager modal is currently open. */
+export declare const MediaManagerModalAtom: import('@zedux/atoms').AtomTemplate<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomTemplateBase<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, any>>>>;
+/** Whether the Modifiers modal is currently open. */
+export declare const ModifiersModalAtom: import('@zedux/atoms').AtomTemplate<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomTemplateBase<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, any>>>>;
+/** Show or hide nodes whose visibility was authored as "hidden". Default true. */
+export declare const ShowHiddenAtom: import('@zedux/atoms').AtomTemplate<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomTemplateBase<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, any>>>>;
+/**
+ * Editor chrome dark mode. Default `false`; the `useDarkMode` hook hydrates
+ * from `phStorage["theme"]` + `prefers-color-scheme` on mount. Lifted to an
+ * atom in Phase 2 C2b so `ph.ui.toggleDarkMode` can fire from outside React
+ * (keybinding dispatcher / command palette / host code).
+ */
+export declare const DarkModeAtom: import('@zedux/atoms').AtomTemplate<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomTemplateBase<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, any>>>>;
+export declare const IsolateAtom: import('@zedux/atoms').AtomTemplate<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: string;
+    Store: import('@zedux/core').Store<string>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: string;
+    Store: import('@zedux/core').Store<string>;
+}, import('@zedux/atoms').AtomTemplateBase<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: string;
+    Store: import('@zedux/core').Store<string>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: string;
+    Store: import('@zedux/core').Store<string>;
+}, any>>>>;
+/** A reusable saved component registered in {@link ComponentsAtom}. */
+export interface SavedComponent {
+    /** CraftJS node id of the component's root node. */
+    rootNodeId: string;
+    /** JSON-serialized node map of the component subtree. */
+    nodes: string;
+    /** Display name shown in the saved-components toolbox. */
+    name: string;
+    /** `true` = saved as a full-width section/block rather than a component. */
+    isSection?: boolean;
+}
+export declare const ComponentsAtom: import('@zedux/atoms').AtomTemplate<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: SavedComponent[];
+    Store: import('@zedux/core').Store<SavedComponent[]>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: SavedComponent[];
+    Store: import('@zedux/core').Store<SavedComponent[]>;
+}, import('@zedux/atoms').AtomTemplateBase<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: SavedComponent[];
+    Store: import('@zedux/core').Store<SavedComponent[]>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: SavedComponent[];
+    Store: import('@zedux/core').Store<SavedComponent[]>;
+}, any>>>>;
+export declare const OnlineAtom: import('@zedux/atoms').AtomTemplate<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomTemplateBase<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, any>>>>;
+export declare const ScreenshotAtom: import('@zedux/atoms').AtomTemplate<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomTemplateBase<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, any>>>>;
+export declare const SideBarAtom: import('@zedux/atoms').AtomTemplate<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomTemplateBase<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, any>>>>;
+export declare const SideBarOpen: import('@zedux/atoms').AtomTemplate<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomTemplateBase<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: boolean;
+    Store: import('@zedux/core').Store<boolean>;
+}, any>>>>;
+/**
+ * `true` = main editor settings toolbar is docked to the **left** of the canvas; `false` = docked to the **right**.
+ * Use for chrome that should align with the toolbar side (e.g. Site Settings docks the same way).
+ */
+export declare function useEditorSidebarDockLeft(): boolean;
+/** Canvas scope for component editor — not the same as responsive viewport `ViewMode` in store.tsx */
+export type EditorCanvasViewMode = "page" | "preview" | "canvas";
+export declare const ViewModeAtom: import('@zedux/atoms').AtomTemplate<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: EditorCanvasViewMode;
+    Store: import('@zedux/core').Store<EditorCanvasViewMode>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: EditorCanvasViewMode;
+    Store: import('@zedux/core').Store<EditorCanvasViewMode>;
+}, import('@zedux/atoms').AtomTemplateBase<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: EditorCanvasViewMode;
+    Store: import('@zedux/core').Store<EditorCanvasViewMode>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: EditorCanvasViewMode;
+    Store: import('@zedux/core').Store<EditorCanvasViewMode>;
+}, any>>>>;
+export declare const LastActiveAtom: import('@zedux/atoms').AtomTemplate<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: string;
+    Store: import('@zedux/core').Store<string>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: string;
+    Store: import('@zedux/core').Store<string>;
+}, import('@zedux/atoms').AtomTemplateBase<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: string;
+    Store: import('@zedux/core').Store<string>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: string;
+    Store: import('@zedux/core').Store<string>;
+}, any>>>>;
+export declare const ActiveAtom: import('@zedux/atoms').AtomTemplate<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: string;
+    Store: import('@zedux/core').Store<string>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: string;
+    Store: import('@zedux/core').Store<string>;
+}, import('@zedux/atoms').AtomTemplateBase<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: string;
+    Store: import('@zedux/core').Store<string>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: string;
+    Store: import('@zedux/core').Store<string>;
+}, any>>>>;
+export declare const SelectedSectionAtom: import('@zedux/atoms').AtomTemplate<{
+    State: import('@zedux/atoms').PromiseState<string>;
+    Params: [];
+    Exports: Record<string, never>;
+    Store: import('@zedux/core').Store<import('@zedux/atoms').PromiseState<string>>;
+    Promise: Promise<string>;
+}, import('@zedux/atoms').AtomInstance<{
+    State: import('@zedux/atoms').PromiseState<string>;
+    Params: [];
+    Exports: Record<string, never>;
+    Store: import('@zedux/core').Store<import('@zedux/atoms').PromiseState<string>>;
+    Promise: Promise<string>;
+}, import('@zedux/atoms').AtomTemplateBase<{
+    State: import('@zedux/atoms').PromiseState<string>;
+    Params: [];
+    Exports: Record<string, never>;
+    Store: import('@zedux/core').Store<import('@zedux/atoms').PromiseState<string>>;
+    Promise: Promise<string>;
+}, import('@zedux/atoms').AtomInstance<{
+    State: import('@zedux/atoms').PromiseState<string>;
+    Params: [];
+    Exports: Record<string, never>;
+    Store: import('@zedux/core').Store<import('@zedux/atoms').PromiseState<string>>;
+    Promise: Promise<string>;
+}, any>>>>;
+/**
+ * Signal atom used by `ph.node.renameDisplayName` to drive the inline rename
+ * UI in `NodeBreadcrumb` from outside React. The command writes the target
+ * node id; the breadcrumb consumes the atom — when the current crumb's id
+ * matches it enters edit mode and clears the atom back to `null` so the
+ * signal can fire again. Cleared on exit (Enter / Escape / blur).
+ */
+export declare const BreadcrumbRenameRequestedAtom: import('@zedux/atoms').AtomTemplate<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: string;
+    Store: import('@zedux/core').Store<string>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: string;
+    Store: import('@zedux/core').Store<string>;
+}, import('@zedux/atoms').AtomTemplateBase<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: string;
+    Store: import('@zedux/core').Store<string>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: string;
+    Store: import('@zedux/core').Store<string>;
+}, any>>>>;
+/**
+ * Currently-open Tiptap inline-edit toolbar panel. Lifted out of
+ * `InlineEditToolbar` local state in Phase 2 C2g so `ph.text.openFontPanel` /
+ * `openLinkPanel` / `openMorePanel` / `openTextColorPanel` /
+ * `openHighlightPanel` / `closeActivePanel` commands can drive it from the
+ * registry (palette, keybindings, right-click menu, etc.).
+ *
+ * Set to `null` when no panel is open. The toolbar mounts a useEffect that
+ * watches selection / mount transitions and resets to null on outside click
+ * or Escape.
+ */
+export type InlineEditActivePanel = "font" | "link" | "more" | "bgcolor" | "textcolor" | null;
+export declare const InlineEditActivePanelAtom: import('@zedux/atoms').AtomTemplate<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: InlineEditActivePanel;
+    Store: import('@zedux/core').Store<InlineEditActivePanel>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: InlineEditActivePanel;
+    Store: import('@zedux/core').Store<InlineEditActivePanel>;
+}, import('@zedux/atoms').AtomTemplateBase<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: InlineEditActivePanel;
+    Store: import('@zedux/core').Store<InlineEditActivePanel>;
+}, import('@zedux/atoms').AtomInstance<{
+    Exports: Record<string, never>;
+    Params: [];
+    Promise: undefined;
+    State: InlineEditActivePanel;
+    Store: import('@zedux/core').Store<InlineEditActivePanel>;
+}, any>>>>;
+//# sourceMappingURL=atoms.d.ts.map