opacacms 0.1.0

package/dist/db/d1.d.ts

@@ -0,0 +1,42 @@
+import type { D1Database } from "@cloudflare/workers-types";
+import { Kysely } from "kysely";
+import type { Collection, FindOptions, Global, PaginatedResult } from "../types";
+import { BaseDatabaseAdapter } from "./adapter";
+export declare class D1Adapter extends BaseDatabaseAdapter {
+    name: string;
+    private _rawDb;
+    private _db;
+    private _collections;
+    private _globals;
+    push: boolean;
+    migrationDir: string;
+    pushDestructive: boolean;
+    get raw(): D1Database;
+    get db(): Kysely<any>;
+    constructor(db: D1Database, options?: {
+        push?: boolean;
+        pushDestructive?: boolean;
+        migrationDir?: string;
+    });
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    unsafe(query: string, params?: unknown[]): Promise<unknown>;
+    private coerceData;
+    count(collection: string, query?: Record<string, unknown>): Promise<number>;
+    create<T extends object>(collection: string, data: Partial<T>): Promise<T>;
+    findOne<T extends object>(collection: string, query: Record<string, unknown>, tx?: any): Promise<T | null>;
+    find<T extends object>(collection: string, query?: Record<string, unknown>, options?: FindOptions): Promise<PaginatedResult<T>>;
+    update<T extends object>(collection: string, query: Record<string, unknown> | string | number, data: Partial<T>): Promise<T>;
+    updateMany<T extends object>(collection: string, query: Record<string, unknown>, data: Partial<T>): Promise<number>;
+    delete(collection: string, query: Record<string, unknown> | string | number): Promise<boolean>;
+    deleteMany(collection: string, query: Record<string, unknown>): Promise<number>;
+    findGlobal<T extends object>(slug: string): Promise<T | null>;
+    updateGlobal<T extends object>(slug: string, data: Partial<T>): Promise<T>;
+    runMigrations(): Promise<void>;
+    migrate(collections: Collection[], globals?: Global[]): Promise<void>;
+}
+export declare function createD1Adapter(db: D1Database, options?: {
+    push?: boolean;
+    pushDestructive?: boolean;
+    migrationDir?: string;
+}): D1Adapter;

package/dist/db/kysely/data-mapper.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Converts a snake_case string to camelCase.
+ */
+export declare function toCamelCase(str: string): string;
+export declare function flattenPayload(payload: any, prefix?: string, excludeKeys?: string[]): any;
+export declare function unflattenRow(row: any): any;

package/dist/db/kysely/field-mapper.d.ts

@@ -0,0 +1,22 @@
+import type { Field } from "../../types";
+export declare function toSnakeCase(str: string): string;
+/**
+ * Maps an OpacaCMS FieldType to a Kysely column data type for PostgreSQL.
+ */
+export declare function mapFieldToPostgresType(field: Field): string;
+/**
+ * Maps an OpacaCMS FieldType to a Kysely column data type for SQLite/D1.
+ */
+export declare function mapFieldToSQLiteType(field: Field): string;
+/**
+ * Recursively flattens a field list, collecting only fields with a 'name'.
+ * This skips layout fields like 'row', 'collapsible', 'tabs' while preserving their nested named fields.
+ * Group and Blocks fields are also flattened, prefixing their children's names to avoid collisions.
+ * It explicitly excludes virtual fields like 'join' since they are resolved at runtime.
+ */
+export declare function flattenFields(fields: Field[], prefix?: string): Field[];
+/**
+ * Recursively find all relational fields (relationship with hasMany or blocks).
+ * This is used by adapters to fetch related data during findOne/find.
+ */
+export declare function getRelationalFields(fields: Field[], prefix?: string): Field[];

package/dist/db/kysely/migration-generator.d.ts

@@ -0,0 +1,9 @@
+import type { Collection, Global } from "../../types";
+/**
+ * Generates Kysely migration code for 'up' and 'down' functions based on schema definitions.
+ */
+export declare function generateMigrationCode(collections: Collection[], globals: Global[] | undefined, dialect: "postgres" | "sqlite" | "d1"): string;
+/**
+ * Generates raw SQL migration code for Cloudflare D1.
+ */
+export declare function generateSQLCode(collections: Collection[], globals?: Global[]): string;

package/dist/db/kysely/query-builder.d.ts

@@ -0,0 +1,9 @@
+import type { ExpressionBuilder } from "kysely";
+/**
+ * Builds a Kysely expression from a generic query object.
+ *
+ * @param eb The Kysely ExpressionBuilder (e.g., from .where((eb) => buildKyselyWhere(eb, query)))
+ * @param query The query object (e.g., { age: { gt: 18 }, name: 'John' })
+ * @returns A single Expression combining all conditions with AND, or undefined.
+ */
+export declare function buildKyselyWhere(eb: ExpressionBuilder<any, any>, query: Record<string, any> | undefined): any;

package/dist/db/kysely/schema-builder.d.ts

@@ -0,0 +1,15 @@
+import type { Kysely } from "kysely";
+import type { Collection, Global } from "../../types";
+export type DialectType = "postgres" | "sqlite" | "d1";
+/**
+ * Dynamically pushes schemas to the database using Kysely's safe Schema Builder API.
+ *
+ * @param db The Kysely database instance
+ * @param dialect "postgres", "sqlite", or "d1"
+ * @param collections The user collections
+ * @param globals The user globals
+ * @param options Push options
+ */
+export declare function pushSchema(db: Kysely<any>, dialect: DialectType, collections: Collection[], globals?: Global[], options?: {
+    pushDestructive?: boolean;
+}): Promise<void>;

package/dist/db/kysely/sql-utils.d.ts

@@ -0,0 +1 @@
+export declare function assertSafeIdentifier(identifier: string): void;

package/dist/db/postgres.d.ts

@@ -0,0 +1,51 @@
+import { Kysely } from "kysely";
+import postgres from "postgres";
+import type { Collection, FindOptions, Global, PaginatedResult } from "../types";
+import { BaseDatabaseAdapter } from "./adapter";
+export interface PostgresConfig {
+    url?: string;
+    host?: string;
+    port?: number;
+    database?: string;
+    username?: string;
+    password?: string;
+    ssl?: boolean | "require" | "allow" | "prefer" | "verify-full" | Record<string, unknown>;
+}
+export declare class PostgresAdapter extends BaseDatabaseAdapter {
+    name: string;
+    private _rawDb;
+    private _db;
+    private _collections;
+    private _globals;
+    private config;
+    push: boolean;
+    migrationDir: string;
+    pushDestructive: boolean;
+    get raw(): postgres.Sql<{}> | null;
+    get db(): Kysely<any> | null;
+    constructor(config: PostgresConfig | string, options?: {
+        push?: boolean;
+        pushDestructive?: boolean;
+        migrationDir?: string;
+    });
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    unsafe(query: string, params?: unknown[]): Promise<unknown>;
+    count(collection: string, query?: Record<string, unknown>): Promise<number>;
+    create<T extends object>(collection: string, data: Partial<T>): Promise<T>;
+    findOne<T extends object>(collection: string, query: Record<string, unknown>, tx?: any): Promise<T | null>;
+    find<T extends object>(collection: string, query?: Record<string, unknown>, options?: FindOptions): Promise<PaginatedResult<T>>;
+    update<T extends object>(collection: string, query: Record<string, unknown> | string | number, data: Partial<T>): Promise<T>;
+    updateMany<T extends object>(collection: string, query: Record<string, unknown>, data: Partial<T>): Promise<number>;
+    delete(collection: string, query: Record<string, unknown> | string | number): Promise<boolean>;
+    deleteMany(collection: string, query: Record<string, unknown>): Promise<number>;
+    findGlobal<T extends object>(slug: string): Promise<T | null>;
+    updateGlobal<T extends object>(slug: string, data: Partial<T>): Promise<T>;
+    runMigrations(): Promise<void>;
+    migrate(collections: Collection[], globals?: Global[]): Promise<void>;
+}
+export declare function createPostgresAdapter(config: PostgresConfig | string, options?: {
+    push?: boolean;
+    pushDestructive?: boolean;
+    migrationDir?: string;
+}): PostgresAdapter;

package/dist/db/sqlite.d.ts

@@ -0,0 +1,41 @@
+import { Kysely } from "kysely";
+import type { Collection, FindOptions, Global, PaginatedResult } from "../types";
+import { BaseDatabaseAdapter } from "./adapter";
+export declare class SQLiteAdapter extends BaseDatabaseAdapter {
+    name: string;
+    private _rawDb;
+    private _db;
+    private _collections;
+    private _globals;
+    push: boolean;
+    migrationDir: string;
+    pushDestructive: boolean;
+    get raw(): any;
+    get db(): Kysely<any>;
+    constructor(path: string, options?: {
+        push?: boolean;
+        pushDestructive?: boolean;
+        migrationDir?: string;
+    });
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    unsafe(query: string, params?: any[]): Promise<unknown>;
+    private coerceData;
+    count(collection: string, query?: Record<string, unknown>): Promise<number>;
+    create<T extends object>(collection: string, data: Partial<T>): Promise<T>;
+    findOne<T extends object>(collection: string, query: Record<string, unknown>, tx?: any): Promise<T | null>;
+    find<T extends object>(collection: string, query?: Record<string, unknown>, options?: FindOptions): Promise<PaginatedResult<T>>;
+    update<T extends object>(collection: string, query: Record<string, unknown> | string | number, data: Partial<T>): Promise<T>;
+    delete(collection: string, query: Record<string, unknown> | string | number): Promise<boolean>;
+    updateMany<T extends object>(collection: string, query: Record<string, unknown>, data: Partial<T>): Promise<number>;
+    deleteMany(collection: string, query: Record<string, unknown>): Promise<number>;
+    findGlobal<T extends object>(slug: string): Promise<T | null>;
+    updateGlobal<T extends object>(slug: string, data: Partial<T>): Promise<T>;
+    runMigrations(): Promise<void>;
+    migrate(collections: Collection[], globals?: Global[]): Promise<void>;
+}
+export declare function createSQLiteAdapter(path: string, options?: {
+    push?: boolean;
+    pushDestructive?: boolean;
+    migrationDir?: string;
+}): SQLiteAdapter;

package/dist/db/system-schema.d.ts

@@ -0,0 +1,2 @@
+import type { Collection } from "../types";
+export declare const getSystemCollections: () => Collection[];

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./auth";
+export * from "./client";
+export * from "./config";
+export * from "./config-utils";
+export * from "./types";
+export type { AdminConfig, CollectionHooks, FieldType, } from "./validation";

package/dist/runtimes/bun.d.ts

@@ -0,0 +1,17 @@
+import { Hono } from "hono";
+import type { OpacaConfig } from "../types";
+export interface BunServerOptions {
+    port?: number;
+}
+/**
+ * Creates a standalone Bun server running OpacaCMS.
+ * Bun has native support for the `fetch` API, making it extremely fast.
+ *
+ * @param config - The OpacaCMS configuration object.
+ * @param options - Options for the Bun server (e.g., port).
+ * @returns The Hono application instance and an `init` function to start the server.
+ */
+export declare function createBunHandler(config: OpacaConfig, options?: BunServerOptions): {
+    app: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+    init: () => Promise<Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">>;
+};

package/dist/runtimes/cloudflare-workers.d.ts

@@ -0,0 +1,10 @@
+import { Hono } from "hono";
+import type { OpacaConfig } from "../types";
+/**
+ * Creates a Cloudflare Workers compatible handler for OpacaCMS.
+ * Returns an object with a `fetch` method, perfectly matched for CF Workers.
+ *
+ * @param configOrFactory - Either the OpacaCMS configuration object or a function that returns it.
+ * @returns An object with a standard `fetch` method signature.
+ */
+export declare function createCloudflareWorkersHandler(configOrFactory: OpacaConfig | ((env: any, request: Request) => OpacaConfig | Promise<OpacaConfig>)): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;

package/dist/runtimes/next.d.ts

@@ -0,0 +1,16 @@
+import type { OpacaConfig } from "../types";
+/**
+ * Creates a Next.js App Router compatible route handler for OpacaCMS.
+ * Wraps the internal Hono router using `hono/vercel`.
+ *
+ * @param config - The OpacaCMS configuration object.
+ * @returns An object containing the HTTP methods to be exported in `app/api/[[...route]]/route.ts`.
+ */
+export declare function createNextHandler(config: OpacaConfig): {
+    GET: (req: Request) => Response | Promise<Response>;
+    POST: (req: Request) => Response | Promise<Response>;
+    PUT: (req: Request) => Response | Promise<Response>;
+    DELETE: (req: Request) => Response | Promise<Response>;
+    PATCH: (req: Request) => Response | Promise<Response>;
+    OPTIONS: (req: Request) => Response | Promise<Response>;
+};

package/dist/runtimes/node.d.ts

@@ -0,0 +1,18 @@
+import { Hono } from "hono";
+import type { OpacaConfig } from "../types";
+export interface NodeServerOptions {
+    port?: number;
+    fetch?: (request: Request) => Promise<Response>;
+}
+/**
+ * Creates a standalone Node.js server running OpacaCMS.
+ * Uses `@hono/node-server` to serve the API.
+ *
+ * @param config - The OpacaCMS configuration object.
+ * @param options - Options for the Node server (e.g., port).
+ * @returns The Hono application instance and an `init` function to start the server.
+ */
+export declare function createNodeHandler(config: OpacaConfig, options?: NodeServerOptions): {
+    app: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+    init: () => Promise<Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">>;
+};

package/dist/schema/collection.d.ts

@@ -0,0 +1,100 @@
+import type { Collection as BaseCollection, IconName } from "../types";
+import type { AccessRules, InferFields } from "./infer";
+/**
+ * The Fluent API Collection Builder.
+ */
+export declare class CollectionBuilder<TFields extends Record<string, any> = {}> {
+    readonly slug: string;
+    private config;
+    private fieldBuilders;
+    constructor(slug: string);
+    /**
+     * Sets the user-friendly label for the Collection.
+     */
+    label(label: string): this;
+    /**
+     * Sets the Lucide icon for this collection.
+     */
+    icon(iconName: IconName): this;
+    /**
+     * Defines which field should be used as the title in the Admin UI.
+     */
+    useAsTitle(fieldName: keyof TFields | (string & {})): this;
+    /**
+     * Enables or disables automatic timestamps (createdAt, updatedAt).
+     */
+    timestamps(val?: boolean): this;
+    /**
+     * Defines the fields for this Collection.
+     * Re-instantiates the builder to capture the strong types of the fields.
+     */
+    fields<T extends readonly any[]>(fields: [...T]): CollectionBuilder<InferFields<T>>;
+    /**
+     * Type-safe access control rules.
+     */
+    access(rules: AccessRules<TFields>): this;
+    /**
+     * Defines a virtual/computed field with full type inference of the current collection data.
+     */
+    virtual<TName extends string, TReturn = any>(name: TName, options: {
+        label?: string;
+        resolve: (args: {
+            data: TFields;
+            req: any;
+            user: any;
+            session: any;
+            apiKey?: any;
+        }) => TReturn | Promise<TReturn>;
+        returnType?: "string" | "number" | "boolean" | "json";
+    }): CollectionBuilder<TFields & {
+        [K in TName]: TReturn;
+    }>;
+    /**
+     * Alias for .virtual()
+     */
+    computed<TName extends string, TReturn = any>(name: TName, options: {
+        label?: string;
+        resolve: (args: {
+            data: TFields;
+            req: any;
+            user: any;
+            session: any;
+            apiKey?: any;
+        }) => TReturn | Promise<TReturn>;
+        returnType?: "string" | "number" | "boolean" | "json";
+    }): CollectionBuilder<TFields & {
+        [K in TName]: TReturn;
+    }>;
+    /**
+     * Advanced Admin UI configuration.
+     */
+    admin(opts: BaseCollection["admin"]): this;
+    /**
+     * Adds automated versioning and drafts.
+     */
+    versions(opts: {
+        drafts?: boolean;
+        maxRevisions?: number;
+        autosave?: boolean;
+    }): this;
+    /**
+     * Adds webhooks to be triggered on document lifecycle events.
+     */
+    webhooks(webhooks: {
+        events: string[];
+        url: string;
+        headers?: Record<string, string>;
+    }[]): this;
+    /**
+     * Spreads configuration from presets (Proposed Feature stub)
+     */
+    extend(preset: any): this;
+    protected _ensureAdmin(): void;
+    /**
+     * Compiles the collection builder down into the raw Object structure expected by OpacaCMS.
+     */
+    build(): BaseCollection;
+}
+export declare const Collection: {
+    create: (slug: string) => CollectionBuilder<{}>;
+};

package/dist/schema/fields/base.d.ts

@@ -0,0 +1,83 @@
+import type { BaseField, FieldAccessConfig } from "../../types";
+/**
+ * The base class for all Fluent API Field Builders.
+ * Accumulates configuration state linearly.
+ *
+ * @template TType The literal string type of the field (e.g., 'text', 'relationship').
+ * @template TName The literal string name of the field.
+ * @template TValue The TypeScript literal value type this field produces (e.g., string, number).
+ */
+export declare abstract class FieldBuilder<TType extends string, TName extends string = string, TValue = any, TSubFields extends readonly any[] = any[]> {
+    readonly type: TType;
+    readonly name: TName;
+    readonly __type: TType;
+    readonly __name: TName;
+    readonly __value: TValue;
+    readonly __sub: TSubFields;
+    protected config: Partial<BaseField & Record<string, any>>;
+    constructor(type: TType, name: TName);
+    /**
+     * Defines a user-friendly label for the Admin UI.
+     */
+    label(label: string): this;
+    /**
+     * Sets the placeholder text for the input field.
+     */
+    placeholder(text: string): this;
+    /**
+     * Marks the field as strictly required.
+     */
+    required(val?: boolean): this;
+    /**
+     * Marks the field as unique within the database table.
+     */
+    unique(val?: boolean): this;
+    /**
+     * Enables native field-level internationalization.
+     */
+    localized(val?: boolean): this;
+    /**
+     * Sets a default value for the field.
+     */
+    defaultValue(val: TValue): this;
+    /**
+     * A custom validation callback function.
+     */
+    validate(fn: (value: unknown) => boolean | string): this;
+    /**
+     * Configure granular access control for this specific field.
+     */
+    access(config: FieldAccessConfig): this;
+    /**
+     * Add a descriptive text below the field in the Admin UI.
+     */
+    description(text: string): this;
+    /**
+     * Override Admin UI with custom React components.
+     */
+    admin(opts: NonNullable<BaseField["admin"]>): this;
+    /**
+     * Completely hide the field from the Admin UI and API responses (depending on access).
+     */
+    hidden(val?: boolean): this;
+    /**
+     * Mark the field as read-only in the Admin UI.
+     */
+    readOnly(val?: boolean): this;
+    /**
+     * Spreads arbitrary runtime configuration for any non-strongly-typed features.
+     */
+    extend(opts: Record<string, any>): this;
+    /**
+     * Helper to ensure the `admin` options object is initialized.
+     */
+    protected _ensureAdmin(): void;
+    /**
+     * Helper to ensure the `options` object is initialized.
+     */
+    protected _ensureOptions(): void;
+    /**
+     * Compiles the accumulated builder state down into the raw Object structure expected by OpacaCMS.
+     */
+    build(): any;
+}

package/dist/schema/fields/index.d.ts

@@ -0,0 +1,135 @@
+import { FieldBuilder } from "./base";
+export declare class TextFieldBuilder<TName extends string> extends FieldBuilder<"text", TName, string> {
+    constructor(name: TName);
+}
+export declare class SlugFieldBuilder<TName extends string> extends FieldBuilder<"slug", TName, string> {
+    constructor(name: TName);
+    from(sourceField: string): this;
+    format(fn: (val: string) => string): this;
+}
+export declare class TextAreaFieldBuilder<TName extends string> extends FieldBuilder<"textarea", TName, string> {
+    constructor(name: TName);
+}
+export declare class NumberFieldBuilder<TName extends string> extends FieldBuilder<"number", TName, number> {
+    constructor(name: TName);
+    min(val: number): this;
+    max(val: number): this;
+}
+export declare class BooleanFieldBuilder<TName extends string> extends FieldBuilder<"boolean", TName, boolean> {
+    constructor(name: TName);
+    display(type: "switch" | "toggle" | "checkbox" | "select"): this;
+}
+export declare class RichTextFieldBuilder<TName extends string> extends FieldBuilder<"richtext", TName, string> {
+    constructor(name: TName);
+    mode(mode: "simple" | "notion"): this;
+}
+export declare class RelationshipFieldBuilder<TName extends string> extends FieldBuilder<"relationship", TName, string | string[]> {
+    constructor(name: TName);
+    to(collection: string | {
+        slug: string;
+    }): this;
+    single(): this;
+    many(): this;
+    displayField(field: string): this;
+}
+export declare class FileFieldBuilder<TName extends string> extends FieldBuilder<"file", TName, unknown> {
+    constructor(name: TName);
+    bucket(bucketName: string): this;
+    allowedmime_types(types: string[]): this;
+    maxSize(bytes: number): this;
+}
+export declare class DateFieldBuilder<TName extends string> extends FieldBuilder<"date", TName, string | Date> {
+    constructor(name: TName);
+}
+export declare class SelectFieldBuilder<TName extends string> extends FieldBuilder<"select", TName, string> {
+    constructor(name: TName);
+    choices(choices: string[] | {
+        label: string;
+        value: string;
+    }[]): this;
+}
+export declare class RadioFieldBuilder<TName extends string> extends FieldBuilder<"radio", TName, string> {
+    constructor(name: TName);
+    choices(choices: string[] | {
+        label: string;
+        value: string;
+    }[]): this;
+}
+export declare class TabsFieldBuilder<TTabs extends readonly any[] = []> extends FieldBuilder<"tabs", "", unknown, TTabs> {
+    constructor();
+    tab<TLabel extends string, TSub extends readonly FieldBuilder<any, any, any, any>[]>(label: TLabel, ...fields: TSub): TabsFieldBuilder<[...TTabs, {
+        label: TLabel;
+        fields: TSub;
+    }]>;
+}
+export declare class CollapsibleFieldBuilder<TNames extends string = string, TSub extends readonly any[] = any[]> extends FieldBuilder<"collapsible", "", unknown, TSub> {
+    constructor(fields?: FieldBuilder<any, TNames, any, any>[]);
+    initiallyCollapsed(val?: boolean): this;
+    useAsTitle(fieldName: TNames | (string & {})): this;
+    fields<NewSub extends readonly FieldBuilder<any, any, any>[]>(...fields: NewSub): CollapsibleFieldBuilder<ExtractNames<NewSub>, NewSub>;
+}
+type ExtractNames<T extends readonly any[]> = T[number]["name"];
+export declare class JoinFieldBuilder<TName extends string> extends FieldBuilder<"join", TName, any[]> {
+    constructor(name: TName);
+    collection(collectionSlug: string): this;
+    on(fieldName: string): this;
+}
+export declare class ArrayFieldBuilder<TName extends string, TSub extends readonly any[] = any[]> extends FieldBuilder<"array", TName, unknown[], TSub> {
+    constructor(name: TName);
+    of<NewSub extends readonly FieldBuilder<any, any, any, any>[]>(...fields: NewSub): ArrayFieldBuilder<TName, NewSub>;
+}
+export declare class GroupFieldBuilder<TName extends string, TNames extends string = string, TSub extends readonly any[] = any[]> extends FieldBuilder<"group", TName, Record<string, any>, TSub> {
+    constructor(name: TName, fields?: FieldBuilder<any, TNames, any, any>[]);
+    fields<NewSub extends readonly FieldBuilder<any, any, any, any>[]>(...fields: NewSub): GroupFieldBuilder<TName, ExtractNames<NewSub>, NewSub>;
+}
+export declare class RowFieldBuilder<TSub extends readonly any[] = any[]> extends FieldBuilder<"row", "", unknown, TSub> {
+    constructor(fields?: FieldBuilder<any, any, any, any>[]);
+    fields<NewSub extends readonly FieldBuilder<any, any, any, any>[]>(...fields: NewSub): RowFieldBuilder<NewSub>;
+}
+export declare class BlockBuilder<TSlug extends string, TNames extends string = string, TSub extends readonly any[] = any[]> {
+    private config;
+    constructor(slug: TSlug);
+    label(label: string): this;
+    fields<NewSub extends readonly FieldBuilder<any, any, any, any>[]>(...fields: NewSub): BlockBuilder<TSlug, ExtractNames<NewSub>, NewSub>;
+    build(): Record<string, any>;
+}
+export declare class VirtualFieldBuilder<TName extends string, TData = any> extends FieldBuilder<"virtual", TName, any> {
+    constructor(name: TName);
+    resolve(fn: (args: {
+        data: TData;
+        req: any;
+        user: any;
+        session: any;
+        apiKey?: any;
+    }) => any | Promise<any>): this;
+    returnType(type: "string" | "number" | "boolean" | "json"): this;
+}
+export declare class BlocksFieldBuilder<TName extends string, TBlocks extends readonly any[] = any[]> extends FieldBuilder<"blocks", TName, any[], TBlocks> {
+    constructor(name: TName);
+    blocks<NewBlocks extends readonly BlockBuilder<any, any, any>[]>(...blocks: NewBlocks): BlocksFieldBuilder<TName, NewBlocks>;
+}
+/**
+ * The Field Factory object containing methods to instantiate specific field builders.
+ */
+export declare const Field: {
+    text: <N extends string>(name: N) => TextFieldBuilder<N>;
+    slug: <N extends string>(name: N) => SlugFieldBuilder<N>;
+    textarea: <N extends string>(name: N) => TextAreaFieldBuilder<N>;
+    number: <N extends string>(name: N) => NumberFieldBuilder<N>;
+    boolean: <N extends string>(name: N) => BooleanFieldBuilder<N>;
+    date: <N extends string>(name: N) => DateFieldBuilder<N>;
+    select: <N extends string>(name: N) => SelectFieldBuilder<N>;
+    radio: <N extends string>(name: N) => RadioFieldBuilder<N>;
+    richText: <N extends string>(name: N) => RichTextFieldBuilder<N>;
+    relationship: <N extends string>(name: N) => RelationshipFieldBuilder<N>;
+    join: <N extends string>(name: N) => JoinFieldBuilder<N>;
+    file: <N extends string>(name: N) => FileFieldBuilder<N>;
+    array: <N extends string>(name: N) => ArrayFieldBuilder<N, any[]>;
+    group: <N extends string, TSub extends readonly FieldBuilder<any, any, any, any>[]>(name: N, fields?: TSub) => GroupFieldBuilder<N, any, TSub>;
+    tabs: () => TabsFieldBuilder<[]>;
+    collapsible: <N extends string, S extends readonly FieldBuilder<any, any, any, any>[]>(fields?: S) => CollapsibleFieldBuilder<ExtractNames<S>, S>;
+    row: <S extends readonly FieldBuilder<any, any, any, any>[]>(fields?: S) => RowFieldBuilder<S>;
+    blocks: <N extends string, TSub extends readonly BlockBuilder<any, any, any>[]>(name: N, ...blocks: TSub) => BlocksFieldBuilder<N, TSub>;
+    block: <N extends string>(slug: N) => BlockBuilder<N, string, any[]>;
+};
+export * from "./base";