@blinkk/root-cms 3.0.2 → 3.0.3

package/dist/core/core.d.ts

@@ -0,0 +1,5 @@
+export * from './client.js';
+export * from './route.js';
+export * from './runtime.js';
+export * as schema from './schema.js';
+export * from './translations-manager.js';

package/dist/core/cron.d.ts

@@ -0,0 +1,19 @@
+import { RootConfig } from '@blinkk/root';
+import { LoadSchemaFn } from './search-index.js';
+/**
+ * The minimum interval between incremental search-index rebuilds. The cron tick
+ * itself runs every 1 min; this throttle prevents a rebuild from kicking off on
+ * every tick.
+ */
+export declare const SEARCH_INDEX_MIN_INTERVAL_MS: number;
+export interface RunCronJobsOptions {
+    /**
+     * Optional schema loader for the search-index rebuild step. The Cloud
+     * Scheduler / functions path doesn't need this (prod uses the bundled
+     * `dist/collections/<id>.schema.json` files), but the manual
+     * `POST /cms/api/cron.run` trigger threads its request-aware loader through
+     * so dev users can rebuild without first running a full prod build.
+     */
+    loadSchema?: LoadSchemaFn;
+}
+export declare function runCronJobs(rootConfig: RootConfig, options?: RunCronJobsOptions): Promise<void>;

package/dist/core/csv.d.ts

@@ -0,0 +1,5 @@
+export declare function arrayToCsv(req: {
+    headers: string[];
+    rows: Array<Record<string, any>>;
+}): string;
+export declare function csvToArray(csvString: string): any;

package/dist/core/functions.d.ts

@@ -0,0 +1,9 @@
+import { ScheduleOptions } from 'firebase-functions/v2/scheduler';
+export interface CronOptions {
+    rootDir?: string;
+    scheduleOptions?: Partial<ScheduleOptions>;
+}
+/**
+ * Runs offline CMS tasks, such as publishing of scheduled docs.
+ */
+export declare function cron(options?: CronOptions): import("firebase-functions/scheduler").ScheduleFunction;

package/dist/core/plugin.d.ts

@@ -0,0 +1,357 @@
+import { Plugin, Request } from '@blinkk/root';
+import { App } from 'firebase-admin/app';
+import { Firestore } from 'firebase-admin/firestore';
+import { type AiConfig } from './ai.js';
+import { type CMSCheck } from './checks.js';
+import { Action } from './client.js';
+import { type CMSNotificationService } from './services-notifications.js';
+import { type CMSTranslationService } from './translations.js';
+export type { AiConfig, AiModelConfig, AiProvider } from './ai.js';
+export type { CMSCheck, CheckResult, CheckContext, CheckStatus, } from './checks.js';
+export { translationsCheck } from './checks-translations.js';
+export type { TranslationsCheckOptions } from './checks-translations.js';
+export type { CMSService, CMSServiceContext } from './services.js';
+export type { CMSNotificationService, NotificationResult, NotificationServiceContext, } from './services-notifications.js';
+export type { CMSTranslationService, TranslationExportResult, TranslationImportResult, TranslationRow, TranslationServiceContext, } from './translations.js';
+/**
+ * Built-in sidebar tools that can be toggled on/off in the CMS UI.
+ */
+export type CMSBuiltInSidebarTool = 'home' | 'content' | 'releases' | 'data' | 'assets' | 'translations' | 'ai' | 'settings';
+export interface CMSUser {
+    email: string;
+}
+/**
+ * @deprecated The `experiments.ai` flag is now used only as a sidebar toggle.
+ * Configure chat models on the top-level `ai` plugin option instead.
+ */
+export interface CMSAIConfig {
+    /** Custom API endpoint for chat prompts. */
+    endpoint?: string;
+    /** Gen AI model to use. */
+    model?: string;
+}
+/**
+ * Filters applied to the spotlight / global search indexer. By default every
+ * collection and every doc is indexed. Use these options to scope the index to
+ * a subset of the project's content.
+ *
+ * Doc ids use the `<collectionId>/<slug>` format (e.g. `Pages/about`), which
+ * matches the format used elsewhere in the CMS.
+ */
+export interface CMSSearchIndexConfig {
+    /**
+     * Collections to include in the search index. If specified, only these
+     * collections are indexed. If unset, all collections are indexed (subject to
+     * `excludeCollections`).
+     */
+    includeCollections?: string[];
+    /**
+     * Collections to exclude from the search index. Applied after
+     * `includeCollections`.
+     */
+    excludeCollections?: string[];
+    /**
+     * Doc ids to include in the search index. If specified, only these docs are
+     * indexed (within collections that pass the collection filter). Format:
+     * `<collectionId>/<slug>`.
+     */
+    includeDocIds?: string[];
+    /**
+     * Doc ids to exclude from the search index. Applied after `includeDocIds`.
+     * Format: `<collectionId>/<slug>`.
+     */
+    excludeDocIds?: string[];
+}
+export interface CMSSidebarTool {
+    /** URL for the sidebar icon image. */
+    icon?: string;
+    /** Label. */
+    label?: string;
+    /** Iframe URL to render for the tool. */
+    iframeUrl?: string;
+    /**
+     * CMS URL that should be opened when the tool is selected. The url must start
+     * with `/cms/`. Use this to create shortcuts to CMS pages instead of
+     * rendering the tool inside an iframe.
+     */
+    cmsUrl?: string;
+    /**
+     * External URL that should open in a new tab when the tool is selected.
+     */
+    externalUrl?: string;
+}
+export type CMSPluginOptions = {
+    /**
+     * The ID of the project. Data will be stored under the namespace
+     * `Projects/${id}` in firestore.
+     */
+    id?: string;
+    /**
+     * The name of the project. Used in the header of the CMS to help identify
+     * the project.
+     */
+    name?: string;
+    /**
+     * Firebase config object, which can be obtained in the Firebase Console by
+     * going to "Project Settings".
+     */
+    firebaseConfig: {
+        [key: string]: string | undefined;
+        apiKey: string;
+        authDomain: string;
+        projectId: string;
+        storageBucket: string;
+        databaseId?: string;
+    };
+    /**
+     * GAPI credentials. Include if using Google Drive and Google Sheets features.
+     * See: https://developers.google.com/sheets/api/quickstart/js
+     */
+    gapi?: {
+        /** https://developers.google.com/sheets/api/quickstart/js#create_an_api_key */
+        apiKey: string;
+        /** https://developers.google.com/sheets/api/quickstart/js#authorize_credentials_for_a_web_application */
+        clientId: string;
+    };
+    /**
+     * Secret value(s) used for signing the user authentication cookie.
+     * @deprecated This is now handled directly by root's sessionMiddleware under
+     * `server.sessionCookieSecret` in root.config.ts.
+     */
+    cookieSecret?: string | string[];
+    /** Function called to check if a user should have access to the CMS. */
+    isUserAuthorized?: (req: Request, user: CMSUser) => boolean | Promise<boolean>;
+    /**
+     * Function to call to check if login is required for a particular request.
+     */
+    isLoginRequired?: (req: Request) => boolean;
+    /**
+     * By default, iframing the CMS is disallowed. Setting this value will allow
+     * iframes from the specified origins. Example:
+     * ```
+     * allowedIframeOrigins: ['https://app.example.com']
+     * ```
+     */
+    allowedIframeOrigins?: string[];
+    /**
+     * URL to GCI service for transforming uploaded GCS images to a Google App
+     * Engine Images API serving URL.
+     *
+     * Setting this to `true` uses the default hosted service at
+     * https://services.rootjs.dev.
+     *
+     * To set up GCI:
+     *
+     * - Create a GCS bucket with fine-grained permissions
+     * - Share owner access to the bucket with the service account returned in
+     *   https://services.rootjs.dev/_/service_account
+     *
+     * To disable GCI, leave this value empty or set to `false`, which which will
+     * serve images directly from GCS instead.
+     */
+    gci?: string | boolean;
+    /**
+     * Customization options for the CMS sidebar.
+     */
+    sidebar?: {
+        /**
+         * Sidebar tools, a map of the sidebar id to config options. The sidebar
+         * tool is url-mapped to `/cms/tools/:id` and displays the tool in an
+         * iframe.
+         */
+        tools?: Record<string, CMSSidebarTool>;
+        /**
+         * Hide specific built-in sidebar tools. Hiding a tool also removes its
+         * surfaces from the CMS home page. The underlying routes remain
+         * accessible via direct URL.
+         */
+        hiddenBuiltInTools?: CMSBuiltInSidebarTool[];
+    };
+    /**
+     * URL for a custom favicon used by the CMS UI.
+     */
+    favicon?: string;
+    /**
+     * Enables minimal branding mode in the CMS header. This hides the Root CMS
+     * logo and displays the project name on the top-right.
+     */
+    minimalBranding?: boolean;
+    /**
+     * Callback when an action occurs.
+     */
+    onAction?: (action: Action) => any;
+    /**
+     * Configures the Root CMS AI chat (`/cms/ai`). Provide one or more models
+     * — the CMS proxies user requests directly to the configured providers.
+     *
+     * The shape mirrors open source tools like Ollama and LiteLLM: each entry
+     * declares the provider, model id and credentials. Keys live on the server,
+     * never on the client.
+     *
+     * Example:
+     * ```ts
+     * cmsPlugin({
+     *   ai: {
+     *     models: [
+     *       {
+     *         id: 'gpt-5.5',
+     *         label: 'GPT-5.5',
+     *         provider: 'openai',
+     *         apiKey: process.env.OPENAI_API_KEY,
+     *         capabilities: {tools: true, reasoning: true, attachments: true},
+     *       },
+     *       {
+     *         id: 'claude-opus-4-7',
+     *         label: 'Claude Opus 4.7',
+     *         provider: 'anthropic',
+     *         apiKey: process.env.ANTHROPIC_API_KEY,
+     *         capabilities: {tools: true, reasoning: true, attachments: true},
+     *       },
+     *       {
+     *         id: 'gemini-3.1-pro',
+     *         label: 'Gemini 3.1 Pro',
+     *         provider: 'gemini',
+     *         apiKey: process.env.GEMINI_API_KEY,
+     *         capabilities: {tools: true, reasoning: true, attachments: true},
+     *       },
+     *       {
+     *         id: 'llama3-local',
+     *         label: 'Llama 3 (local)',
+     *         provider: 'openai-compatible',
+     *         baseURL: 'http://localhost:11434/v1',
+     *       },
+     *     ],
+     *     defaultModel: 'gpt-4o',
+     *   },
+     * });
+     * ```
+     *
+     * For project-specific guidance (conventions, patterns, naming rules, etc.),
+     * drop a `ROOT.md` file at the project root. Its contents are appended to
+     * the system prompt for every chat — similar to `AGENTS.md` / `CLAUDE.md`.
+     */
+    ai?: AiConfig;
+    /**
+     * Experimental config options. Note: these are subject to change at any time.
+     */
+    experiments?: {
+        /**
+         * @deprecated Use the top-level `ai` config instead. Setting this to
+         * `true` keeps the AI chat icon visible in the sidebar.
+         */
+        ai?: boolean | CMSAIConfig;
+        /**
+         * Enables the v2 `TranslationsManager`.
+         */
+        v2TranslationsManager?: boolean;
+        /**
+         * Enables the task manager (sidebar entry, home page card, and
+         * `/cms/tasks` routes).
+         */
+        taskManager?: boolean;
+    };
+    /**
+     * Adjust console output verbosity. Default is `'info'`.
+     */
+    logLevel?: 'info' | 'warn' | 'error' | 'silent' | 'debug';
+    /**
+     * Whether to enable/disable file watching in dev (e.g. for generating
+     * `root-cms.d.ts`). Defaults to `true`.
+     */
+    watch?: boolean;
+    /** Options associated with the preview. */
+    preview?: {
+        /**
+         * Whether to send messages to the preview iframe, handle messages from
+         * the preview iframe, enable both (`true`), or disable messages entirely
+         * (`false`). If unspecified, the default is `false`.
+         */
+        channel: boolean | 'to-preview' | 'from-preview';
+    };
+    /**
+     * Checks that can be run on-demand from the CMS UI to validate document
+     * content. Each check defines a server-side function that returns a
+     * success/warning/error result with a markdown message.
+     *
+     * Example:
+     * ```ts
+     * cmsPlugin({
+     *   checks: [
+     *     {
+     *       id: 'my-check',
+     *       label: 'My Check',
+     *       run: async (ctx) => {
+     *         return {status: 'success', message: 'All good!'};
+     *       },
+     *     },
+     *   ],
+     * });
+     * ```
+     *
+     * NOTE: The checks feature is considered a "beta" feature, its interface
+     * may change from version to version as we add new features.
+     */
+    checks?: CMSCheck[];
+    /**
+     * Translation services that appear in the Localization modal's Import and
+     * Export menus. Each service defines server-side import/export functions
+     * that integrate with an external translation platform (e.g. Crowdin).
+     *
+     * Example:
+     * ```ts
+     * cmsPlugin({
+     *   translations: [
+     *     {
+     *       id: 'crowdin',
+     *       label: 'Crowdin',
+     *       onImport: async (ctx, data) => { ... },
+     *       onExport: async (ctx, data) => { ... },
+     *     },
+     *   ],
+     * });
+     * ```
+     */
+    translations?: CMSTranslationService[];
+    /**
+     * Notification services that react to CMS actions and dispatch them to
+     * external channels (email, Slack, webhooks, etc.). Each service defines
+     * an optional server-side `onAction` handler.
+     *
+     * Example:
+     * ```ts
+     * cmsPlugin({
+     *   notifications: [
+     *     {
+     *       id: 'sendgrid',
+     *       label: 'SendGrid',
+     *       onAction: async (ctx, action) => {
+     *         if (action.action === 'doc.publish') {
+     *           await sendgrid.send({ ... });
+     *         }
+     *       },
+     *     },
+     *   ],
+     * });
+     * ```
+     */
+    notifications?: CMSNotificationService[];
+    /**
+     * Configuration for the spotlight / global search indexer. Use this to
+     * include or exclude specific collections or docs from being indexed.
+     */
+    searchIndex?: CMSSearchIndexConfig;
+    /**
+     * Default UI variant for `oneOf` fields. Individual fields can still
+     * override this by setting their own `variant`. Defaults to `'dropdown'`.
+     */
+    defaultOneOfVariant?: 'dropdown' | 'picker';
+};
+export type CMSPlugin = Plugin & {
+    name: 'root-cms';
+    getConfig: () => CMSPluginOptions;
+    getFirebaseApp: () => App;
+    getFirestore: (options?: {
+        databaseId?: string;
+    }) => Firestore;
+};
+export declare function cmsPlugin(options: CMSPluginOptions): CMSPlugin;

package/dist/{project.d.ts → core/project.d.ts}

@@ -1,32 +1,30 @@
-import { S as Schema, C as Collection } from './schema-Db_xODoi.js';
-
 /**
  * Loads various files or configurations from the project.
  *
  * NOTE: This file needs to be loaded through vite's ssrLoadModule so that
  * virtual modules are resolved.
  */
-
-interface SchemaModule {
-    default: Schema;
+import * as schema from './schema.js';
+export interface SchemaModule {
+    default: schema.Schema;
 }
-declare const SCHEMA_MODULES: Record<string, SchemaModule>;
+export declare const SCHEMA_MODULES: Record<string, SchemaModule>;
 /**
  * Returns a map of all `schema.ts` files defined in the project as
  * fileId => schema. This is used by `generate-types.ts` to build the
  * `root-cms.d.ts` file.
  */
-declare function getProjectSchemas(): Record<string, Schema>;
+export declare function getProjectSchemas(): Record<string, schema.Schema>;
 /**
  * Resolves SchemaPattern objects in oneOf fields to arrays of Schema objects.
  * This is needed for type generation which expects `field.types` to be an array.
  */
-declare function resolveOneOfPatterns(schemaObj: Schema): Schema;
+export declare function resolveOneOfPatterns(schemaObj: schema.Schema): schema.Schema;
 /**
  * Returns a collection's schema definition as defined in
  * `/collections/<id>.schema.ts`.
  */
-declare function getCollectionSchema(collectionId: string): Collection | null;
+export declare function getCollectionSchema(collectionId: string): schema.Collection | null;
 /**
  * Converts all `oneof` field type definitions into a map keyed by the type
  * name. The field definitions are replaced with an array of type names.
@@ -39,6 +37,4 @@ declare function getCollectionSchema(collectionId: string): Collection | null;
  * and skipping the clone would mutate the shared entries in `SCHEMA_MODULES`
  * and corrupt subsequent calls (e.g. when building multiple collections).
  */
-declare function convertOneOfTypes(collection: Collection, schemaModules?: Record<string, SchemaModule>): Collection;
-
-export { SCHEMA_MODULES, type SchemaModule, convertOneOfTypes, getCollectionSchema, getProjectSchemas, resolveOneOfPatterns };
+export declare function convertOneOfTypes(collection: schema.Collection, schemaModules?: Record<string, SchemaModule>): schema.Collection;

package/dist/core/richtext.d.ts

@@ -0,0 +1,101 @@
+import { FunctionalComponent } from 'preact';
+export interface RichTextBlock {
+    type: string;
+    data?: any;
+}
+export interface RichTextData {
+    [key: string]: any;
+    blocks: RichTextBlock[];
+}
+export type RichTextComponent = FunctionalComponent<any>;
+export type RichTextBlockComponent = RichTextComponent;
+export type RichTextInlineComponent = RichTextComponent;
+export type RichTextComponentMap = Record<string, RichTextComponent>;
+export interface RichTextContextProps {
+    /**
+     * Rich text components override for both inline and block level components.
+     */
+    components?: RichTextComponentMap;
+    /**
+     * Translator function override.
+     */
+    t?: (msg: string, params?: Record<string, string | number>) => string;
+}
+export declare const RichTextContext: import("preact").Context<RichTextContextProps>;
+export declare function useRichTextContext(): RichTextContextProps;
+export interface RichTextProps {
+    data: RichTextData | undefined;
+    components?: Record<string, RichTextBlockComponent>;
+    /** @deprecated */
+    translate?: boolean;
+}
+/** Renders data from the "richtext" field. */
+export declare function RichText(props: RichTextProps): import("preact").JSX.Element | null;
+export declare namespace RichText {
+    var Block: (props: RichTextBlock) => import("preact").JSX.Element | null;
+    var ParagraphBlock: (props: RichTextParagraphBlockProps) => import("preact").JSX.Element | null;
+    var HeadingBlock: (props: RichTextHeadingBlockProps) => import("preact").JSX.Element | null;
+    var ListBlock: (props: RichTextListBlockProps) => import("preact").JSX.Element | null;
+    var ImageBlock: (props: RichTextImageBlockProps) => import("preact").JSX.Element | null;
+    var HtmlBlock: (props: RichTextHtmlBlockProps) => import("preact").JSX.Element | null;
+    var TableBlock: (props: RichTextTableBlockProps) => import("preact").JSX.Element | null;
+}
+export interface RichTextParagraphBlockProps {
+    type: 'paragraph';
+    data?: {
+        text?: string;
+        components?: Record<string, any>;
+    };
+}
+export interface RichTextHeadingBlockProps {
+    type: 'heading';
+    data?: {
+        level?: number;
+        text?: string;
+    };
+}
+interface ListItem {
+    content?: string;
+    items?: ListItem[];
+    components?: Record<string, any>;
+}
+export interface RichTextListBlockProps {
+    type: 'orderedList' | 'unorderedList';
+    data?: {
+        style?: 'ordered' | 'unordered';
+        items?: ListItem[];
+    };
+}
+export interface RichTextImageBlockProps {
+    type: 'image';
+    data?: {
+        /** The caption entered into the CMS Image field. */
+        caption?: string;
+        file?: {
+            url: string;
+            width: string | number;
+            height: string | number;
+            alt: string;
+        };
+    };
+}
+export interface RichTextHtmlBlockProps {
+    type: 'html';
+    data?: {
+        html?: string;
+    };
+}
+export interface RichTextTableBlockProps {
+    type: 'table';
+    data?: {
+        rows?: Array<{
+            cells: Array<{
+                blocks: RichTextBlock[];
+                type: 'header' | 'data';
+            }>;
+        }>;
+    };
+}
+/** Returns whether the rich text value is truthy. */
+export declare function testContent(data: RichTextData): boolean;
+export {};

package/dist/{core.d.ts → core/route.d.ts}

@@ -1,10 +1,3 @@
-import { R as RootCMSClient, D as DocMode, L as LoadTranslationsOptions, T as TranslationsMap, a as LocaleTranslations } from './client-1puwLgNx.js';
-export { A as Action, r as ArrayObject, F as BatchRequest, B as BatchRequestOptions, y as BatchRequestQuery, z as BatchRequestQueryOptions, I as BatchResponse, C as CronUnit, d as DataSource, c as DataSourceCron, e as DataSourceData, f as DataSourceMode, b as Doc, j as GetCountOptions, G as GetDocOptions, H as HttpMethod, m as ListActionsOptions, i as ListDocsOptions, J as Locale, Q as MultiLocaleTranslationsMap, l as Release, g as SaveDraftOptions, S as SetDocOptions, V as SingleLocaleTranslationsMap, K as SourceString, M as TranslatedString, k as Translation, E as TranslationsDoc, N as TranslationsDocMode, P as TranslationsLocaleDocEntry, O as TranslationsLocaleDocHashMap, W as TranslationsManager, h as UpdateDraftOptions, U as UserRole, X as buildTranslationsDbPath, Y as buildTranslationsLocaleDocDbPath, o as getCmsPlugin, n as isRichTextData, s as marshalArray, p as marshalData, q as normalizeData, x as parseDocId, t as toArrayObject, w as translationsForLocale, v as unmarshalArray, u as unmarshalData } from './client-1puwLgNx.js';
-import { Request, RootConfig, Response, RouteParams, GetStaticProps, GetStaticPaths } from '@blinkk/root';
-import { Query } from 'firebase-admin/firestore';
-export { s as schema } from './schema-Db_xODoi.js';
-import 'firebase-admin/app';
-
 /**
  * Utility for creating Root filesystem routes that are connected to a CMS doc.
  *
@@ -30,8 +23,9 @@ import 'firebase-admin/app';
  * export const {getStaticProps, getStaticPaths} = createRoute({collection: 'BlogPosts'});
  * ```
  */
-
-interface RootCMSDoc<Fields = any> {
+import { GetStaticPaths, GetStaticProps, Request, Response, RootConfig, RouteParams } from '@blinkk/root';
+import { DocMode, RootCMSClient } from './client.js';
+export interface RootCMSDoc<Fields = any> {
     /** The id of the doc, e.g. "Pages/foo-bar". */
     id: string;
     /** The collection id of the doc, e.g. "Pages". */
@@ -53,12 +47,12 @@ interface RootCMSDoc<Fields = any> {
     /** User-entered field values from the CMS. */
     fields?: Fields;
 }
-type RouteRequest = Request & {
+export type RouteRequest = Request & {
     rootConfig: RootConfig;
     cmsClient: RootCMSClient;
 };
-type RouteResponse = Response;
-interface RouteContext {
+export type RouteResponse = Response;
+export interface RouteContext {
     /**
      * HTTP request object. Only available in SSR mode.
      */
@@ -80,7 +74,7 @@ interface RouteContext {
      */
     params: RouteParams;
 }
-interface Route {
+export interface Route {
     /**
      * SSR handler.
      */
@@ -94,7 +88,7 @@ interface Route {
      */
     getStaticPaths?: GetStaticPaths;
 }
-interface CreateRouteOptions {
+export interface CreateRouteOptions {
     /**
      * Collection mapped to the route.
      */
@@ -171,67 +165,20 @@ interface CreateRouteOptions {
 /**
  * Utility for creating Root filesystem routes that are connected to a CMS doc.
  */
-declare function createRoute(options: CreateRouteOptions): Route;
-declare function resolvePromisesMap(promisesMap: Record<string, Promise<any>>): Promise<Record<string, any>>;
+export declare function createRoute(options: CreateRouteOptions): Route;
+export declare function resolvePromisesMap(promisesMap: Record<string, Promise<any>>): Promise<Record<string, any>>;
 /**
  * Returns the first query param value in a given request.
  *
  * For example, for a URL like `/?foo=bar&foo=baz`, calling
  * `getFirstQueryParam(req, 'foo')` would return `"bar"`.
  */
-declare function getFirstQueryParam(req: Request, key: string): string | null;
+export declare function getFirstQueryParam(req: Request, key: string): string | null;
 /**
  * Issues an HTTP redirect, preserving any query params from the original req.
  */
-declare function redirectWithQuery(req: Request, res: Response, redirectCode: number, redirectPath: string): void;
+export declare function redirectWithQuery(req: Request, res: Response, redirectCode: number, redirectPath: string): void;
 /**
  * Returns the CMS document mode associated with the request.
  */
-declare function getMode(req: Request): Promise<DocMode>;
-
-/** @deprecated Use client.ts instead. */
-
-/**
- * Retrieves a doc from Root.js CMS.
- * @deprecated Use RootCMSClient.getDoc() instead.
- */
-declare function getDoc<T>(rootConfig: RootConfig, collectionId: string, slug: string, options: {
-    mode: 'draft' | 'published';
-}): Promise<T | null>;
-/**
- * Lists docs from a Root.js CMS collection.
- * @deprecated Use RootCMSClient.listDocs() instead.
- */
-declare function listDocs<T>(rootConfig: RootConfig, collectionId: string, options: {
-    mode: 'draft' | 'published';
-    offset?: number;
-    limit?: number;
-    orderBy?: string;
-    orderByDirection?: 'asc' | 'desc';
-    query?: (query: Query) => Query;
-}): Promise<{
-    docs: T[];
-}>;
-/**
- * Returns the number of docs in a Root.js CMS collection.
- * @deprecated Use RootCMSClient.getDocsCount() instead.
- */
-declare function numDocs(rootConfig: RootConfig, collectionId: string, options: {
-    mode: 'draft' | 'published';
-    query?: (query: Query) => Query;
-}): Promise<number>;
-/**
- * Publishes scheduled docs.
- * @deprecated Use RootCMSClient.publishScheduledDocs() instead.
- */
-declare function publishScheduledDocs(rootConfig: RootConfig): Promise<any[]>;
-/**
- * @deprecated Use `RootCMSClient.loadTranslations()`.
- */
-declare function loadTranslations(rootConfig: RootConfig, options?: LoadTranslationsOptions): Promise<TranslationsMap>;
-/**
- * @deprecated Use `RootCMSClient.loadTranslationsForLocale()`.
- */
-declare function loadTranslationsForLocale(rootConfig: RootConfig, locale: string, options?: LoadTranslationsOptions): Promise<LocaleTranslations>;
-
-export { type CreateRouteOptions, DocMode, LoadTranslationsOptions, LocaleTranslations, RootCMSClient, type RootCMSDoc, type Route, type RouteContext, type RouteRequest, type RouteResponse, TranslationsMap, createRoute, getDoc, getFirstQueryParam, getMode, listDocs, loadTranslations, loadTranslationsForLocale, numDocs, publishScheduledDocs, redirectWithQuery, resolvePromisesMap };
+export declare function getMode(req: Request): Promise<DocMode>;