chaipro 0.1.0

package/dist/actions-DM00SIUk.d.cts

@@ -0,0 +1,899 @@
+import { StreamTextResult } from 'ai';
+import { RJSFSchema, UiSchema } from '@rjsf/utils';
+import * as React from 'react';
+import React__default from 'react';
+
+interface ChaiPage$1 {
+    id: string;
+    name: string;
+    slug: string;
+    pageType: string;
+    parent: string | null;
+    children?: ChaiPage$1[];
+    isTemplate?: boolean;
+    dynamic?: boolean;
+    [key: string]: any;
+}
+
+type StructureError = {
+    id: string;
+    message: string;
+    severity: "error" | "warning";
+    blockId?: string;
+    partialBlockId?: string;
+};
+type StructureRule = {
+    name: string;
+    description: string;
+    validate: (canvasDocument: Document) => StructureError[];
+};
+
+type FilterOptions = {
+    id: string;
+    name: string;
+    description?: string;
+};
+type SortOptions = {
+    id: string;
+    name: string;
+    description?: string;
+};
+type ChaiCollectoin = {
+    id: string;
+    name: string;
+    description?: string;
+    filters?: FilterOptions[];
+    sorts?: SortOptions[];
+};
+
+type ChaiRenderBlockProps<T> = {
+    blockProps: Record<string, string>;
+    children?: React.ReactNode;
+    inBuilder: boolean;
+} & T;
+type ChaiBlockStyles = Record<string, string>;
+
+interface ChaiDesignTokens {
+    [uniqueId: string]: {
+        name: string;
+        description?: string;
+        value: string;
+        archived?: boolean;
+    };
+}
+type ChaiBlocksWithDesignTokens = Record<string, string>;
+interface ChaiSiteWideUsageData {
+    [pageId: string]: {
+        name: string;
+        isPartial: boolean;
+        partialBlocks: string[];
+        links: string[];
+        designTokens: ChaiBlocksWithDesignTokens;
+    };
+}
+
+type ChaiLibraryBlock<T = Record<string, any>> = {
+    id: string;
+    group: string;
+    name: string;
+    preview?: string;
+    tags?: string[];
+    description?: string;
+} & T;
+type ChaiLibrary<T = Record<string, any>> = {
+    id: string;
+    name: string;
+    blocks?: ChaiLibraryBlock[];
+    description?: string;
+} & T;
+type ReactComponentType = React__default.ComponentType<any>;
+type CSSVariableName = string;
+type HSLColor = string;
+type HexColor = string;
+type ChaiCssVariableNameWithDefault = Record<CSSVariableName, any>;
+type VariableKey = string;
+type ChaiBorderRadiusValue = false | string;
+type ChaiThemeOptions = {
+    fontFamily: false | Record<VariableKey, string>;
+    borderRadius: ChaiBorderRadiusValue;
+    colors: {
+        group: string;
+        items: Record<VariableKey, [HSLColor, HSLColor]>;
+    }[];
+};
+type ChaiBreakpoint = {
+    title: string;
+    content: string;
+    breakpoint: "xs" | "sm" | "md" | "lg" | "xl" | "2xl" | string;
+    icon: React__default.ReactNode | Element;
+    width: number;
+};
+type ChaiSavePageData = {
+    autoSave: boolean;
+    blocks: ChaiBlock[];
+    needTranslations?: boolean;
+    designTokens: ChaiDesignTokens;
+    partialIds?: string[];
+    linkPageIds?: string[];
+};
+type ChaiSaveWebsiteData = {
+    type: "THEME";
+    data: ChaiTheme;
+} | {
+    type: "DESIGN_TOKENS";
+    data: ChaiDesignTokens;
+};
+type ChaiAskAiResponse = {
+    blocks?: Array<{
+        _id: string;
+    } & Partial<ChaiBlock>>;
+    usage?: Record<any, number>;
+    error?: any;
+};
+type ChaiTheme = {
+    fontFamily: {
+        heading: string;
+        body: string;
+    };
+    borderRadius: string;
+    colors: {
+        background: [HexColor, HexColor];
+        foreground: [HexColor, HexColor];
+        primary: [HexColor, HexColor];
+        "primary-foreground": [HexColor, HexColor];
+        secondary: [HexColor, HexColor];
+        "secondary-foreground": [HexColor, HexColor];
+        muted: [HexColor, HexColor];
+        "muted-foreground": [HSLColor, HSLColor];
+        accent: [HSLColor, HSLColor];
+        "accent-foreground": [HSLColor, HSLColor];
+        destructive: [HSLColor, HSLColor];
+        "destructive-foreground": [HSLColor, HSLColor];
+        border: [HSLColor, HSLColor];
+        input: [HSLColor, HSLColor];
+        ring: [HexColor, HexColor];
+        card: [HexColor, HexColor];
+        "card-foreground": [HexColor, HexColor];
+        popover: [HexColor, HexColor];
+        "popover-foreground": [HexColor, HexColor];
+        success?: [HexColor, HexColor];
+        "success-foreground"?: [HexColor, HexColor];
+        warning?: [HexColor, HexColor];
+        "warning-foreground"?: [HexColor, HexColor];
+        info?: [HexColor, HexColor];
+        "info-foreground"?: [HexColor, HexColor];
+        purple?: [HexColor, HexColor];
+        "purple-foreground"?: [HexColor, HexColor];
+        orange?: [HexColor, HexColor];
+        "orange-foreground"?: [HexColor, HexColor];
+        aqua?: [HexColor, HexColor];
+        "aqua-foreground"?: [HexColor, HexColor];
+    };
+};
+interface ChaiBuilderEditorProps {
+    children?: React__default.ReactNode;
+    /**
+     * Goto page callback
+     */
+    gotoPage?: ({ pageId, lang }: {
+        pageId: string;
+        lang: string;
+    }) => void;
+    /**
+     * User
+     */
+    user?: ChaiLoggedInUser;
+    /**
+     * Permissions
+     */
+    permissions?: string[] | null;
+    /**
+     * Optional pageId. If not provided, a random pageId will be generated
+     */
+    pageId?: string;
+    /**
+     * Page external data
+     */
+    pageExternalData?: Record<string, any>;
+    /**
+     * Theme presets
+     */
+    themePresets?: Record<string, Partial<ChaiTheme>>[];
+    /**
+     * Theme
+     */
+    theme?: ChaiTheme;
+    /**
+     * Builder theme
+     */
+    builderTheme?: ChaiTheme;
+    /**
+     * Theme panel component
+     * TODO: Move to registerChaiThemePanelComponent()
+     */
+    themePanelComponent?: ReactComponentType;
+    /**
+     * onError callback function
+     * @param error
+     */
+    onError?: (error: Error) => void;
+    /**
+     * Translations object
+     */
+    translations?: Record<string, Record<string, any>>;
+    /**
+     * Custom layout component
+     * TODO: Move to registerChaiLayoutComponent()
+     */
+    layout?: React__default.ComponentType;
+    /**
+     * HTML direction.
+     */
+    htmlDir?: "ltr" | "rtl";
+    /**
+     * Show debug logs
+     */
+    debugLogs?: boolean;
+    /**
+     * Auto save support
+     */
+    autoSave?: boolean;
+    /**
+     * Auto save interval in seconds
+     */
+    autoSaveActionsCount?: number;
+    /**
+     * Breakpoints
+     */
+    breakpoints?: ChaiBreakpoint[];
+    /**
+     * Loading state
+     */
+    loading?: boolean;
+    /**
+     * Locale
+     */
+    locale?: string;
+    /**
+     * Ask AI callback
+     */
+    askAiCallBack?: (type: "styles" | "content", prompt: string, blocks: ChaiBlock[], lang: string) => Promise<ChaiAskAiResponse>;
+    /**
+     * Get partial blocks
+     * @returns {Record<string, { type: string; name: string; description?: string }>}
+     */
+    getPartialBlocks?: () => Promise<Record<string, {
+        type: string;
+        name: string;
+        description?: string;
+    }>>;
+    /**
+     * Get all blocks of a partial block
+     */
+    getPartialBlockBlocks?: (partialBlockKey: string) => Promise<ChaiBlock[]>;
+    /**
+     * Blocks for the page
+     */
+    blocks?: ChaiBlock[];
+    /**
+     * onSave callback function
+     * @param saveData
+     */
+    onSave?: ({ blocks, autoSave }: ChaiSavePageData) => Promise<boolean | Error>;
+    /**
+     * onSaveWebsiteData callback function for theme and design tokens
+     * @param saveData
+     */
+    onSaveWebsiteData?: (data: ChaiSaveWebsiteData) => Promise<boolean | Error>;
+    /**
+     * onSaveStateChange callback function
+     * @param syncStatus
+     */
+    onSaveStateChange?: (syncStatus: "SAVED" | "SAVING" | "UNSAVED") => void;
+    /**
+     * Preview component
+     * TODO: Move to registerChaiPreviewComponent()
+     */
+    previewComponent?: ReactComponentType;
+    /**
+     * Content locale
+     */
+    fallbackLang?: string;
+    /**
+     * Languages
+     */
+    languages?: string[];
+    /**
+     * Page Types props
+     */
+    pageTypes?: ChaiPageType[];
+    /**
+     * Search page type items
+     */
+    searchPageTypeItems?: (pageTypeKey: string, query: string) => Promise<Pick<ChaiPage$1, "id" | "slug" | "name">[] | Error>;
+    /**
+     * Collections
+     */
+    collections?: ChaiCollectoin[];
+    /**
+     * Get Block Async Props
+     */
+    getBlockAsyncProps?: (args: {
+        block: ChaiBlock;
+    }) => Promise<{
+        [key: string]: any;
+    }>;
+    /**
+     * temporary props. Not to be used in production
+     */
+    flags?: {
+        librarySite?: boolean;
+        copyPaste?: boolean;
+        exportCode?: boolean;
+        darkMode?: boolean;
+        dataBinding?: boolean;
+        importHtml?: boolean;
+        importTheme?: boolean;
+        gotoSettings?: boolean;
+        dragAndDrop?: boolean;
+        validateStructure?: boolean;
+        designTokens?: boolean;
+        ai?: boolean;
+        aiCredits?: boolean;
+        revisions?: boolean;
+        sharedJsonLD?: boolean;
+        resetSeoToDefault?: boolean;
+        pagesManager?: boolean;
+        dam?: {
+            searchImages?: boolean;
+            genAI?: boolean;
+        };
+        trash?: boolean;
+        animation?: boolean;
+        bulkPublish?: boolean;
+        draftsInRevisions?: boolean;
+    };
+    structureRules?: StructureRule[];
+    designTokens?: ChaiDesignTokens;
+    siteWideUsage?: ChaiSiteWideUsageData;
+    /**
+     * Custom feature labels with i18n support
+     */
+    labels?: {
+        features?: {
+            designTokens?: string | Record<string, string>;
+            trash?: string | Record<string, string>;
+            dataBinding?: string | Record<string, string>;
+            ai?: string | Record<string, string>;
+        };
+    };
+    /**
+     * Screen to small message component
+     */
+    smallScreenComponent?: ReactComponentType;
+}
+
+type ChaiUserAccess = {
+    role: string;
+    permissions: string[] | null;
+};
+/**
+ * Action Context
+ * Contains information and repositories needed by actions
+ */
+interface ChaiActionContext {
+    appId: string;
+    userId?: string;
+    /** Resolved app membership, set by dispatchChaiAction for authenticated actions. */
+    userAccess?: ChaiUserAccess;
+    /**
+     * Delegated permission scopes for MCP-scoped requests. When present, effective
+     * permissions are clamped to `userPermissions ∩ delegatedScopes`. Absent/null on
+     * normal browser requests (full user permissions apply).
+     */
+    delegatedScopes?: string[] | null;
+    /** Registry action key, when set by the dispatcher. */
+    action?: string;
+}
+/**
+ * Resolves the permission required to run an action.
+ * Either a static permission key (`entity:operation`) or a function that derives
+ * it from the action data/context (e.g. page-type-level permissions).
+ * Return `null`/`undefined` to require no specific permission (authenticated-only).
+ */
+type ChaiRequiredPermission<T = any> = string | ((data: T, context: ChaiActionContext) => string | null | undefined);
+/**
+ * ChaiAction Interface
+ * Defines the contract for all action handlers
+ */
+interface ChaiAction<T = any, K = any> {
+    /**
+     * Permission required to run this action. Enforced by `dispatchChaiAction`.
+     * Undeclared (undefined) = authenticated-only (no specific permission).
+     */
+    requiredPermission?: ChaiRequiredPermission<T>;
+    validate(data: T): boolean;
+    setContext(context: ChaiActionContext): void;
+    execute(data: T): Promise<K>;
+    run(data: T): Promise<K>;
+}
+
+type TrashContext = ChaiActionContext & Record<string, any>;
+type TrashRecord = {
+    id: string;
+    entityType: string;
+    entityId: string;
+    name?: string;
+    metadata?: Record<string, any>;
+    deletedAt?: string;
+    deletedBy: string;
+    app?: string;
+    tags?: string[];
+};
+type TrashableRecordData = Omit<TrashRecord, "id">;
+type RestoreConflictResolution = {
+    resolved: boolean;
+    newSlug?: string;
+};
+interface ChaiTrashableEntity {
+    key: string;
+    label: string;
+    icon?: string;
+    moveToTrash: (id: string, context: TrashContext) => Promise<TrashableRecordData>;
+    restore: (record: TrashRecord, context: TrashContext) => Promise<void>;
+    deletePermanently: (record: TrashRecord, context: TrashContext) => Promise<boolean>;
+    hasRestoreConflict?: (record: TrashRecord, context: TrashContext) => Promise<boolean>;
+    resolveRestoreConflict?: (record: TrashRecord, context: TrashContext) => Promise<RestoreConflictResolution>;
+}
+
+type AIModel = {
+    id: string;
+    name: string;
+    provider: string;
+    description: string;
+    multiplier: number;
+    /** MIME types this model accepts as file attachments. Set by the consumer via AIConfigProvider or ai.models prop. */
+    allowedFileTypes?: string[];
+};
+type AICompletionEvent = {
+    type: "completion";
+    content: string;
+    model: string;
+    timestamp: number;
+};
+type AIErrorEvent = {
+    type: "error";
+    error: Error | string;
+    model?: string;
+    timestamp: number;
+};
+type AIStreamStartEvent = {
+    type: "stream_start";
+    model: string;
+    timestamp: number;
+};
+type AIEvent = AICompletionEvent | AIErrorEvent | AIStreamStartEvent;
+type AISuccessCallback = {
+    content: string;
+    model: string;
+    timestamp: number;
+};
+type AIErrorCallback = {
+    error: Error | string;
+    model: string;
+    timestamp: number;
+};
+type AICompleteCallback = {
+    success: boolean;
+    content?: string;
+    error?: Error | string;
+    model: string;
+    timestamp: number;
+};
+
+type LoggedInUser = {
+    id: string;
+    email: string;
+    name: string;
+    avatar?: string;
+    metadata?: Record<string, any>;
+};
+
+type ChaiBlock<T = Record<string, any>> = {
+    _id: string;
+    _name?: string;
+    _parent?: string | null | undefined;
+    _libBlock?: string;
+    _type: string;
+    partialBlockId?: string;
+} & T;
+interface ChaiCoreBlock {
+    blocks?: ChaiBlock[];
+    data: any;
+    props: {
+        [key: string]: any;
+    };
+    type: string;
+    _name?: string;
+    partialBlockId?: string;
+}
+
+type ChaiBlockUiSchema = UiSchema;
+type ChaiBlockPropsSchema = RJSFSchema & {
+    properties?: {
+        [key: string]: RJSFSchema;
+    } | undefined;
+    enumNames?: (string | number)[];
+};
+type ChaiBlockSchema = {
+    properties?: Record<string, ChaiBlockPropsSchema>;
+    allOf?: any[];
+    oneOf?: any[];
+} & Partial<Pick<ChaiBlockPropsSchema, "required" | "dependencies" | "ui" | "title" | "description" | "default">>;
+type ChaiBlockSchemas = {
+    schema: object | Omit<ChaiBlockSchema, "ui">;
+    uiSchema?: ChaiBlockUiSchema;
+};
+type ChaiBlockRJSFSchemas = {
+    schema: object | Omit<ChaiBlockSchema, "ui">;
+    uiSchema: ChaiBlockUiSchema;
+};
+type ChaiWebsiteBuilderProps = {
+    ai?: {
+        models?: AIModel[];
+        /** Map of model keys to action names they handle. Actions: 'AI_ENHANCE_CONTEXT', 'AI_GENERATE_THEME', 'AI_GENERATE_SEO_FIELD', 'AI_GENERATE_IMAGE_DESCRIPTION', 'AI_GENERATE_IMAGE' */
+        actionModels?: Record<string, string[]>;
+    };
+    hasReactQueryProvider?: boolean;
+    apiUrl?: string;
+    getPreviewUrl?: (slug: string) => string;
+    getLiveUrl?: (slug: string) => string;
+    onLogout?: (reason?: string) => void;
+    getAccessToken?: () => Promise<string>;
+    currentUser: LoggedInUser | null;
+    websocket?: any;
+    beforeRequest?: (params: {
+        action: string;
+        data: any;
+    }) => Promise<{
+        action: string;
+        data: any;
+    } | null> | {
+        action: string;
+        data: any;
+    } | null;
+    dam?: {
+        searchImages?: {
+            providers: {
+                id: string;
+                filters: Record<string, string[]>;
+            }[];
+        };
+    };
+} & Pick<ChaiBuilderEditorProps, "onError" | "translations" | "locale" | "htmlDir" | "autoSave" | "autoSaveActionsCount" | "fallbackLang" | "languages" | "themePresets" | "flags" | "structureRules" | "labels">;
+type ChaiPageProps<T = Record<string, any>> = {
+    slug: string;
+    searchParams?: Record<string, string>;
+} & T;
+type ChaiFontByUrl = {
+    family: string;
+    url: string;
+    fallback: string;
+};
+type ChaiFontSource = {
+    url: string;
+    format: string;
+    fontWeight?: string;
+    fontStyle?: string;
+    fontDisplay?: string;
+    fontStretch?: string;
+};
+type ChaiFontBySrc = {
+    family: string;
+    src: ChaiFontSource[];
+    fallback: string;
+};
+type ChaiSystemFont = {
+    family: string;
+    fallback: string;
+};
+type ChaiFont = ChaiFontByUrl | ChaiFontBySrc | ChaiSystemFont;
+
+type CollectionFetchParams = {
+    block: ChaiBlock;
+    inBuilder: boolean;
+    draft: boolean;
+    lang: string;
+    pageProps: {
+        slug: string;
+        params?: Record<string, string>;
+        [key: string]: any;
+    };
+};
+interface CollectionConfig<T> {
+    id: string;
+    name: string;
+    icon?: string;
+    filters?: {
+        id: string;
+        name: string;
+    }[];
+    sort?: {
+        id: string;
+        name: string;
+    }[];
+    fetch: (params: CollectionFetchParams) => Promise<{
+        items: T[];
+        totalItems?: number;
+    }>;
+}
+
+/**
+ * Minimal request shape for route handlers and `resolveRequestContext`.
+ * Structural type compatible with Next.js `NextRequest` and standard `Request`.
+ */
+type ChaiIncomingRequest = {
+    headers: {
+        get(name: string): string | null;
+    };
+    method: string;
+    url: string;
+    cookies: {
+        get(name: string): {
+            value: string;
+        } | undefined;
+    };
+};
+/**
+ * Per-request context from `resolveDefaultChaiContext`, `resolveRequestContext`, or `getChaiBuilder(config, route)`.
+ */
+type ChaiRequestContext = {
+    appId: string;
+    userId?: string | null;
+    draft?: boolean;
+    siteUrl?: string | null;
+    lang?: string;
+    /**
+     * MCP-delegated permission scopes. When present, effective permissions are
+     * clamped to `userPermissions ∩ delegatedScopes`. Absent on normal browser requests.
+     */
+    delegatedScopes?: string[] | null;
+    /**
+     * Client-sent license last-check timestamp (ms epoch, as a string) from the
+     * `x-chai-license-check` request header. A refresh throttle only — never
+     * license data. Populated from the request during context resolution.
+     */
+    licenseCheck?: string | null;
+};
+/**
+ * Arguments passed to the process-registered {@link ChaiContextResolver}.
+ * `request` is present in route handlers; absent in server components, server
+ * actions, MCP tools, and scripts (resolve identity from headers/cookies/args).
+ */
+type ChaiContextResolverArgs<Req extends ChaiIncomingRequest = ChaiIncomingRequest> = {
+    request?: Req;
+    routeProps?: ChaiBuilderRouteProps;
+};
+/**
+ * Resolves the full {@link ChaiRequestContext} for the current call. Registered
+ * once per process via `setChaiContextResolver`, decoupled from the server config
+ * so the config stays environment-agnostic (Next-free).
+ */
+type ChaiContextResolver<Req extends ChaiIncomingRequest = ChaiIncomingRequest> = (args: ChaiContextResolverArgs<Req>) => Partial<ChaiRequestContext> | Promise<Partial<ChaiRequestContext>>;
+/**
+ * @deprecated Context passed to the removed `resolveSiteUrl` config option.
+ * Resolve `siteUrl` inside your {@link ChaiContextResolver} instead.
+ */
+type ChaiResolveSiteUrlContext = {
+    appId: string;
+};
+/** @deprecated Use {@link ChaiContextResolverArgs}. */
+type ChaiRequestContextArgs<Req extends ChaiIncomingRequest = ChaiIncomingRequest> = {
+    routeProps: ChaiBuilderRouteProps;
+    request?: Req;
+};
+/** @deprecated Use {@link ChaiContextResolver}. */
+type ChaiRequestContextResolver<Req extends ChaiIncomingRequest = ChaiIncomingRequest> = (args: ChaiRequestContextArgs<Req>) => Partial<ChaiRequestContext> | Promise<Partial<ChaiRequestContext>>;
+/**
+ * Same shape as Next.js App Router route component props (`page` / `layout` / `generateMetadata`).
+ * `params` / `searchParams` may be `Promise`s (Next 15+) or plain objects.
+ *
+ * Route Handlers (`route.ts`): pass `params` / `searchParams` from the handler context plus optional
+ * `ChaiIncomingRequest` (e.g. Next.js `NextRequest`) as the third argument to `getChaiBuilder`.
+ */
+type ChaiBuilderRouteProps = {
+    params?: Promise<unknown> | unknown;
+    searchParams?: Promise<unknown> | unknown;
+};
+/**
+ * Global data provider function - returns merged global data object
+ */
+type ChaiGlobalDataProvider<T = any> = (ctx: {
+    lang: string;
+    draft: boolean;
+    inBuilder: boolean;
+}) => Promise<T>;
+/**
+ * Page type entry (includes both page types and partials)
+ */
+type ChaiPageTypeEntry = ChaiPageType & {
+    partial?: boolean;
+};
+/**
+ * Collection entry
+ */
+type ChaiCollectionEntry = CollectionConfig<any>;
+/**
+ * Page type data provider function
+ */
+type ChaiPageTypeDataProvider<T = Record<string, any>> = (ctx: {
+    lang: string;
+    draft: boolean;
+    inBuilder: boolean;
+    pageProps: ChaiPageProps;
+}) => Promise<T>;
+/**
+ * Block data provider function
+ */
+type ChaiBlockDataProvider = (ctx: {
+    block: any;
+    lang: string;
+    draft: boolean;
+    inBuilder: boolean;
+    pageProps: any;
+}) => Promise<any>;
+/**
+ * Trash entry
+ */
+type ChaiTrashEntry = ChaiTrashableEntity;
+/** 0 = off (default), 1 = DB + HTTP + cache + AI summary, 2 = + API/action timing + full SQL + AI verbose (prompts, tools, tokens) */
+type ChaiDebugLevel = 0 | 1 | 2;
+
+type ChaiBaseSlugEntry = {
+    slug: string;
+    lang: string;
+    pageId: string;
+    primaryPageId: string | null;
+    dynamicSlugCustom: string | null;
+};
+
+type ChaiWebsiteSetting = {
+    appKey: string;
+    fallbackLang: string;
+    languages: string[];
+    theme: ChaiTheme;
+    settings: Record<string, any>;
+    designTokens: ChaiDesignTokens;
+    appChanges?: string[];
+    consentConfig?: Record<string, any>;
+    configData?: Record<string, any>;
+};
+type ChaiPageSeo = {
+    title?: string;
+    description?: string;
+    ogTitle?: string;
+    ogDescription?: string;
+    ogImage?: string;
+    canonicalUrl?: string;
+    noIndex?: boolean;
+    noFollow?: boolean;
+    jsonLD?: string;
+};
+type ChaiPage = {
+    id: string;
+    slug: string;
+    lang: string;
+    name: string;
+    pageType: string;
+    blocks: ChaiBlock[];
+    createdAt: string;
+    lastSaved: string;
+    dynamic: boolean;
+    online: boolean;
+    seo: ChaiPageSeo;
+    app: string;
+    primaryPage?: string | null;
+    currentEditor?: string | null;
+    changes: object[];
+    parent?: string | null;
+    libRefId?: string | null;
+    dynamicSlugCustom?: string | null;
+    metadata?: object;
+    jsonld?: object;
+    globalJsonLds?: string[];
+    links?: string;
+    partialBlocks?: string;
+    designTokens?: ChaiDesignTokens;
+    tracking?: Record<string, any> | null;
+};
+type ChaiPageType = {
+    key: string;
+    helpText?: string;
+    description?: string;
+    hasSlug?: boolean;
+    icon?: string;
+    name: string | (() => Promise<string>);
+    pluralName?: string | (() => Promise<string>);
+    dynamicSegments?: string;
+    dynamicSlug?: string;
+    getDynamicPages?: ({ query, slug, lang, }: {
+        query?: string;
+        slug?: string;
+        lang: string;
+    }) => Promise<Pick<ChaiPage, "id" | "name" | "slug" | "primaryPage">[]>;
+    search?: (query: string) => Promise<Pick<ChaiPage, "id" | "name" | "slug">[] | Error>;
+    resolveLink?: (id: string, draft?: boolean, lang?: string) => Promise<string>;
+    /**
+     * URL to open in an iframe panel when editing a dynamic page item.
+     * Use {{ID}} as placeholder for the page id.
+     * e.g. "/admin/embed/collections/posts/{{ID}}"
+     */
+    editUrl?: string;
+    /**
+     * URL to open in an iframe panel when creating a new dynamic page item.
+     * Plain URL, no placeholder needed.
+     * e.g. "/admin/embed/collections/posts/create"
+     */
+    createUrl?: string;
+    onCreate?: (data: Partial<ChaiPage> & {
+        id: string;
+    }) => Promise<void>;
+    onUpdate?: (data: Partial<ChaiPage> & {
+        id: string;
+    }) => Promise<void>;
+    onDelete?: (data: Pick<ChaiPage, "id">) => Promise<void>;
+    dataProvider?: ChaiPageTypeDataProvider;
+    defaultSeo?: () => Record<string, any>;
+    defaultJSONLD?: () => Record<string, any>;
+    defaultMetaTags?: () => Record<string, string>;
+    defaultTrackingInfo?: () => Record<string, any>;
+};
+interface ChaiLoggedInUser {
+    id: string;
+    email: string;
+    name: string;
+    avatar?: string;
+    role?: string;
+}
+type ChaiUserInfo = {
+    id: string;
+    email: string;
+    name: string;
+    avatar?: string;
+};
+type AssetsParams = {
+    search: string;
+    limit: number;
+    page: number;
+};
+type ImageConfig = {
+    lastImage?: string;
+    aspectRatio?: "1:1" | "3:4" | "4:3" | "9:16" | "16:9";
+    quality?: number;
+};
+type AIChatOptions = {
+    messages: any[];
+    image?: ImageConfig;
+    systemPrompt?: string;
+    initiator?: string | null;
+    model?: string;
+    context?: AIContext;
+    designTokens?: ChaiDesignTokens;
+    images?: string[];
+    attachments?: {
+        url?: string;
+        mediaType?: string;
+        filename?: string;
+    }[];
+    options?: Record<string, any>;
+};
+type AIContext = {
+    site?: Record<string, any>;
+    page?: Record<string, any>;
+};
+interface ChaiBuilderPagesAIInterface {
+    handleRequest(options: AIChatOptions, res: any): Promise<StreamTextResult<any, any>>;
+    isConfigured(): boolean;
+}
+
+export type { ChaiResolveSiteUrlContext as $, AIChatOptions as A, ChaiContextResolverArgs as B, ChaiAction as C, ChaiCoreBlock as D, ChaiCssVariableNameWithDefault as E, ChaiDebugLevel as F, ChaiDesignTokens as G, ChaiFont as H, ChaiFontBySrc as I, ChaiFontByUrl as J, ChaiFontSource as K, ChaiGlobalDataProvider as L, ChaiIncomingRequest as M, ChaiLibrary as N, ChaiLibraryBlock as O, ChaiLoggedInUser as P, ChaiPage$1 as Q, ChaiPage as R, ChaiPageProps as S, ChaiPageType as T, ChaiPageTypeDataProvider as U, ChaiPageTypeEntry as V, ChaiRenderBlockProps as W, ChaiRequestContext as X, ChaiRequestContextArgs as Y, ChaiRequestContextResolver as Z, ChaiRequiredPermission as _, AICompleteCallback as a, ChaiSavePageData as a0, ChaiSaveWebsiteData as a1, ChaiSiteWideUsageData as a2, ChaiSystemFont as a3, ChaiTheme as a4, ChaiThemeOptions as a5, ChaiTrashEntry as a6, ChaiTrashableEntity as a7, ChaiUserAccess as a8, ChaiUserInfo as a9, ChaiWebsiteBuilderProps as aa, ChaiWebsiteSetting as ab, CollectionConfig as ac, CollectionFetchParams as ad, ImageConfig as ae, RestoreConflictResolution as af, StructureRule as ag, TrashContext as ah, TrashRecord as ai, TrashableRecordData as aj, AIContext as b, AIErrorCallback as c, AIEvent as d, AIModel as e, AISuccessCallback as f, AssetsParams as g, ChaiActionContext as h, ChaiAskAiResponse as i, ChaiBaseSlugEntry as j, ChaiBlock as k, ChaiBlockDataProvider as l, ChaiBlockPropsSchema as m, ChaiBlockRJSFSchemas as n, ChaiBlockSchema as o, ChaiBlockSchemas as p, ChaiBlockStyles as q, ChaiBlockUiSchema as r, ChaiBorderRadiusValue as s, ChaiBreakpoint as t, ChaiBuilderEditorProps as u, ChaiBuilderPagesAIInterface as v, ChaiBuilderRouteProps as w, ChaiCollectionEntry as x, ChaiCollectoin as y, ChaiContextResolver as z };