chaipro 0.1.0

package/dist/payload.d.cts

@@ -0,0 +1,603 @@
+import * as payload from 'payload';
+import { PayloadRequest, Plugin, Field, CollectionConfig, Access, SanitizedConfig, Where, Payload, CollectionSlug } from 'payload';
+import { h as ResolvedChaiBuilderServerConfig, C as ChaiBuilderServerConfigInput } from './server-config-b29G6_aQ.cjs';
+import { M as ChaiIncomingRequest, L as ChaiGlobalDataProvider, V as ChaiPageTypeEntry, a6 as ChaiTrashEntry, C as ChaiAction, a7 as ChaiTrashableEntity } from './actions-DM00SIUk.cjs';
+import { B as BuildChaiBuilderConfigOptions, C as ChaiBaseAction } from './build-config-DrerOPd9.cjs';
+import { z } from 'zod';
+import 'ai';
+import './core-BNe4bA6z.cjs';
+import 'drizzle-orm/pg-core';
+import '@rjsf/utils';
+import 'react';
+
+/**
+ * Resolves the multi-app (tenant) id. Optionally request-aware so hosts can
+ * derive the id from headers/domain/user instead of a fixed env value.
+ */
+type GetAppId = (args?: {
+    req?: PayloadRequest;
+}) => string | Promise<string>;
+/**
+ * Default app id from env. Hosts may override via {@link registerAppIdResolver}
+ * (set by {@link chaiBuilderPlugin}) or {@link configureChaiPayload} when the id
+ * comes from elsewhere.
+ */
+declare function defaultGetAppId(): string;
+/** Register the host app-id resolver. `undefined` leaves the env default in place. */
+declare function registerAppIdResolver(resolver: GetAppId | undefined): void;
+/**
+ * Single source of the app id for fields, access, filterOptions, menus, and the
+ * builder runtime fallback. Pass `req` where available so a request-aware
+ * resolver can use it.
+ */
+declare function resolveAppId(args?: {
+    req?: PayloadRequest;
+}): string | Promise<string>;
+
+type ChaiBuilderPluginOptions = {
+    /** Multi-app scoping field name injected onto scoped collections. Default `'app'`. */
+    appField?: string;
+    /**
+     * Collection slugs that receive the ChaiBuilder fields (iframe UI + `app` field),
+     * app-scoped access, and relationship filterOptions (AND-ed with any host
+     * access). Menus always gets these.
+     */
+    appCollections?: string[];
+    /**
+     * App-id resolver. Registered process-wide for fields, access, filterOptions,
+     * menus, and the builder runtime. Defaults to env `CHAIBUILDER_APP_KEY`.
+     */
+    getAppId?: GetAppId;
+    /** Show the Menus collection in the Payload admin nav (collection always registered). Default `false`. */
+    menus?: boolean;
+    /** Payload collections that back Chai page types — revalidate hooks are auto-attached. */
+    revalidateCollections?: string[];
+    /** Slug of the media collection backing the builder asset manager. */
+    mediaSlug?: string;
+};
+/**
+ * Payload plugin wiring ChaiBuilder concerns into the Payload config:
+ * - registers the host `getAppId` resolver process-wide
+ * - always registers the Menus collection (`menus` only toggles admin visibility)
+ * - injects iframe + `app` fields onto `appCollections` (and Menus)
+ * - AND-s app-scoped access + relationship filterOptions onto those collections
+ * - attaches publish revalidation hooks to the listed page-type collections
+ * - validates the adapter contract (media collection present, app scoping
+ *   field on revalidated collections) with early, explicit errors
+ *
+ * Note: the drizzle schema merge cannot live in a plugin (it must exist at
+ * adapter creation) — see `chaiBuilderSchemaHook`. The shared-pool postgres
+ * adapter is host infrastructure and lives in the host app (`@/db`).
+ */
+declare function chaiBuilderPlugin(options?: ChaiBuilderPluginOptions): Plugin;
+
+/**
+ * Shared fields prepended onto app-scoped Payload collections by
+ * {@link chaiBuilderPlugin} via `appCollections`:
+ * - iframe save/close bridge UI (embed admin)
+ * - hidden multi-app `app` scoping field (name configurable via `appField`)
+ */
+declare function createChaiBuilderFields(opts?: {
+    appField?: string;
+}): Field[];
+/** Default instance (app field named `app`). Used by the Menus collection. */
+declare const chaiBuilderFields: Field[];
+
+/**
+ * Wrap an access function so results are always AND-ed with the app filter.
+ * `false` stays denied; `true` becomes the app Where; Where clauses are merged.
+ */
+declare function withAppIdAccess(access: Access | undefined, appField?: string): Access;
+/**
+ * Admin list + Lexical internal-link picker filter for the current app.
+ * Access alone is not enough here — Payload applies `admin.baseFilter` in the
+ * list view and relationship pickers (same pattern as the multi-tenant plugin).
+ */
+declare function withAppBaseFilter(collection: CollectionConfig, appField?: string): CollectionConfig;
+/**
+ * Allow create only when this app has no row yet (singleton per app).
+ * Use for collections like `site-config` that are one doc per tenant.
+ */
+declare function createAppScopedSingletonCreate(collection: string, options?: {
+    appField?: string;
+    /** Role gate before the singleton check. Defaults to authenticated. */
+    roleAccess?: Access;
+}): Access;
+/**
+ * Default multi-app access for app-scoped collections.
+ * - create: authenticated
+ * - read/update/delete: constrained to current app
+ * - anonymous read: published-only when `drafts` is true
+ */
+declare function createAppScopedAccess(options?: {
+    appField?: string;
+    /** When true, anonymous reads are limited to `_status: published`. */
+    drafts?: boolean;
+}): NonNullable<CollectionConfig['access']>;
+/**
+ * Ensure collection access always filters by app on read/update/delete.
+ * Preserves host create/read/update/delete logic when present; AND-s app scope.
+ */
+declare function withAppScopedAccess(collection: CollectionConfig, appField?: string): CollectionConfig;
+
+/**
+ * Inject app-scoped `filterOptions` onto every relationship/upload field in a
+ * collection whose target is an app-scoped collection. Recurses through
+ * rows/groups/collapsibles/arrays, tabs, and blocks.
+ */
+declare function injectAppFilterOptions(collection: CollectionConfig, opts: {
+    appField: string;
+    appSlugs: ReadonlySet<string>;
+}): CollectionConfig;
+
+/**
+ * Structural shape of Payload `@payloadcms/db-postgres` `beforeSchemaInit` schema.
+ * Defined locally so DTS build works without the optional peer installed.
+ */
+type PayloadDrizzleSchema = {
+    tables: Record<string, unknown>;
+    relations: Record<string, unknown>;
+    [key: string]: unknown;
+};
+type ChaiBuilderSchemaHook = (args: {
+    schema: PayloadDrizzleSchema;
+}) => PayloadDrizzleSchema | Promise<PayloadDrizzleSchema>;
+/** Merges ChaiBuilder tables into Payload's Drizzle schema for migrations/push. */
+declare const chaiBuilderSchemaHook: ChaiBuilderSchemaHook;
+
+type MenusCollectionOptions = {
+    /** Collection slug (default 'menus'). */
+    slug?: string;
+    /** Show in admin nav. Default true when called standalone. */
+    showInAdmin?: boolean;
+    /** App-scoped access control. Defaults to app-scoped staff access. */
+    access?: {
+        create?: Access;
+        read?: Access;
+        update?: Access;
+        delete?: Access;
+    };
+    /**
+     * Cross-cutting fields prepended to the collection.
+     * Defaults to {@link chaiBuilderFields} (iframe UI + `app`).
+     */
+    commonFields?: Field[];
+};
+/**
+ * Builds the ChaiBuilder Menus collection. Always registered by
+ * {@link chaiBuilderPlugin}; `showInAdmin` only toggles admin nav visibility.
+ */
+declare function createMenusCollection(options?: MenusCollectionOptions): CollectionConfig;
+
+declare const menuItemsField: Field;
+
+type MenuItemChild = {
+    type?: string | null;
+    label?: string | null;
+    url?: string | null;
+    openInNewTab?: boolean | null;
+    icon?: string | null;
+};
+type MenuItem = MenuItemChild & {
+    type?: string | null;
+    children?: MenuItemChild[] | null;
+};
+declare function validateMenuItems(items: MenuItem[] | null | undefined): string | true;
+
+type MenuPageOption = {
+    id: string;
+    name: string;
+    slug: string;
+};
+
+type RevalidateCollectionItemArgs = {
+    /** Page type / Payload collection slug (e.g. "blog"). */
+    pageType: string;
+    /** Collection item slug (not full URL). */
+    itemSlug: string;
+    /** Payload locale when localized; filters template bases by lang. */
+    lang?: string;
+};
+declare function revalidateCollectionItem(config: ResolvedChaiBuilderServerConfig, { pageType, itemSlug, lang }: RevalidateCollectionItemArgs): Promise<{
+    paths: string[];
+    tags: string[];
+}>;
+
+/**
+ * Runtime Payload capabilities injected by the host app.
+ *
+ * INVARIANT: this module (and everything under `~/payload`) must only use
+ * `import type` from `payload` / `@payloadcms/*` at the top level. Runtime
+ * `getPayload` is lazy-imported from the host's peer copy inside
+ * {@link configureChaiPayload}. Never add a static `import { getPayload }` —
+ * a nested node_modules copy would create dual-module-instance bugs.
+ */
+type ChaiPayloadDeps = {
+    /** Host Payload config (or promise). Used to call `getPayload({ config })`. */
+    config: Promise<SanitizedConfig> | SanitizedConfig;
+    /** Multi-tenant app id. Defaults to the registered resolver (env `CHAIBUILDER_APP_KEY`). */
+    getAppId?: () => string | Promise<string>;
+    /** Builds admin URLs. Defaults to `defaultAdminUrl` (env `PAYLOAD_ADMIN_ROUTE`). */
+    adminUrl?: (...segments: string[]) => string;
+    /** URL post-processing for media (cache-bust). Defaults to `defaultGetMediaUrl`. */
+    getMediaUrl?: (url: string | null | undefined, cacheTag?: string | null) => string;
+    /** Rich text -> HTML. Defaults to lazy `@payloadcms/richtext-lexical/html-async`. */
+    richTextToHTML?: (value: unknown) => Promise<unknown>;
+    /** Collection-slug conventions (NOT collection definitions). */
+    slugs?: {
+        media?: string;
+        users?: string;
+    };
+    /** Multi-tenant scoping field name on collections. */
+    appField?: string;
+};
+type ResolvedChaiPayloadDeps = {
+    getPayload: () => Promise<Payload>;
+    getAppId: () => string | Promise<string>;
+    adminUrl: (...segments: string[]) => string;
+    getMediaUrl: (url: string | null | undefined, cacheTag?: string | null) => string;
+    richTextToHTML: (value: unknown) => Promise<unknown>;
+    appField: string;
+    slugs: {
+        media: string;
+        users: string;
+    };
+};
+/**
+ * Structural shape of a Payload media doc — stands in for the host's generated
+ * `Media` type, which cannot be imported here.
+ */
+type PayloadMediaLike = {
+    id: string | number;
+    alt?: unknown;
+    url?: string | null;
+    thumbnailURL?: string | null;
+    filename?: string | null;
+    mimeType?: string | null;
+    filesize?: number | null;
+    width?: number | null;
+    height?: number | null;
+    createdAt: string;
+    updatedAt: string;
+    app?: string | null;
+    deletedAt?: string | null;
+};
+/** Scope a Payload `where` clause to the given app (multi-tenant filter). */
+declare function appWhere(appId: string, extra?: Where, appField?: string): Where;
+
+type GetMediaUrl$1 = (url: string | null | undefined, cacheTag?: string | null) => string;
+type ChaiDamAsset = {
+    id: string;
+    name: string;
+    url: string;
+    type: string;
+    size: number;
+    width?: number;
+    height?: number;
+    format?: string;
+    thumbnailUrl?: string;
+    description?: Record<string, string>;
+    createdAt: string;
+    updatedAt: string;
+};
+declare function appendCacheBust(url: string | null | undefined, updatedAt: string, getMediaUrl?: GetMediaUrl$1): string;
+declare function mapPayloadMediaToDamAsset(doc: PayloadMediaLike, descriptionByLocale?: Record<string, string>, getMediaUrl?: GetMediaUrl$1): ChaiDamAsset;
+
+/**
+ * Check if a collection has a slug field
+ */
+declare function hasSlugField(fields: Field[]): boolean;
+/**
+ * Resolve collection name and plural name
+ */
+declare function resolveName(collection: CollectionConfig): {
+    name: string;
+    pluralName: string;
+};
+/**
+ * Payload page type adapter options
+ */
+type PayloadPageTypeOptions = {
+    name?: string;
+    pluralName?: string;
+    icon?: string;
+    helpText?: string;
+    dynamicSegments?: string;
+    dataProviderDepth?: number;
+};
+
+/**
+ * Payload-auth backed user identity resolution for the ChaiBuilder context
+ * resolver. The host wires this into its `setChaiContextResolver` call — this
+ * module stays free of `next/headers` (host resolves cookies/draftMode itself).
+ */
+declare function createPayloadUserResolver({ getPayload, cookieName, }: {
+    getPayload: () => Promise<Payload>;
+    cookieName?: string;
+}): {
+    userIdFromToken: (token: string | undefined | null) => Promise<string | null>;
+    userIdFromRequest: (request: ChaiIncomingRequest) => Promise<string | null>;
+    cookieName: string;
+};
+
+type GetMediaUrl = (url: string | null | undefined, cacheTag?: string | null) => string;
+declare function sanitizePayloadData(value: unknown, getMediaUrl?: GetMediaUrl): Promise<unknown>;
+
+/** Default Payload / ChaiBuilder admin base path. */
+declare const DEFAULT_ADMIN_ROUTE = "/admin";
+/**
+ * Normalize and validate a custom admin route from env (no leading slash).
+ * Any path is allowed; must be at least 4 characters.
+ */
+declare function parseAdminRoute(raw?: string | null): string;
+/** Resolved admin base path from env (server + client). */
+declare function getAdminRoute(): string;
+/** Join admin base path with optional segments. */
+declare function defaultAdminUrl(...segments: string[]): string;
+
+/**
+ * Processes media resource URL to ensure proper formatting
+ * @param url The original URL from the resource
+ * @param cacheTag Optional cache tag to append to the URL
+ * @returns Properly formatted URL with cache tag if provided
+ *
+ * Local paths (e.g. `/api/media/file/image.webp`) are kept relative so
+ * Next.js image optimization treats them as local rather than fetching
+ * through `remotePatterns`, which blocks private IPs since Next.js 16.
+ */
+declare const defaultGetMediaUrl: (url: string | null | undefined, cacheTag?: string | null) => string;
+
+declare const transformRichTextToHTML: (value: unknown) => Promise<unknown>;
+
+/** Payload collection + page-type options for {@link buildChaiBuilderConfig}. */
+type PayloadPageTypeConfig = PayloadPageTypeOptions & {
+    collection: CollectionConfig;
+    /** Adapt as a partial type instead of a page type. */
+    partial?: boolean;
+};
+type ChaiPayloadBuilderConfigInput = Omit<ChaiBuilderServerConfigInput, 'globalDataProvider' | 'trash' | 'builderActions' | 'actions' | 'pageTypes' | 'collections'> & {
+    /** Host Payload config — binds Local API via {@link configureChaiPayload}. */
+    payloadConfig: ChaiPayloadDeps['config'];
+    getAppId?: ChaiPayloadDeps['getAppId'];
+    adminUrl?: ChaiPayloadDeps['adminUrl'];
+    getMediaUrl?: ChaiPayloadDeps['getMediaUrl'];
+    richTextToHTML?: ChaiPayloadDeps['richTextToHTML'];
+    slugs?: ChaiPayloadDeps['slugs'];
+    appField?: ChaiPayloadDeps['appField'];
+    /** Payload single-row collection as site-wide global data. */
+    globalProvider?: {
+        slug: CollectionSlug;
+        depth?: number;
+    };
+    /**
+     * Custom / adapted global provider. Prefer
+     * `asChaiBuilderGlobalProvider({ slug })` — safe to call before configure
+     * (deferred until this builder runs).
+     */
+    globalDataProvider?: ChaiGlobalDataProvider;
+    /**
+     * Payload collections as page types. Adapted after `payloadConfig` binds.
+     * Use `{ collection, partial: true, …opts }` for partial types, or
+     * `asChaiBuilderPartialType(collection, opts)` (deferred-safe).
+     */
+    pageTypes?: Array<PayloadPageTypeConfig | ChaiPageTypeEntry>;
+    /**
+     * Payload collections as ChaiBuilder data-source collections.
+     * Adapted after `payloadConfig` binds.
+     */
+    collections?: CollectionConfig[];
+    trash?: ChaiTrashEntry[];
+    /** Include Payload media soft-delete trash entity. Default `true`. */
+    assetTrash?: boolean;
+    builderActions?: Record<string, ChaiAction<any, any>>;
+    actions?: Record<string, ChaiAction<any, any>>;
+    /** Merge `GET_CHAI_USER` action. Default `true`. */
+    includeUserActions?: boolean;
+    /** Merge DAM asset CRUD actions. Default `true`. */
+    includeAssetActions?: boolean;
+};
+/**
+ * Payload-aware `buildChaiBuilderConfig`. Configures payload adapters first,
+ * adapts Payload collections into page types / collections, then delegates to core.
+ *
+ * Keeps all Payload wiring inside `~/payload` — core stays CMS-agnostic.
+ */
+declare function buildChaiBuilderConfig<TExtra extends Record<string, unknown> = Record<never, never>>(input: ChaiPayloadBuilderConfigInput, options?: BuildChaiBuilderConfigOptions<TExtra>): Readonly<ResolvedChaiBuilderServerConfig & TExtra>;
+
+declare class PayloadAssets {
+    private deps;
+    private appId;
+    private userId;
+    private payloadInstance;
+    constructor(deps: ResolvedChaiPayloadDeps, appId: string, userId: string);
+    private getPayload;
+    private get mediaSlug();
+    private getUser;
+    private baseWhere;
+    private getBufferFromBase64;
+    private getMimeType;
+    private sanitizeName;
+    private toDamAsset;
+    list({ search, page, limit }: {
+        search?: string;
+        page?: number;
+        limit?: number;
+    }): Promise<{
+        assets: ChaiDamAsset[];
+        total: number;
+        page: number;
+        pageSize: number;
+    }>;
+    getById(id: string): Promise<ChaiDamAsset>;
+    create({ name, file, description, }: {
+        name: string;
+        file: string;
+        description?: Record<string, string>;
+    }): Promise<ChaiDamAsset>;
+    update({ id, file, description, }: {
+        id: string;
+        file?: string;
+        description?: Record<string, string>;
+    }): Promise<ChaiDamAsset>;
+    deleteMany(ids: string[]): Promise<{
+        success: boolean;
+    }>;
+    softDelete(id: string): Promise<payload.JsonObject & payload.TypeWithID>;
+    restore(id: string): Promise<payload.JsonObject & payload.TypeWithID>;
+    deletePermanently(id: string): Promise<{
+        success: boolean;
+    }>;
+}
+
+declare const GetAssetsSchema: z.ZodObject<{
+    search: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>;
+declare const GetAssetSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+declare const CreateAssetSchema: z.ZodObject<{
+    name: z.ZodString;
+    file: z.ZodString;
+    folderId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    description: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    optimize: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+declare const UpdateAssetSchema: z.ZodObject<{
+    id: z.ZodString;
+    file: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+declare const DeleteAssetSchema: z.ZodObject<{
+    ids: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type GetAssetsInput = z.infer<typeof GetAssetsSchema>;
+type GetAssetInput = z.infer<typeof GetAssetSchema>;
+type CreateAssetInput = z.infer<typeof CreateAssetSchema>;
+type UpdateAssetInput = z.infer<typeof UpdateAssetSchema>;
+type DeleteAssetInput = z.infer<typeof DeleteAssetSchema>;
+declare abstract class PayloadAssetBaseAction<T> extends ChaiBaseAction<T> {
+    protected deps: ResolvedChaiPayloadDeps;
+    constructor(deps: ResolvedChaiPayloadDeps);
+    protected getAssets(): PayloadAssets;
+}
+declare class PayloadGetAssetsAction extends PayloadAssetBaseAction<GetAssetsInput> {
+    protected getValidationSchema(): z.ZodObject<{
+        search: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, z.core.$strip>;
+    execute(data: GetAssetsInput): Promise<{
+        assets: ChaiDamAsset[];
+        total: number;
+        page: number;
+        pageSize: number;
+    }>;
+}
+declare class PayloadGetAssetAction extends PayloadAssetBaseAction<GetAssetInput> {
+    protected getValidationSchema(): z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>;
+    execute(data: GetAssetInput): Promise<ChaiDamAsset>;
+}
+declare class PayloadCreateAssetAction extends PayloadAssetBaseAction<CreateAssetInput> {
+    protected getValidationSchema(): z.ZodObject<{
+        name: z.ZodString;
+        file: z.ZodString;
+        folderId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        description: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        optimize: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, z.core.$strip>;
+    execute(data: CreateAssetInput): Promise<ChaiDamAsset>;
+}
+declare class PayloadUpdateAssetAction extends PayloadAssetBaseAction<UpdateAssetInput> {
+    protected getValidationSchema(): z.ZodObject<{
+        id: z.ZodString;
+        file: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>;
+    execute(data: UpdateAssetInput): Promise<ChaiDamAsset>;
+}
+declare class PayloadDeleteAssetAction extends PayloadAssetBaseAction<DeleteAssetInput> {
+    protected getValidationSchema(): z.ZodObject<{
+        ids: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    execute(data: DeleteAssetInput): Promise<{
+        success: boolean;
+    }>;
+}
+/** Ready-to-spread `builderActions` entries for asset CRUD. */
+declare function createAssetActions(deps: ResolvedChaiPayloadDeps): {
+    GET_ASSETS: PayloadGetAssetsAction;
+    GET_ASSET: PayloadGetAssetAction;
+    CREATE_ASSET: PayloadCreateAssetAction;
+    UPDATE_ASSET: PayloadUpdateAssetAction;
+    DELETE_ASSET: PayloadDeleteAssetAction;
+};
+
+declare const GetChaiUserSchema: z.ZodObject<{
+    userId: z.ZodString;
+}, z.core.$strip>;
+type GetChaiUserInput = z.infer<typeof GetChaiUserSchema>;
+type GetChaiUserResponse = {
+    data: {
+        id: string;
+        name: string;
+        email: string;
+        avatar: string;
+    };
+};
+/**
+ * Resolves ChaiBuilder user info (for the editor avatar / presence) from the
+ * Payload users collection. Payload users carry no name/avatar by default, so
+ * `name` falls back to the email and `avatar` is empty.
+ */
+declare class PayloadGetChaiUserAction extends ChaiBaseAction<GetChaiUserInput, GetChaiUserResponse> {
+    private deps;
+    constructor(deps: ResolvedChaiPayloadDeps);
+    protected getValidationSchema(): z.ZodObject<{
+        userId: z.ZodString;
+    }, z.core.$strip>;
+    execute(data: GetChaiUserInput): Promise<GetChaiUserResponse>;
+}
+/** Ready-to-spread builder user actions. */
+declare function createUserActions(deps: ResolvedChaiPayloadDeps): {
+    GET_CHAI_USER: PayloadGetChaiUserAction;
+};
+
+/**
+ * Process-wide Payload adapter runtime. Separated from the barrel so
+ * {@link buildChaiBuilderConfig} can import without a circular graph.
+ *
+ * `asChaiBuilderGlobalProvider` / `asChaiBuilderPartialType` may be called while
+ * building the `buildChaiBuilderConfig({…})` argument object — before configure
+ * runs. In that case they return a deferred marker; {@link resolveDeferred*}
+ * materializes them after configure.
+ *
+ * Page types + collections are passed as Payload `CollectionConfig`s on
+ * `buildChaiBuilderConfig` and adapted after configure (no wrapper helpers).
+ */
+
+/**
+ * Bind the host's Payload config to the ChaiBuilder payload adapters.
+ * Prefer {@link buildChaiBuilderConfig} which calls this automatically.
+ */
+declare function configureChaiPayload(payloadDeps: ChaiPayloadDeps): void;
+/** Convert a Payload collection into a ChaiBuilder partial type. */
+declare function asChaiBuilderPartialType(collection: CollectionConfig, opts?: PayloadPageTypeOptions): ChaiPageTypeEntry;
+/** Global data provider backed by a single-row Payload collection. */
+declare function asChaiBuilderGlobalProvider(opts: {
+    slug: CollectionSlug;
+    depth?: number;
+}): ChaiGlobalDataProvider;
+/** Payload-backed DAM asset store for the given app + user. */
+declare function chaiBuilderAssets(appId: string, userId: string): PayloadAssets;
+/** Ready-to-spread builder asset CRUD actions. */
+declare function chaiBuilderAssetActions(): ReturnType<typeof createAssetActions>;
+/** Ready-to-spread builder user actions (GET_CHAI_USER). */
+declare function chaiBuilderUserActions(): ReturnType<typeof createUserActions>;
+/** Trash entity wiring builder asset soft-delete. */
+declare function chaiBuilderAssetTrashEntity(): ChaiTrashableEntity;
+
+export { BuildChaiBuilderConfigOptions, type ChaiBuilderPluginOptions, type ChaiDamAsset, type ChaiPayloadBuilderConfigInput, type ChaiPayloadDeps, DEFAULT_ADMIN_ROUTE, type GetAppId, type MenuItem, type MenuPageOption, type MenusCollectionOptions, type PayloadMediaLike, type PayloadPageTypeConfig, type PayloadPageTypeOptions, type RevalidateCollectionItemArgs, appWhere, appendCacheBust, asChaiBuilderGlobalProvider, asChaiBuilderPartialType, buildChaiBuilderConfig, chaiBuilderAssetActions, chaiBuilderAssetTrashEntity, chaiBuilderAssets, chaiBuilderFields, chaiBuilderPlugin, chaiBuilderSchemaHook, chaiBuilderUserActions, configureChaiPayload, createAppScopedAccess, createAppScopedSingletonCreate, createChaiBuilderFields, createMenusCollection, createPayloadUserResolver, defaultAdminUrl, defaultGetAppId, defaultGetMediaUrl, getAdminRoute, hasSlugField, injectAppFilterOptions, mapPayloadMediaToDamAsset, menuItemsField, parseAdminRoute, registerAppIdResolver, resolveAppId, resolveName, revalidateCollectionItem, sanitizePayloadData, transformRichTextToHTML, validateMenuItems, withAppBaseFilter, withAppIdAccess, withAppScopedAccess };