@dyrected/core 0.0.0-pr-18-20260828214838

package/dist/index.d.cts

@@ -0,0 +1,1399 @@
+import { F as Field, B as Block, D as DyrectedConfig, C as CollectionConfig, A as AdminAuthConfig, P as PublicAdminAuthConfig, G as GlobalConfig, a as DeclarativeHookExpression, W as WorkflowConfig, b as AuthenticatedUser, c as WorkflowTransition, L as LifecycleEventName, d as LifecycleEvent, e as BaseDocument, H as HookRequestContext, f as DetailComputedOptions, g as ComputedHandler, h as DetailComputed, i as DetailCustomOptions, j as DetailCustom, k as DetailDividerOptions, l as DetailDivider, m as DisplayFieldOptions, n as DetailField, o as DetailItem, p as DetailGridOptions, q as DetailGrid, r as DetailRepeatOptions, s as DetailRepeat, t as DetailSectionOptions, u as DetailSection, v as DetailTabOptions, w as DetailTab, x as DetailTabsOptions, y as DetailTabs, z as DetailTextOptions, E as DetailText, I as DetailSchema, J as DatabaseAdapter, K as DyrectedAIContext, M as AIThread, N as AIMessage, R as RAGSearchResult, O as ArrayField, Q as BlocksField, S as BooleanField, T as AuthConfig, U as AccessPolicyResolver, V as DateField, X as DateTimeField, Y as EmailField, Z as IconField, _ as ImageField, $ as JoinField, a0 as JsonField, a1 as MultiSelectField, a2 as NumberField, a3 as ObjectField, a4 as RadioField, a5 as RelationshipField, a6 as RichTextField, a7 as RowField, a8 as SelectField, a9 as TextField, aa as TextareaField, ab as TimeField, ac as UrlField } from './app-config-BgV9qpFu.cjs';
+export { ad as AIAction, ae as AIActionStatus, af as AIActionType, ag as AIAuditRecord, ah as AIChunk, ai as AIConfig, aj as AIToolContext, ak as AIToolDefinition, al as AI_ACTIONS_COLLECTION, am as AI_AUDIT_COLLECTION, an as AI_CHUNKS_COLLECTION, ao as AI_MESSAGES_COLLECTION, ap as AI_THREADS_COLLECTION, aq as AccessConfig, ar as AccessFunction, as as AccessFunctionArgs, at as AccessResult, au as AccessRule, av as ActionConfig, aw as ActionContext, ax as ActionType, ay as AdminAuthAccessResolution, az as AdminAuthClaimMapping, aA as AdminAuthMember, aB as AdminAuthProvider, aC as AdminAuthProviderMembersConfig, aD as AdminAuthProvisioningMode, aE as AdminAuthResolveAccessArgs, aF as AdminAuthResolvedIdentity, aG as AdminConfig, aH as AdminDashboardComponentSlots, aI as AdminIconName, aJ as AggregateArgs, aK as AggregateCastType, aL as AggregateCollectionResult, aM as AggregateInput, aN as AggregateOperation, aO as AggregateResult, aP as BaseAdminAuthProvider, aQ as BaseFieldAdmin, aR as BlockVariant, aS as BooleanFieldAdmin, aT as BooleanFormat, aU as CharacterLimitFieldAdmin, aV as CharacterLimitFieldConfig, aW as CollectionAfterChangeHook, aX as CollectionAfterDeleteHook, aY as CollectionAfterReadHook, aZ as CollectionAfterReadHookEntry, a_ as CollectionAfterTransitionHook, a$ as CollectionBeforeChangeHook, b0 as CollectionBeforeChangeHookEntry, b1 as CollectionBeforeDeleteHook, b2 as CollectionBeforeReadHook, b3 as CollectionBeforeReadHookEntry, b4 as CollectionBeforeTransitionHook, b5 as CollectionListComponentSlots, b6 as CollectionRAGConfig, b7 as CollectionSchemaResult, b8 as CollectionSummaryResult, b9 as CountOperation, ba as CustomAdminAuthProvider, bb as DateFieldAdmin, bc as DateFormat, bd as DefineActionOptions, be as DefineViewOptions, bf as DetailSpan, bg as DisplayTone, bh as DisplayVariant, bi as DistinctCountOperation, bj as DistinctValuesOperation, bk as DynamicOptionItem, bl as DynamicOptionsConfig, bm as DynamicOptionsResolver, bn as DynamicOptionsResolverArgs, bo as DyrectedLoggerConfig, bp as DyrectedObservabilityConfig, bq as EmailFieldAdmin, br as FieldAdminHooks, bs as FieldAdminOnChangeHook, bt as FieldAdminOnChangeHookArgs, bu as FieldAdminOptionsHook, bv as FieldAdminOptionsHookArgs, bw as FieldAdminOptionsHookResult, bx as FieldAfterReadHook, by as FieldAfterReadHookArgs, bz as FieldBase, bA as FieldBeforeChangeHook, bB as FieldBeforeChangeHookArgs, bC as FieldHook, bD as FieldHooks, bE as FieldType, bF as FileData, bG as GetDocumentResult, bH as GlobalAfterChangeHook, bI as GlobalAfterReadHook, bJ as GlobalAfterReadHookEntry, bK as GlobalBeforeChangeHook, bL as GlobalBeforeChangeHookEntry, bM as GlobalBeforeReadHook, bN as GlobalBeforeReadHookEntry, bO as GlobalRAGConfig, bP as GlobalSchemaResult, bQ as GlobalSummaryResult, bR as HeadingLevel, bS as HookFunction, bT as IconFieldAdmin, bU as ImageService, bV as InferAggregateResult, bW as JoinFieldAdmin, bX as JsonFieldAdmin, bY as JsonFormat, bZ as LIFECYCLE_EVENT_NAMES, b_ as LifecycleEventHandler, b$ as LinkFormat, c0 as MetricColor, c1 as MultiSelectFieldAdmin, c2 as NamedAccessPolicy, c3 as NumberFieldAdmin, c4 as NumberFormat, c5 as NumberLimitFieldAdmin, c6 as NumberLimitFieldConfig, c7 as NumericOperation, c8 as OIDCAdminAuthProvider, c9 as OptionFormat, ca as PaginatedResult, cb as PublicAdminAuthProvider, cc as QueryCollectionResult, cd as RadioFieldAdmin, ce as RateLimitConfig, cf as ReadonlyDatabaseAdapter, cg as RichTextFeature, ch as RichTextFieldConfig, ci as SelectFieldAdmin, cj as StorageAdapter, ck as TextFieldAdmin, cl as TextFormat, cm as TextareaFieldAdmin, cn as TrustProxyConfig, co as TypedField, cp as UploadConfig, cq as UrlFieldAdmin, cr as UrlLinkValue, cs as ViewActionFeatures, ct as ViewConfig, cu as ViewLayout, cv as ViewMetric, cw as ViewSubMetric, cx as WordLimitFieldAdmin, cy as WordLimitFieldConfig, cz as WorkflowMetadata, cA as WorkflowRole, cB as WorkflowState, cC as WorkflowTransitionContext, cD as defineAction, cE as defineView, cF as isAICollection } from './app-config-BgV9qpFu.cjs';
+import jexl from 'jexl';
+import { LanguageModel, EmbeddingModel } from 'ai';
+export { z } from 'zod';
+import 'lucide-react';
+import 'pino';
+
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+};
+type FieldValueType<F extends Field> = F["type"] extends "text" | "textarea" | "email" | "url" | "icon" | "date" | "datetime" | "time" | "select" | "radio" ? string : F["type"] extends "number" ? number : F["type"] extends "boolean" ? boolean : F["type"] extends "multiSelect" ? string[] : F["type"] extends "relationship" ? F extends {
+    hasMany: true;
+} ? string[] : string : F["type"] extends "image" ? F extends {
+    hasMany: true;
+} ? string[] : string : F["type"] extends "richText" | "json" ? Record<string, unknown> : F["type"] extends "object" ? F extends {
+    fields: infer SF extends readonly Field[];
+} ? Prettify<InferDocShape<SF>> : Record<string, unknown> : F["type"] extends "array" ? F extends {
+    fields: infer SF extends readonly Field[];
+} ? Array<Prettify<InferDocShape<SF>>> : unknown[] : F["type"] extends "blocks" ? F extends {
+    blocks: infer B extends readonly Block[];
+} ? Array<InferBlocksUnion<B>> : Array<{
+    blockType: string;
+} & Record<string, unknown>> : unknown;
+type InferBlocksUnion<Blocks extends readonly Block[]> = Blocks extends readonly [
+    infer B extends Block,
+    ...infer Rest extends readonly Block[]
+] ? B["fields"] extends readonly Field[] ? ({
+    blockType: B["slug"];
+} & Prettify<InferDocShape<B["fields"]>>) | InferBlocksUnion<Rest> : ({
+    blockType: B["slug"];
+} & Record<string, unknown>) | InferBlocksUnion<Rest> : never;
+type InferFieldEntry<F extends Field> = F extends {
+    type: "row";
+    fields: infer SF extends readonly Field[];
+} ? InferDocShape<SF> : F extends {
+    type: "join";
+} ? Record<never, never> : F extends {
+    name: infer N extends string;
+    required: true;
+} ? {
+    [K in N]: FieldValueType<F>;
+} : F extends {
+    name: infer N extends string;
+} ? {
+    [K in N]?: FieldValueType<F>;
+} : Record<never, never>;
+type InferDocShape<Fields extends readonly Field[]> = Fields extends readonly [] ? Record<never, never> : Fields extends readonly [infer Head extends Field, ...infer Tail extends readonly Field[]] ? InferFieldEntry<Head> & InferDocShape<Tail> : Record<string, unknown>;
+type SystemDocFields = {
+    createdAt?: string;
+    updatedAt?: string;
+    createdBy?: string;
+    updatedBy?: string;
+};
+type AuthDocFields = {
+    email: string;
+    password?: string;
+    roles?: string[];
+};
+type UploadDocFields = {
+    filename: string;
+    filesize?: number;
+    mimeType: string;
+    url: string;
+    width?: number;
+    height?: number;
+    focalPoint?: {
+        x: number;
+        y: number;
+    };
+    blurhash?: string;
+    sizes?: Record<string, {
+        filename?: string;
+        url?: string;
+        width?: number;
+        height?: number;
+    }>;
+};
+
+type AIErrorCode = 'AI_UNCONFIGURED' | 'AI_RATE_LIMITED' | 'AI_QUOTA_EXHAUSTED' | 'AI_TIMEOUT' | 'AI_TOOL_VALIDATION_ERROR' | 'AI_PERMISSION_DENIED' | 'AI_TENANT_VIOLATION' | 'AI_ACTION_EXPIRED' | 'AI_ACTION_ALREADY_EXECUTED' | 'AI_INTERNAL_ERROR';
+declare class DyrectedAIError extends Error {
+    readonly code: AIErrorCode;
+    readonly status: number;
+    readonly details?: Record<string, unknown>;
+    constructor(code: AIErrorCode, message: string, status?: number, details?: Record<string, unknown>);
+    toJSON(): {
+        error: boolean;
+        code: AIErrorCode;
+        message: string;
+        status: number;
+        details: Record<string, unknown> | undefined;
+    };
+}
+
+/**
+ * Normalizes the Dyrected configuration by injecting system fields
+ * (createdAt, updatedAt, createdBy, updatedBy) into every collection and
+ * registering the __audit collection if any collection has audit: true.
+ */
+declare function normalizeConfig(config: DyrectedConfig): DyrectedConfig;
+
+declare function getAdminAuthCollection(config: Pick<DyrectedConfig, "collections" | "adminAuth">): CollectionConfig | null;
+declare function resolveAdminAuthCollection(collections: CollectionConfig[], collectionSlug?: string): CollectionConfig | undefined;
+declare function getPublicAdminAuthConfig(adminAuth?: AdminAuthConfig, collections?: CollectionConfig[]): PublicAdminAuthConfig;
+
+/**
+ * Dyrected Where Clause DSL — shared query language across all database adapters.
+ *
+ * Adapters translate this DSL into their native format:
+ *   - SQL adapters (SQLite, Postgres, MySQL): use parseSqlWhere()
+ *   - MongoDB adapter: use parseMongoWhere()
+ *   - Future adapters: implement their own translator against WhereClause
+ *
+ * Exhaustive operator handling is enforced at compile time via `assertNever`,
+ * so adding a new operator without handling it will produce a TypeScript error
+ * in every adapter translator.
+ */
+type WhereOperatorName = 'equals' | 'not_equals' | 'in' | 'not_in' | 'gt' | 'greater_than' | 'gte' | 'greater_than_equal' | 'greater_than_or_equal' | 'lt' | 'less_than' | 'lte' | 'less_than_equal' | 'less_than_or_equal' | 'contains' | 'like' | 'starts_with' | 'exists';
+type WhereOperator = {
+    equals: any;
+} | {
+    not_equals: any;
+} | {
+    in: any[];
+} | {
+    not_in: any[];
+} | {
+    gt: any;
+} | {
+    greater_than: any;
+} | {
+    gte: any;
+} | {
+    greater_than_equal: any;
+} | {
+    greater_than_or_equal: any;
+} | {
+    lt: any;
+} | {
+    less_than: any;
+} | {
+    lte: any;
+} | {
+    less_than_equal: any;
+} | {
+    less_than_or_equal: any;
+} | {
+    contains: string;
+} | {
+    like: string;
+} | {
+    starts_with: string;
+} | {
+    exists: boolean;
+};
+/** Top-level where clause. Fields map to operator objects or shorthand scalar values. */
+type WhereClause = {
+    [field: string]: WhereOperator | any;
+    OR?: WhereClause[];
+    AND?: WhereClause[];
+};
+interface SqlWhereResult {
+    sql: string;
+    params: any[];
+}
+/**
+ * Translates a WhereClause into a parameterized SQL WHERE fragment.
+ *
+ * @param where         The Dyrected where DSL object
+ * @param getJsonField  Returns the SQL expression for a JSON-stored field (dialect-specific):
+ *                        SQLite:   (f) => `json_extract(data, '$.${f}')`
+ *                        Postgres: (f) => `data->>'${f}'`
+ *                        MySQL:    (f) => `JSON_UNQUOTE(JSON_EXTRACT(data, '$.${f}'))`
+ * @param placeholder   '?' for SQLite/MySQL, 'pg' for auto-incrementing Postgres $1/$2/…
+ */
+declare function parseSqlWhere(where: WhereClause, getJsonField: (field: string) => string, placeholder?: '?' | 'pg', 
+/**
+ * SQL keyword used for `contains`/`starts_with`. Postgres `LIKE` is
+ * case-sensitive, so the Postgres adapter defaults to `'ILIKE'` to keep substring
+ * matching case-insensitive like SQLite and MySQL.
+ */
+likeOperator?: 'LIKE' | 'ILIKE'): SqlWhereResult;
+/**
+ * Translates a WhereClause into a MongoDB filter object.
+ * Handles nested OR/AND via $or/$and, and all operators via $eq/$in/$gt etc.
+ */
+declare function parseMongoWhere(where: WhereClause): Record<string, any>;
+
+type SortDirection = 'ASC' | 'DESC';
+interface SortClause {
+    field: string;
+    direction: SortDirection;
+}
+declare function parseSort(sort: string | undefined, fallback?: SortClause): SortClause[];
+/**
+ * Collects the names of top-level fields declared as numbers. SQL adapters use
+ * this to decide which JSON-extracted sort fields need a numeric cast.
+ */
+declare function numericFieldNames(fields?: Field[]): Set<string>;
+/**
+ * Dialect hooks for turning a parsed sort into a SQL `ORDER BY` body.
+ * Each SQL adapter supplies its own quoting, JSON extraction, and numeric cast.
+ */
+interface SqlSortDialect {
+    /** Quote a real column identifier (e.g. `"created_at"` or \`created_at\`). */
+    quoteIdent: (identifier: string) => string;
+    /** SQL expression that reads a top-level field out of the JSON `data` column. */
+    jsonExtract: (field: string) => string;
+    /**
+     * Wrap a JSON-extracted expression so it sorts numerically instead of
+     * lexicographically. Adapters whose JSON extraction already preserves number
+     * types (SQLite) can return the expression unchanged.
+     */
+    castNumeric: (expr: string) => string;
+}
+/**
+ * Builds the `ORDER BY` body shared by the SQL adapters.
+ *
+ * Real (promoted) columns and the `created_at`/`updated_at` timestamps are
+ * ordered by their typed column directly. Everything else is read out of the
+ * JSON `data` column — and when a field is declared as a `number`, its extracted
+ * value is cast so it orders by magnitude rather than as text ("9" < "10").
+ *
+ * @param sort            The raw sort string (e.g. `"-createdAt"`, `"priority,-views"`).
+ * @param existingColumns Real column names present on the table.
+ * @param numericFields   Names of top-level fields declared with `type: 'number'`.
+ * @param dialect         Adapter-specific quoting, extraction, and numeric cast.
+ */
+declare function buildSqlOrderBy(sort: string | undefined, existingColumns: string[], numericFields: Set<string>, dialect: SqlSortDialect): string;
+
+type DeclarativeHookSurface = "collection.beforeRead" | "collection.afterRead" | "collection.beforeChange" | "global.beforeRead" | "global.afterRead" | "global.beforeChange" | "field.beforeChange" | "field.admin.onChange";
+interface DeclarativeHookValidationIssue {
+    path: string;
+    surface: DeclarativeHookSurface | "unsupported";
+    expression: string;
+    message: string;
+}
+type DeclarativeAccessSurface = "config.accessPolicy" | "collection.access" | "global.access" | "field.access";
+interface DeclarativeAccessValidationIssue {
+    path: string;
+    surface: DeclarativeAccessSurface;
+    expression: string;
+    message: string;
+}
+type DeclarativeAdminSurface = "field.admin.condition";
+type DeclarativePreviewSurface = "collection.admin.previewUrl";
+interface DeclarativeAdminValidationIssue {
+    path: string;
+    surface: DeclarativeAdminSurface;
+    expression: string;
+    message: string;
+}
+interface DeclarativePreviewValidationIssue {
+    path: string;
+    surface: DeclarativePreviewSurface;
+    expression: string;
+    message: string;
+}
+interface ConfigDiagnostic {
+    severity: "error" | "warning";
+    source: "declarativeHook" | "declarativeAccess" | "adminCondition" | "previewUrl";
+    path: string;
+    surface: string;
+    message: string;
+    expression: string;
+}
+type DiagnosticFormatOptions = {
+    color?: boolean;
+};
+type DeclarativeValidationConfig = {
+    blocks?: Array<Pick<Block, "fields"> & Partial<Pick<Block, "slug">>>;
+    collections: Array<Pick<CollectionConfig, "fields" | "hooks" | "access" | "admin"> & Partial<Pick<CollectionConfig, "slug">>>;
+    globals?: Array<Pick<GlobalConfig, "fields" | "hooks" | "access"> & Partial<Pick<GlobalConfig, "slug">>>;
+    accessPolicies?: Record<string, unknown>;
+};
+declare function validateDeclarativeHookExpression(expression: string, surface: DeclarativeHookSurface, path: string): DeclarativeHookValidationIssue[];
+declare function validateDeclarativeAccessExpression(expression: string, surface: DeclarativeAccessSurface, path: string): DeclarativeAccessValidationIssue[];
+declare function validateAdminConditionExpression(expression: string, path: string, allowedRoots: readonly string[]): DeclarativeAdminValidationIssue[];
+declare function validatePreviewUrlExpression(expression: string, path: string, allowedRoots: readonly string[]): DeclarativePreviewValidationIssue[];
+declare function assertValidDeclarativeHookExpression(expression: string, surface: DeclarativeHookSurface, path: string): void;
+declare function assertValidDeclarativeHookResult(result: unknown, surface: "collection.beforeRead" | "collection.afterRead" | "collection.beforeChange" | "global.beforeRead" | "global.afterRead" | "global.beforeChange", path: string): void;
+declare function collectDeclarativeHookValidationIssues(config: DeclarativeValidationConfig): DeclarativeHookValidationIssue[];
+declare function collectDeclarativeAccessValidationIssues(config: DeclarativeValidationConfig): DeclarativeAccessValidationIssue[];
+declare function collectAdminConditionValidationIssues(config: DeclarativeValidationConfig): DeclarativeAdminValidationIssue[];
+declare function collectPreviewUrlValidationIssues(config: DeclarativeValidationConfig): DeclarativePreviewValidationIssue[];
+declare function assertValidAdminConditionsInConfig(config: DeclarativeValidationConfig, source?: string): void;
+declare function assertValidPreviewUrlsInConfig(config: DeclarativeValidationConfig, source?: string): void;
+declare function collectConfigDiagnostics(config: DeclarativeValidationConfig): ConfigDiagnostic[];
+declare function formatConfigDiagnostics(source: string, diagnostics: ConfigDiagnostic[], options?: DiagnosticFormatOptions): string;
+declare class ConfigValidationError extends Error {
+    diagnostics: ConfigDiagnostic[];
+    source: string;
+    constructor(source: string, diagnostics: ConfigDiagnostic[]);
+}
+declare function isConfigValidationError(error: unknown): error is ConfigValidationError;
+declare function assertValidDeclarativeHooksInConfig(config: DeclarativeValidationConfig, source?: string): void;
+declare function assertValidDeclarativeAccessInConfig(config: DeclarativeValidationConfig, source?: string): void;
+
+/**
+ * Transforms a string into a clean, URL-safe slug.
+ * Strips accents, lowercases, removes non-alphanumeric characters, and hyphens whitespace.
+ *
+ * @example `slugify("Hello World!")` => `"hello-world"`
+ */
+declare function slugify(val: unknown): string;
+/**
+ * Converts a string value to lowercase.
+ *
+ * @example `lower("Dyrected")` => `"dyrected"`
+ */
+declare function lower(val: unknown): string;
+/**
+ * Converts a string value to uppercase.
+ *
+ * @example `upper("dyrected")` => `"DYRECTED"`
+ */
+declare function upper(val: unknown): string;
+/**
+ * Trims leading and trailing whitespace from a string.
+ *
+ * @example `trim("  hello  ")` => `"hello"`
+ */
+declare function trim(val: unknown): string;
+/**
+ * Capitalizes the first letter of a string and lowercases the rest.
+ *
+ * @example `capitalize("hELLO")` => `"Hello"`
+ */
+declare function capitalize(val: unknown): string;
+/**
+ * Truncates a string to a maximum length and appends an ellipsis.
+ *
+ * @example `truncate("Long article text...", 10)` => `"Long artic..."`
+ */
+declare function truncate(val: unknown, length: unknown, ellipsis?: string): string;
+/**
+ * Calculates estimated reading time in minutes based on word count.
+ *
+ * @example `readingTime(articleText)` => `3`
+ */
+declare function readingTime(val: unknown, wpm?: number): number;
+/**
+ * Returns the word count of a text string.
+ *
+ * @example `wordCount("Quick brown fox")` => `3`
+ */
+declare function wordCount(val: unknown): number;
+/**
+ * Replaces occurrences of a substring or pattern with a replacement string.
+ *
+ * @example `replace("hello world", "world", "there")` => `"hello there"`
+ */
+declare function replace(val: unknown, search: unknown, replacement: unknown): string;
+/**
+ * Checks if a string starts with a given prefix.
+ *
+ * @example `startsWith("dyrected.com", "dyrected")` => `true`
+ */
+declare function startsWith(str: unknown, prefix: unknown): boolean;
+/**
+ * Checks if a string ends with a given suffix.
+ *
+ * @example `endsWith("image.png", ".png")` => `true`
+ */
+declare function endsWith(str: unknown, suffix: unknown): boolean;
+/**
+ * Returns the current date and time as an ISO 8601 string.
+ *
+ * @example `now()` => `"2026-07-27T00:00:00.000Z"`
+ */
+declare function now(): string;
+/**
+ * Returns the current date as a YYYY-MM-DD string.
+ *
+ * @example `today()` => `"2026-07-27"`
+ */
+declare function today(): string;
+/**
+ * Formats a date string, number, or Date instance into a formatted string.
+ *
+ * @param style `'short'` (default), `'iso'`, `'date'`, `'datetime'`, or `'full'`
+ * @example `formatDate("2026-07-27T12:00:00Z", "short")` => `"Jul 27, 2026"`
+ */
+declare function formatDate(val: unknown, style?: unknown): string;
+/**
+ * Adds or subtracts a specified number of days to a date.
+ *
+ * @example `addDays(now(), 7)` => `"2026-08-03T00:00:00.000Z"`
+ */
+declare function addDays(val: unknown, days: unknown): string;
+/**
+ * Calculates the integer difference in days between two dates.
+ *
+ * @example `diffDays("2026-07-27", "2026-07-20")` => `7`
+ */
+declare function diffDays(dateA: unknown, dateB: unknown): number;
+/**
+ * Checks if a date is in the past relative to the current timestamp.
+ *
+ * @example `isPast("2020-01-01")` => `true`
+ */
+declare function isPast(val: unknown): boolean;
+/**
+ * Checks if a date is in the future relative to the current timestamp.
+ *
+ * @example `isFuture("2030-01-01")` => `true`
+ */
+declare function isFuture(val: unknown): boolean;
+/**
+ * Checks if an item exists within an array or if a substring exists within a string.
+ *
+ * @example `includes(["admin", "editor"], "admin")` => `true`
+ */
+declare function includes(arrOrStr: unknown, item: unknown): boolean;
+/**
+ * Joins array elements into a string separated by a delimiter.
+ *
+ * @example `join(["Apple", "Banana"], ", ")` => `"Apple, Banana"`
+ */
+declare function join(arr: unknown, separator?: string): string;
+/**
+ * Returns the first item in an array.
+ *
+ * @example `first(["a", "b", "c"])` => `"a"`
+ */
+declare function first(arr: unknown): unknown;
+/**
+ * Returns the last item in an array.
+ *
+ * @example `last(["a", "b", "c"])` => `"c"`
+ */
+declare function last(arr: unknown): unknown;
+/**
+ * Removes null, undefined, and empty string elements from an array.
+ *
+ * @example `compact(["a", null, "b", ""])` => `["a", "b"]`
+ */
+declare function compact(arr: unknown): unknown[];
+/**
+ * Removes duplicate items from an array.
+ *
+ * @example `unique(["a", "b", "a"])` => `["a", "b"]`
+ */
+declare function unique(arr: unknown): unknown[];
+/**
+ * Returns the length of an array, string, or object.
+ *
+ * @example `length("hello")` => `5`
+ */
+declare function length(val: unknown): number;
+/**
+ * Rounds a number to a specified number of decimal places.
+ *
+ * @example `round(3.14159, 2)` => `3.14`
+ */
+declare function round(val: unknown, decimals?: number): number;
+/**
+ * Clamps a number between a minimum and maximum threshold.
+ *
+ * @example `clamp(150, 0, 100)` => `100`
+ */
+declare function clamp(val: unknown, minVal: unknown, maxVal: unknown): number;
+declare function ceil(val: unknown): number;
+declare function floor(val: unknown): number;
+declare function abs(val: unknown): number;
+declare function min(...args: unknown[]): number;
+declare function max(...args: unknown[]): number;
+declare function pow(base: unknown, exp: unknown): number;
+declare function sqrt(val: unknown): number;
+declare function sum(arr: unknown): number;
+declare function count(val: unknown): number;
+/**
+ * Returns a fallback value if the target value is undefined, null, or an empty string.
+ *
+ * @example `default(siblingData.title, "Untitled")` => `"Untitled"`
+ */
+declare function defaultValue(val: unknown, fallback: unknown): unknown;
+/**
+ * Returns the first non-empty value among the arguments provided.
+ *
+ * @example `coalesce(null, "", "Fallback")` => `"Fallback"`
+ */
+declare function coalesce(...args: unknown[]): unknown;
+/**
+ * Checks if a value is empty (undefined, null, empty string, empty array, or empty object).
+ *
+ * @example `isEmpty([])` => `true`
+ */
+declare function isEmpty(val: unknown): boolean;
+/**
+ * Safely accesses a nested object property by a dot-separated key path.
+ *
+ * @example `get(siblingData, "author.name", "Guest")` => `"John"`
+ */
+declare function get(obj: unknown, path: unknown, fallback?: unknown): unknown;
+/**
+ * Registers all Dyrected built-in helper functions onto a Jexl evaluation instance.
+ */
+declare function registerJexlHelpers(jexlInstance?: typeof jexl): void;
+/**
+ * Standard shared evaluator for JEXL expressions across server and browser.
+ * Injects math namespace and standard helpers into the context.
+ */
+declare function evaluateJexl(expression: string, context?: Record<string, any>): Promise<any>;
+/**
+ * Synchronous standard shared evaluator for JEXL expressions.
+ * Injects math namespace and standard helpers into the context.
+ */
+declare function evaluateJexlSync(expression: string, context?: Record<string, any>): any;
+/** List of all built-in Jexl helper function names for AST validation. */
+declare const BUILTIN_JEXL_HELPERS: readonly ["slugify", "lower", "upper", "trim", "capitalize", "truncate", "readingTime", "wordCount", "replace", "startsWith", "endsWith", "now", "today", "formatDate", "addDays", "diffDays", "isPast", "isFuture", "includes", "join", "first", "last", "compact", "unique", "length", "round", "clamp", "default", "coalesce", "isEmpty", "get"];
+
+type AnyHookFn = (args: any) => any;
+type AnyHook = AnyHookFn | DeclarativeHookExpression;
+/**
+ * Run a list of hook functions sequentially.
+ *
+ * Each hook receives the output of the previous hook merged back into the
+ * original `args`. When a hook returns a non-undefined value it becomes the
+ * `data` / `doc` for the next hook in the chain.
+ *
+ * Pass `{ isolated: true }` for hooks that run **after** a DB write has already
+ * been committed (`afterChange`, `afterDelete`). In isolated mode each hook is
+ * wrapped in a try/catch so a failing side-effect (email, webhook, etc.) never
+ * surfaces as an HTTP 500 to the caller — the write already succeeded.
+ */
+declare function runCollectionHooks(hooks: AnyHook[] | undefined, args: {
+    data?: unknown;
+    doc?: unknown;
+    query?: unknown;
+    user?: unknown;
+    req?: unknown;
+    db?: unknown;
+    operation?: "create" | "update" | "delete";
+    [key: string]: unknown;
+}, options?: {
+    isolated?: boolean;
+    surface?: "collection.beforeRead" | "collection.afterRead" | "collection.beforeChange" | "global.beforeRead" | "global.afterRead" | "global.beforeChange";
+    path?: string;
+}): Promise<any>;
+/**
+ * Execute field-level `beforeChange` hooks recursively on a data payload.
+ *
+ * Traverses `array`, `object`, and `blocks` fields depth-first so that nested
+ * field hooks fire on every item automatically.
+ */
+declare function executeFieldBeforeChange(fields: Field[], data: Record<string, unknown>, originalDoc: Record<string, unknown> | null, user: unknown, db?: unknown, pathPrefix?: string): Promise<Record<string, unknown>>;
+/**
+ * Execute field-level `afterRead` hooks recursively on a document.
+ *
+ * Traverses `array`, `object`, and `blocks` fields depth-first so that nested
+ * field hooks fire on every item automatically.
+ */
+declare function executeFieldAfterRead(fields: Field[], doc: Record<string, unknown>, user: unknown, db?: unknown): Promise<Record<string, unknown>>;
+
+/**
+ * Generate an OpenAPI 3.0 specification based on the Dyrected configuration.
+ */
+declare function generateOpenApi(config: DyrectedConfig): any;
+
+declare const WORKFLOW_HISTORY_COLLECTION = "__workflow_history";
+declare const LIFECYCLE_EVENTS_COLLECTION = "__lifecycle_events";
+/**
+ * Role mapping for {@link definePublishingWorkflow}. Map your app's own role
+ * values onto the publishing workflow's two capability tiers.
+ */
+interface PublishingWorkflowOptions {
+    /** Role values allowed to edit and submit for review. Defaults to `["editor"]`. */
+    editors?: string[];
+    /** Role values allowed to also publish and unpublish. Defaults to `["publisher", "admin"]`. */
+    publishers?: string[];
+}
+/**
+ * Build a `draft → in review → published` editorial workflow, mapping your own
+ * role values onto its capability tiers. Reach for this instead of
+ * {@link publishingWorkflow} when your roles aren't named
+ * `editor`/`publisher`/`admin`.
+ *
+ * @example
+ * workflow: definePublishingWorkflow({
+ *   editors: ["writer"],
+ *   publishers: ["managing-editor", "admin"],
+ * })
+ */
+declare function definePublishingWorkflow(options?: PublishingWorkflowOptions): WorkflowConfig;
+/**
+ * The default `draft → in review → published` editorial workflow, using the
+ * conventional role names `editor`, `publisher`, and `admin`. Shorthand for
+ * `definePublishingWorkflow()` — use {@link definePublishingWorkflow} to map
+ * your own role names onto its capability tiers.
+ */
+declare function publishingWorkflow(): WorkflowConfig;
+declare function simplePublishingWorkflow(): WorkflowConfig;
+declare function workflowCapabilities(workflow: WorkflowConfig, user?: AuthenticatedUser): Set<string>;
+declare function canViewWorkflowDraft(workflow: WorkflowConfig, user?: AuthenticatedUser): boolean;
+declare function availableWorkflowTransitions(workflow: WorkflowConfig, state: string, user?: AuthenticatedUser): WorkflowTransition[];
+declare function initializeWorkflowDocument(data: Record<string, unknown>, workflow: WorkflowConfig): {
+    __workflow: {
+        state: string;
+        revision: number;
+    };
+};
+/** The state a legacy document is treated as: the published one, else the last. */
+declare function publishedStateName(workflow: WorkflowConfig): string;
+declare function materializeWorkflowDocument(doc: BaseDocument, workflow: WorkflowConfig, user?: AuthenticatedUser): BaseDocument | null;
+declare function createLifecycleEvent(args: {
+    name: LifecycleEventName;
+    collection: string;
+    documentId: string;
+    actorId?: string;
+    payload: Record<string, unknown>;
+}): LifecycleEvent;
+declare function dispatchLifecycleEvent(config: DyrectedConfig, event: LifecycleEvent): Promise<void>;
+declare function dispatchPendingLifecycleEvents(config: DyrectedConfig, limit?: number): Promise<number>;
+declare function saveWorkflowDraft(args: {
+    config: DyrectedConfig;
+    collection: CollectionConfig;
+    id: string;
+    originalDoc: BaseDocument;
+    data: Record<string, unknown>;
+    user?: AuthenticatedUser;
+}): Promise<{
+    doc: BaseDocument;
+    event: LifecycleEvent;
+}>;
+declare function createWorkflowDocument(args: {
+    config: DyrectedConfig;
+    collection: CollectionConfig;
+    data: Record<string, unknown>;
+    user?: AuthenticatedUser;
+}): Promise<{
+    doc: BaseDocument;
+    event: LifecycleEvent;
+}>;
+declare function transitionWorkflow(args: {
+    config: DyrectedConfig;
+    collection: CollectionConfig;
+    id: string;
+    transitionName: string;
+    expectedRevision?: number;
+    comment?: string;
+    user?: AuthenticatedUser;
+    req: HookRequestContext;
+}): Promise<BaseDocument>;
+
+/**
+ * Normalizes a DetailItem (which may be a shorthand string) into a standard DetailItem object.
+ *
+ * @example `normalizeDetailItem('title')` => `{ type: 'field', field: 'title' }`
+ */
+declare function normalizeDetailItem(item: DetailItem): Exclude<DetailItem, string>;
+/**
+ * Creates a section container in a Detail View layout.
+ *
+ * @example
+ * ```ts
+ * displaySection('Product Information', [
+ *   displayField('name', { span: 8 }),
+ *   displayField('sku', { span: 4 }),
+ * ], { span: 8, icon: 'package' })
+ * ```
+ */
+declare function displaySection(title: string, items: DetailItem[], options?: DetailSectionOptions): DetailSection;
+/**
+ * Creates a single tab entry for use within `displayTabs()`.
+ */
+declare function displayTab(label: string, items: DetailItem[], options?: DetailTabOptions): DetailTab;
+/**
+ * Creates a tabbed container in a Detail View layout.
+ *
+ * @example
+ * ```ts
+ * displayTabs([
+ *   displayTab('Specifications', [displayField('specs')]),
+ *   displayTab('Reviews', [displayRepeat('reviews', [...])], { badge: '3' }),
+ * ])
+ * ```
+ */
+declare function displayTabs(tabs: DetailTab[], options?: DetailTabsOptions): DetailTabs;
+/**
+ * Creates a multi-column grid layout inside a section or detail schema.
+ *
+ * @example
+ * ```ts
+ * displayGrid(2, [
+ *   displayField('firstName'),
+ *   displayField('lastName'),
+ * ])
+ * ```
+ */
+declare function displayGrid(columns: number, items: DetailItem[], options?: DetailGridOptions): DetailGrid;
+/**
+ * Declares a field for presentation in a Detail View.
+ *
+ * @example
+ * ```ts
+ * displayField('status', { display: 'badge', badgeColors: { active: 'emerald' } })
+ * displayField('author.name', { label: 'Written By' })
+ * displayField('specs', { display: 'key-value', keyLabel: 'Spec', valueLabel: 'Detail' })
+ * ```
+ */
+declare function displayField(fieldName: string, options?: DisplayFieldOptions): DetailField;
+/**
+ * Renders an array/repeated field using a delegated display schema.
+ * Supports `'table'`, `'cards'`, and `'list'` layouts.
+ *
+ * @example
+ * ```ts
+ * displayRepeat('items', [
+ *   displayField('product'),
+ *   displayField('quantity'),
+ *   displayField('price'),
+ * ], { layout: 'table' })
+ * ```
+ */
+declare function displayRepeat(fieldName: string, items: DetailItem[], options?: DetailRepeatOptions): DetailRepeat;
+/**
+ * Renders a computed value calculated from document and user context.
+ *
+ * @example
+ * ```ts
+ * displayComputed('Reading Time', 'math.ceil(doc.wordCount / 200) + " min"')
+ * displayComputed('Total', ({ doc }) => `$${doc.price * doc.quantity}`)
+ * ```
+ */
+declare function displayComputed<TDoc = any>(label: string, expressionOrOptionsOrHandler: string | DetailComputedOptions<TDoc> | ComputedHandler<TDoc>, options?: DetailComputedOptions<TDoc>): DetailComputed<TDoc>;
+/**
+ * Creates a horizontal divider line in a Detail View layout.
+ *
+ * @example
+ * ```ts
+ * displayDivider({ spacing: 'md' })
+ * ```
+ */
+declare function displayDivider(options?: DetailDividerOptions): DetailDivider;
+/**
+ * Renders static text, heading, callout, or information notice in a Detail View layout.
+ *
+ * @example
+ * ```ts
+ * displayText('Please note this action is permanent.', { variant: 'warning' })
+ * displayText('Overview Notes', { variant: 'heading' })
+ * ```
+ */
+declare function displayText(content: string, options?: DetailTextOptions): DetailText;
+/**
+ * Renders a custom React component registered by name in the Admin panel.
+ *
+ * @example
+ * ```ts
+ * displayCustom('AnalyticsChart', { props: { timeframe: '30d' } })
+ * ```
+ */
+declare function displayCustom<TDoc = any>(name: string, options?: DetailCustomOptions<TDoc>): DetailCustom<TDoc>;
+/**
+ * Alias for `displayCustom` to render a custom component in a Detail View layout.
+ */
+declare function displayCustomComponent<TDoc = any>(name: string, options?: DetailCustomOptions<TDoc>): DetailCustom<TDoc>;
+/**
+ * Evaluates server-side computed functions and JEXL expressions from a detail schema
+ * and attaches them to `doc._meta.computed`.
+ */
+declare function evaluateDetailComputed(detail: DetailSchema | boolean | undefined, doc: any, user: any, db: any): Promise<any>;
+/**
+ * Generates an automatic default 12-column Detail View schema for a collection or global
+ * when no explicit `detail` configuration is provided.
+ */
+declare function generateDefaultDetailSchema(schema: {
+    fields?: Field[];
+    labels?: {
+        singular?: string;
+        plural?: string;
+    };
+    label?: string;
+    slug?: string;
+}): DetailSchema;
+/**
+ * Evaluates whether a detail item should be visible based on its `options.visible` rule.
+ * Supports boolean values or JEXL expressions evaluated against `{ doc, user }`.
+ * Works consistently for top-level and nested detail items.
+ *
+ * @example
+ * ```ts
+ * isDetailItemVisible(displayField('secret', { visible: false }), doc, user) // false
+ * isDetailItemVisible(displayField('publishedAt', { visible: "doc.status == 'published'" }), doc, user)
+ * ```
+ */
+declare function isDetailItemVisible(item: DetailItem, doc: any, user?: any): boolean;
+
+declare function getAIModel(config?: DyrectedConfig): LanguageModel;
+declare function formatAIErrorMessage(error: any): string;
+declare function buildDyrectedSystemPrompt(context: DyrectedAIContext): string;
+interface AIAgentOptions {
+    db: DatabaseAdapter;
+    config: DyrectedConfig;
+    projectId: string;
+    userId: string;
+    userName?: string;
+    userRole?: string;
+    user?: AuthenticatedUser;
+}
+declare class AIAgent {
+    private db;
+    private config;
+    private projectId;
+    private userId;
+    private userName?;
+    private userRole?;
+    private user?;
+    private contextCache;
+    constructor(options: AIAgentOptions);
+    getContext(): Promise<DyrectedAIContext>;
+    getThread(threadId: string): Promise<AIThread | null>;
+    updateThreadTitle(threadId: string, title: string): Promise<void>;
+    createThread(title?: string): Promise<AIThread>;
+    listThreads(limit?: number): Promise<AIThread[]>;
+    deleteThread(threadId: string): Promise<boolean>;
+    clearAllThreads(): Promise<number>;
+    getMessages(threadId: string): Promise<AIMessage[]>;
+    persistUserMessage(threadId: string, content: string): Promise<AIMessage>;
+    persistAssistantMessage(threadId: string, content: string, metadata?: Record<string, unknown>, parts?: any[]): Promise<AIMessage>;
+    generateTitle(userMessage: string): Promise<string>;
+    streamReply(threadId: string, userMessage: string): AsyncGenerator<string, {
+        text: string;
+        usage?: any;
+        finishReason: string;
+    }, void>;
+    createStreamResponse(threadId: string, userMessage: string, clientMessages?: any[], abortSignal?: AbortSignal, requestId?: string): Promise<Response>;
+}
+
+declare function createDyrectedAITools({ db, config, user, projectId, }: {
+    db: DatabaseAdapter;
+    config: DyrectedConfig;
+    user?: AuthenticatedUser;
+    projectId: string;
+}): Record<string, any>;
+
+interface IndexDocumentOptions {
+    db: DatabaseAdapter;
+    config: DyrectedConfig;
+    collection: string;
+    doc: Record<string, unknown>;
+    projectId: string;
+    force?: boolean;
+}
+interface DeleteDocumentChunksOptions {
+    db: DatabaseAdapter;
+    collection: string;
+    documentId: string;
+    projectId: string;
+}
+interface ReindexCollectionOptions {
+    db: DatabaseAdapter;
+    config: DyrectedConfig;
+    collection: string;
+    projectId: string;
+    force?: boolean;
+}
+interface ReindexAllOptions {
+    db: DatabaseAdapter;
+    config: DyrectedConfig;
+    projectId: string;
+    force?: boolean;
+}
+interface RAGSearchOptions {
+    db: DatabaseAdapter;
+    config: DyrectedConfig;
+    query: string;
+    projectId: string;
+    collections?: string[];
+    limit?: number;
+    minScore?: number;
+    user?: AuthenticatedUser;
+}
+declare class RAGService {
+    private static embeddingServiceCache;
+    private static getEmbeddingService;
+    /**
+     * Determines whether RAG indexing is enabled for a given collection.
+     */
+    static isCollectionRAGEnabled(config: DyrectedConfig, col: CollectionConfig): boolean;
+    /**
+     * Indexes a single document's text fields into `_dyrected_ai_chunks`.
+     */
+    static indexDocument(options: IndexDocumentOptions): Promise<{
+        indexed: number;
+        skipped: number;
+    }>;
+    /**
+     * Deletes all vector chunks associated with a specific document.
+     */
+    static deleteDocumentChunks(options: DeleteDocumentChunksOptions): Promise<number>;
+    /**
+     * Reindexes all documents in a specific collection.
+     */
+    static reindexCollection(options: ReindexCollectionOptions): Promise<{
+        collection: string;
+        totalDocs: number;
+        indexedChunks: number;
+    }>;
+    /**
+     * Reindexes all RAG-enabled collections across the project.
+     */
+    static reindexAll(options: ReindexAllOptions): Promise<{
+        collections: Array<{
+            collection: string;
+            totalDocs: number;
+            indexedChunks: number;
+        }>;
+        totalChunks: number;
+    }>;
+    /**
+     * Performs semantic vector search over project chunks with access filtering.
+     */
+    static search(options: RAGSearchOptions): Promise<{
+        query: string;
+        resultsCount: number;
+        sources: RAGSearchResult[];
+    }>;
+}
+
+/**
+ * Content normalizer for Dyrected CMS fields before chunking and embedding.
+ * Converts raw rich-text ASTs (Lexical, Slate, TipTap, custom blocks), HTML,
+ * JSON objects, and arrays into clean, structured Markdown.
+ */
+/**
+ * Normalizes an unknown field value into clean Markdown/text.
+ */
+declare function normalizeFieldValue(value: unknown, _fieldType?: string): string;
+/**
+ * Extracts searchable text from target fields of a document.
+ */
+declare function extractTextFromDoc(doc: Record<string, unknown>, targetFields?: string[]): Array<{
+    field: string;
+    text: string;
+}>;
+
+interface ChunkOptions {
+    /** Maximum target characters per chunk. Defaults to 1500 (~375-500 tokens). */
+    maxChunkSize?: number;
+    /** Overlap in characters between consecutive chunks. Defaults to 150. */
+    chunkOverlap?: number;
+    /** Hierarchy of string separators for recursive splitting. */
+    separators?: string[];
+}
+interface ChunkResult {
+    text: string;
+    tokenCount: number;
+    index: number;
+}
+/**
+ * Computes a fast, collision-resistant 53-bit hex hash of a string.
+ * 100% isomorphic and pure JavaScript (safe across Node.js, Vite, Nuxt, and browsers).
+ */
+declare function hashContent(content: string, seed?: number): string;
+/**
+ * Estimates token count based on standard ~4 characters per token heuristic.
+ */
+declare function estimateTokens(text: string): number;
+/**
+ * Recursively splits a text into coherent chunks with overlap.
+ */
+declare function chunkText(text: string, options?: ChunkOptions): ChunkResult[];
+
+declare function getEmbeddingModel(config?: DyrectedConfig): EmbeddingModel;
+declare class EmbeddingService {
+    private config?;
+    private model;
+    constructor(config?: DyrectedConfig);
+    embedText(text: string): Promise<number[]>;
+    embedBatch(texts: string[]): Promise<number[][]>;
+}
+/**
+ * Computes cosine similarity between two float vector arrays.
+ * Returns a value between -1.0 and 1.0 (typically 0.0 to 1.0 for normalized text embeddings).
+ */
+declare function cosineSimilarity(a: number[], b: number[]): number;
+
+type TopLevelFieldName<TFields extends readonly Field[]> = Extract<TFields[number], {
+    name: string;
+}>["name"];
+type InvalidReference<TLabel extends string, TReceived, TExpected extends string> = {
+    __dyrected_error__: `Invalid ${TLabel}`;
+    __dyrected_received__: TReceived;
+    __dyrected_expected__: TExpected;
+};
+type TypedReference<TValue, TExpected extends string, TLabel extends string> = TValue extends undefined ? undefined : TValue extends TExpected ? TValue : InvalidReference<TLabel, TValue, TExpected>;
+type TypedReferenceList<TValue, TExpected extends string, TLabel extends string> = TValue extends readonly unknown[] ? {
+    [K in keyof TValue]: TypedReference<TValue[K], TExpected, TLabel>;
+} : InvalidReference<`${TLabel} list`, TValue, TExpected>;
+type TypedCollectionAdmin<TFields extends readonly Field[], TDoc extends object, TAdmin extends NonNullable<CollectionConfig<TDoc>["admin"]> | undefined> = Omit<NonNullable<CollectionConfig<TDoc>["admin"]>, "useAsTitle" | "defaultColumns" | "searchableFields"> & {
+    useAsTitle?: TypedReference<PropertyType<NonNullable<TAdmin>, "useAsTitle">, TopLevelFieldName<TFields>, "field name">;
+    defaultColumns?: TypedReferenceList<PropertyType<NonNullable<TAdmin>, "defaultColumns">, TopLevelFieldName<TFields>, "field name">;
+    searchableFields?: TypedReferenceList<PropertyType<NonNullable<TAdmin>, "searchableFields">, TopLevelFieldName<TFields>, "field name">;
+};
+type TypedNestedFieldAdmin<TFields extends readonly Field[], TAdmin extends NonNullable<Field["admin"]> | undefined> = Omit<NonNullable<Field["admin"]>, "useAsTitle"> & {
+    useAsTitle?: TypedReference<PropertyType<NonNullable<TAdmin>, "useAsTitle">, TopLevelFieldName<TFields>, "field name">;
+};
+type PropertyType<T, K extends PropertyKey> = T extends {
+    [P in K]?: infer V;
+} ? V : never;
+type PolicyNames<TPolicies> = Extract<keyof NonNullable<TPolicies>, string>;
+type TypedPolicyReference<TPolicyNames extends string, TPolicy extends string | undefined> = {
+    policy: TypedReference<TPolicy, TPolicyNames, "policy name">;
+    params?: Record<string, unknown>;
+};
+type TypedAccessRule<TRule, TPolicyNames extends string> = Exclude<TRule, {
+    policy: string;
+}> | TypedPolicyReference<TPolicyNames, Extract<PropertyType<TRule, "policy">, string>>;
+type RetypeAccessObject<TAccess, TKeys extends PropertyKey, TPolicyNames extends string> = TAccess extends object ? Omit<TAccess, Extract<TKeys, keyof TAccess>> & {
+    [K in Extract<TKeys, keyof TAccess>]?: TypedAccessRule<PropertyType<TAccess, K>, TPolicyNames>;
+} : TAccess;
+type TypedFieldAccess<TAccess, TPolicyNames extends string> = RetypeAccessObject<TAccess, "read" | "create" | "update", TPolicyNames>;
+type TypedCollectionAccess<TAccess, TPolicyNames extends string> = RetypeAccessObject<TAccess, "read" | "create" | "update" | "delete" | "readAudit", TPolicyNames>;
+type TypedGlobalAccess<TAccess, TPolicyNames extends string> = RetypeAccessObject<TAccess, "read" | "update", TPolicyNames>;
+type SlugOf<T> = T extends {
+    slug: infer TSlug extends string;
+} ? TSlug : never;
+type CollectionSlug<TCollections extends readonly unknown[]> = SlugOf<TCollections[number]>;
+type BlockSlug<TBlocks extends readonly unknown[]> = SlugOf<TBlocks[number]>;
+type UploadCollectionSlug<TCollections extends readonly unknown[]> = SlugOf<Extract<TCollections[number], {
+    upload: unknown;
+}>>;
+type AuthCollectionSlug<TCollections extends readonly unknown[]> = SlugOf<Extract<TCollections[number], {
+    auth: unknown;
+}>>;
+type CollectionBySlug<TCollections extends readonly unknown[], TSlug extends string> = Extract<TCollections[number], {
+    slug: TSlug;
+}>;
+type CollectionFieldNamesBySlug<TCollections extends readonly unknown[], TSlug extends string> = CollectionBySlug<TCollections, TSlug> extends {
+    fields: infer TFields extends readonly Field[];
+} ? TopLevelFieldName<TFields> : never;
+type WorkflowStateName<TWorkflow> = TWorkflow extends {
+    states: infer TStates extends readonly unknown[];
+} ? Extract<TStates[number], {
+    name: string;
+}>["name"] : never;
+type TypedWorkflowStateValue<TValue, TWorkflow> = TValue extends readonly unknown[] ? {
+    [K in keyof TValue]: TypedReference<TValue[K], WorkflowStateName<TWorkflow>, "workflow state name">;
+} : TypedReference<TValue, WorkflowStateName<TWorkflow>, "workflow state name">;
+type TypedWorkflowTransition<TTransition, TWorkflow> = Omit<TTransition, "from" | "to"> & {
+    from: TypedWorkflowStateValue<PropertyType<TTransition, "from">, TWorkflow>;
+    to: TypedReference<PropertyType<TTransition, "to">, WorkflowStateName<TWorkflow>, "workflow state name">;
+};
+type TypedWorkflow<TWorkflow> = TWorkflow extends {
+    transitions: infer TTransitions extends readonly unknown[];
+} ? Omit<TWorkflow, "initialState" | "draftState" | "transitions"> & {
+    initialState: TypedReference<PropertyType<TWorkflow, "initialState">, WorkflowStateName<TWorkflow>, "workflow state name">;
+    draftState?: TypedReference<PropertyType<TWorkflow, "draftState">, WorkflowStateName<TWorkflow>, "workflow state name">;
+    transitions: {
+        [K in keyof TTransitions]: TypedWorkflowTransition<TTransitions[K], TWorkflow>;
+    };
+} : TWorkflow;
+type TypedBlockForConfig<TBlock extends Block, TCollections extends readonly unknown[], TRootBlocks extends readonly Block[], TPolicyNames extends string> = Omit<TBlock, "fields"> & {
+    fields: TBlock["fields"] extends readonly Field[] ? TypedFields<TBlock["fields"], TCollections, TRootBlocks, TPolicyNames> : TBlock["fields"];
+};
+type TypedBlocksForConfig<TBlocks extends readonly Block[], TCollections extends readonly unknown[], TRootBlocks extends readonly Block[], TPolicyNames extends string> = {
+    [K in keyof TBlocks]: TBlocks[K] extends Block ? TypedBlockForConfig<TBlocks[K], TCollections, TRootBlocks, TPolicyNames> : TBlocks[K];
+};
+type TypedFieldForConfig<TField extends Field, TCollections extends readonly unknown[], TBlocks extends readonly Block[], TPolicyNames extends string> = TField extends {
+    type: "relationship";
+} ? Omit<TField, "relationTo" | "access"> & {
+    relationTo?: TypedReference<PropertyType<TField, "relationTo">, CollectionSlug<TCollections>, "collection slug">;
+    access?: TypedFieldAccess<NonNullable<TField["access"]>, TPolicyNames>;
+} : TField extends {
+    type: "image";
+} ? Omit<TField, "relationTo" | "access"> & {
+    relationTo?: TypedReference<PropertyType<TField, "relationTo">, UploadCollectionSlug<TCollections>, "upload collection slug">;
+    access?: TypedFieldAccess<NonNullable<TField["access"]>, TPolicyNames>;
+} : TField extends {
+    type: "richText";
+} ? Omit<TField, "uploadCollection" | "access"> & {
+    uploadCollection?: TypedReference<PropertyType<TField, "uploadCollection">, UploadCollectionSlug<TCollections>, "upload collection slug">;
+    access?: TypedFieldAccess<NonNullable<TField["access"]>, TPolicyNames>;
+} : TField extends {
+    type: "join";
+} ? Omit<TField, "collection" | "on" | "access"> & {
+    collection?: TypedReference<PropertyType<TField, "collection">, CollectionSlug<TCollections>, "collection slug">;
+    on?: TypedReference<PropertyType<TField, "on">, CollectionFieldNamesBySlug<TCollections, Extract<PropertyType<TField, "collection">, string>> | TopLevelFieldName<Extract<CollectionBySlug<TCollections, CollectionSlug<TCollections>>, {
+        fields: readonly Field[];
+    }>["fields"]>, "field name">;
+    access?: TypedFieldAccess<NonNullable<TField["access"]>, TPolicyNames>;
+} : TField extends {
+    type: "blocks";
+} ? Omit<TField, "blocks" | "blockReferences" | "access"> & {
+    blocks?: TField["blocks"] extends readonly Block[] ? TypedBlocksForConfig<TField["blocks"], TCollections, TBlocks, TPolicyNames> : TField["blocks"];
+    blockReferences?: TypedReferenceList<PropertyType<TField, "blockReferences">, BlockSlug<TBlocks>, "block slug">;
+    access?: TypedFieldAccess<NonNullable<TField["access"]>, TPolicyNames>;
+} : TField extends {
+    type: "array";
+    fields: infer TSubFields extends readonly Field[];
+} ? Omit<TField, "fields" | "access" | "admin"> & {
+    fields: TypedFields<TSubFields, TCollections, TBlocks, TPolicyNames>;
+    access?: TypedFieldAccess<NonNullable<TField["access"]>, TPolicyNames>;
+    admin?: TypedNestedFieldAdmin<TSubFields, PropertyType<TField, "admin">>;
+} : TField extends {
+    type: "object";
+    fields: infer TSubFields extends readonly Field[];
+} ? Omit<TField, "fields" | "access" | "admin"> & {
+    fields: TypedFields<TSubFields, TCollections, TBlocks, TPolicyNames>;
+    access?: TypedFieldAccess<NonNullable<TField["access"]>, TPolicyNames>;
+    admin?: TypedNestedFieldAdmin<TSubFields, PropertyType<TField, "admin">>;
+} : TField extends {
+    fields: infer TSubFields extends readonly Field[];
+} ? Omit<TField, "fields" | "access"> & {
+    fields: TypedFields<TSubFields, TCollections, TBlocks, TPolicyNames>;
+    access?: TypedFieldAccess<NonNullable<TField["access"]>, TPolicyNames>;
+} : Omit<TField, "access"> & {
+    access?: TypedFieldAccess<NonNullable<TField["access"]>, TPolicyNames>;
+};
+type TypedFields<TFields extends readonly Field[], TCollections extends readonly unknown[], TBlocks extends readonly Block[], TPolicyNames extends string> = {
+    [K in keyof TFields]: TFields[K] extends Field ? TypedFieldForConfig<TFields[K], TCollections, TBlocks, TPolicyNames> : TFields[K];
+};
+type TypedCollectionForConfig<TCollection extends CollectionConfig<any>, TCollections extends readonly CollectionConfig<any>[], TBlocks extends readonly Block[], TPolicyNames extends string> = Omit<TCollection, "fields" | "access" | "workflow" | "views"> & {
+    fields: TCollection["fields"] extends readonly Field[] ? TypedFields<TCollection["fields"], TCollections, TBlocks, TPolicyNames> : TCollection["fields"];
+    access?: TypedCollectionAccess<NonNullable<TCollection["access"]>, TPolicyNames>;
+    workflow?: TypedWorkflow<NonNullable<TCollection["workflow"]>>;
+    views?: TCollection["views"];
+};
+type TypedCollections<TCollections extends readonly CollectionConfig<any>[], TAllCollections extends readonly CollectionConfig<any>[], TBlocks extends readonly Block[], TPolicyNames extends string> = {
+    [K in keyof TCollections]: TCollections[K] extends CollectionConfig<any> ? TypedCollectionForConfig<TCollections[K], TAllCollections, TBlocks, TPolicyNames> : TCollections[K];
+};
+type TypedGlobalForConfig<TGlobal extends GlobalConfig<any>, TCollections extends readonly CollectionConfig<any>[], TBlocks extends readonly Block[], TPolicyNames extends string> = Omit<TGlobal, "fields" | "access"> & {
+    fields: TGlobal["fields"] extends readonly Field[] ? TypedFields<TGlobal["fields"], TCollections, TBlocks, TPolicyNames> : TGlobal["fields"];
+    access?: TypedGlobalAccess<NonNullable<TGlobal["access"]>, TPolicyNames>;
+};
+type TypedGlobals<TGlobals extends readonly GlobalConfig<any>[], TCollections extends readonly CollectionConfig<any>[], TBlocks extends readonly Block[], TPolicyNames extends string> = {
+    [K in keyof TGlobals]: TGlobals[K] extends GlobalConfig<any> ? TypedGlobalForConfig<TGlobals[K], TCollections, TBlocks, TPolicyNames> : TGlobals[K];
+};
+type TypedAdminAuthConfig<TAdminAuth, TCollections extends readonly CollectionConfig<any>[]> = TAdminAuth extends object ? Omit<TAdminAuth, "collectionSlug"> & {
+    collectionSlug?: TypedReference<PropertyType<TAdminAuth, "collectionSlug">, AuthCollectionSlug<TCollections>, "auth collection slug">;
+} : TAdminAuth;
+/**
+ * Define a collection. When called without an explicit type argument, TypeScript
+ * automatically infers the document shape from the `fields` array you provide —
+ * no manual interface required:
+ *
+ * ```ts
+ * export const Posts = defineCollection({
+ *   slug: 'posts',
+ *   fields: [
+ *     defineTextField({ name: 'title', required: true }),
+ *     defineSelectField({ name: 'status', options: ['draft', 'published'], required: true }),
+ *   ],
+ *   hooks: {
+ *     beforeChange: [({ data }) => {
+ *       // data is { title: string; status: 'draft' | 'published' } — fully inferred
+ *     }],
+ *   },
+ * })
+ * ```
+ *
+ * When you need a richer interface (e.g. with methods, JSDoc, or types that
+ * can't be derived from fields), pass it explicitly:
+ *
+ * ```ts
+ * interface Post { id: string; title: string; status: 'draft' | 'published' }
+ *
+ * export const Posts = defineCollection<Post>({ ... })
+ * ```
+ */
+declare function defineCollection<const TSlug extends string, const TFields extends Field[], const TAdmin extends NonNullable<CollectionConfig<Prettify<{
+    id: string;
+} & InferDocShape<TFields> & SystemDocFields & AuthDocFields>>["admin"]> | undefined, const TConfig extends Omit<CollectionConfig<Prettify<{
+    id: string;
+} & InferDocShape<TFields> & SystemDocFields & AuthDocFields>>, "fields" | "auth" | "admin"> & {
+    slug: TSlug;
+    fields: TFields;
+    auth: true | AuthConfig;
+    admin?: TypedCollectionAdmin<TFields, Prettify<{
+        id: string;
+    } & InferDocShape<TFields> & SystemDocFields & AuthDocFields>, TAdmin>;
+}>(config: TConfig): TConfig;
+declare function defineCollection<const TSlug extends string, const TFields extends Field[], const TAdmin extends NonNullable<CollectionConfig<Prettify<{
+    id: string;
+} & InferDocShape<TFields> & SystemDocFields & UploadDocFields>>["admin"]> | undefined, const TConfig extends Omit<CollectionConfig<Prettify<{
+    id: string;
+} & InferDocShape<TFields> & SystemDocFields & UploadDocFields>>, "fields" | "upload" | "admin"> & {
+    slug: TSlug;
+    fields: TFields;
+    upload: true;
+    admin?: TypedCollectionAdmin<TFields, Prettify<{
+        id: string;
+    } & InferDocShape<TFields> & SystemDocFields & UploadDocFields>, TAdmin>;
+}>(config: TConfig): TConfig;
+declare function defineCollection<const TSlug extends string, const TFields extends Field[], const TAdmin extends NonNullable<CollectionConfig<Prettify<{
+    id: string;
+} & InferDocShape<TFields> & SystemDocFields>>["admin"]> | undefined, const TConfig extends Omit<CollectionConfig<Prettify<{
+    id: string;
+} & InferDocShape<TFields> & SystemDocFields>>, "fields" | "admin"> & {
+    slug: TSlug;
+    fields: TFields;
+    admin?: TypedCollectionAdmin<TFields, Prettify<{
+        id: string;
+    } & InferDocShape<TFields> & SystemDocFields>, TAdmin>;
+}>(config: TConfig): TConfig;
+declare function defineCollection<TDoc extends object, const TConfig extends CollectionConfig<TDoc>>(config: TConfig): TConfig;
+/**
+ * Define a global (singleton document). TypeScript automatically infers the
+ * document shape from the `fields` array, or you can pass an explicit type:
+ *
+ * ```ts
+ * // Inferred — no interface needed
+ * export const Settings = defineGlobal({
+ *   slug: 'site-settings',
+ *   fields: [
+ *     defineTextField({ name: 'siteName', required: true }),
+ *     defineBooleanField({ name: 'maintenanceMode' }),
+ *   ],
+ *   hooks: {
+ *     afterChange: [({ doc }) => {
+ *       // doc.siteName is string, doc.maintenanceMode is boolean | undefined
+ *       if (doc.maintenanceMode) alertOnCall()
+ *     }],
+ *   },
+ * })
+ *
+ * // Explicit type
+ * interface SiteSettings { siteName: string; maintenanceMode?: boolean }
+ * export const Settings = defineGlobal<SiteSettings>({ ... })
+ * ```
+ */
+declare function defineGlobal<const TSlug extends string, const TFields extends Field[], const TConfig extends Omit<GlobalConfig<Prettify<InferDocShape<TFields>>>, "fields"> & {
+    slug: TSlug;
+    fields: TFields;
+}>(config: TConfig): TConfig;
+declare function defineGlobal<TDoc extends object, const TConfig extends GlobalConfig<TDoc>>(config: TConfig): TConfig;
+/**
+ * Define the root Dyrected configuration.
+ *
+ * This is the single object passed to `createDyrectedApp`. It wires together
+ * the database adapter, collections, globals, storage, email, and all other
+ * server-level configuration.
+ */
+declare function defineConfig<TUser extends AuthenticatedUser = AuthenticatedUser, const TBlocks extends readonly Block[] = [], const TCollections extends readonly CollectionConfig<any>[] = [], const TGlobals extends readonly GlobalConfig<any>[] = [], const TAdminAuth extends DyrectedConfig<TUser>["adminAuth"] | undefined = undefined, const TPolicies extends Record<string, AccessPolicyResolver<Record<string, unknown>, TUser> | string | boolean> | undefined = undefined>(config: Omit<DyrectedConfig<TUser>, "blocks" | "collections" | "globals" | "accessPolicies" | "adminAuth"> & {
+    blocks?: TypedBlocksForConfig<TBlocks, TCollections, TBlocks, PolicyNames<TPolicies>>;
+    collections: TypedCollections<TCollections, TCollections, TBlocks, PolicyNames<TPolicies>>;
+    globals: TypedGlobals<TGlobals, TCollections, TBlocks, PolicyNames<TPolicies>>;
+    accessPolicies?: TPolicies;
+    adminAuth?: TypedAdminAuthConfig<TAdminAuth, TCollections>;
+}): typeof config;
+/**
+ * Define a single field of any type. This is an identity helper: it returns the
+ * field unchanged at runtime but preserves the exact literal type, so document
+ * shapes still infer correctly when the field is placed in a `defineCollection`
+ * or `defineGlobal` `fields` array.
+ *
+ * Use it when you want autocomplete and type-checking on a field written on its
+ * own — for example a shared field reused across collections:
+ *
+ * ```ts
+ * const slug = defineField({ name: 'slug', type: 'text', required: true, unique: true })
+ *
+ * export const Posts = defineCollection({ slug: 'posts', fields: [slug, ...] })
+ * ```
+ *
+ * For a field of a known type, prefer the dedicated helper (e.g.
+ * {@link defineTextField}) so you don't have to repeat the `type`.
+ */
+declare function defineField<const T extends Field>(field: T): T;
+/**
+ * Define a {@link Block} for use in a `blocks` field. Identity helper that
+ * preserves the block's literal type (slug + fields) so `blocks`-field values
+ * stay fully inferred.
+ *
+ * ```ts
+ * const Hero = defineBlock({
+ *   slug: 'hero',
+ *   fields: [defineTextField({ name: 'heading', required: true })],
+ * })
+ *
+ * defineBlocksField({ name: 'layout', blocks: [Hero] })
+ * ```
+ */
+declare function defineBlock<const T extends Block>(block: T): T;
+/** Define a `text` field. */
+declare const defineTextField: <const T extends Omit<TextField, "type">>(field: T) => T & {
+    type: "text";
+};
+/** Define a `textarea` field. */
+declare const defineTextareaField: <const T extends Omit<TextareaField, "type">>(field: T) => T & {
+    type: "textarea";
+};
+/** Define a `richText` field, including its editor `features` and `headingLevels`. */
+declare const defineRichTextField: <const T extends Omit<RichTextField, "type">>(field: T) => T & {
+    type: "richText";
+};
+/** Define a `number` field. */
+declare const defineNumberField: <const T extends Omit<NumberField, "type">>(field: T) => T & {
+    type: "number";
+};
+/** Define a `boolean` field. */
+declare const defineBooleanField: <const T extends Omit<BooleanField, "type">>(field: T) => T & {
+    type: "boolean";
+};
+/** Define a `date` field. */
+declare const defineDateField: <const T extends Omit<DateField, "type">>(field: T) => T & {
+    type: "date";
+};
+/** Define a `datetime` field. */
+declare const defineDateTimeField: <const T extends Omit<DateTimeField, "type">>(field: T) => T & {
+    type: "datetime";
+};
+/** Define a `time` field. */
+declare const defineTimeField: <const T extends Omit<TimeField, "type">>(field: T) => T & {
+    type: "time";
+};
+/** Define a `select` field. */
+declare const defineSelectField: <const T extends Omit<SelectField, "type">>(field: T) => T & {
+    type: "select";
+};
+/** Define a `multiSelect` field. */
+declare const defineMultiSelectField: <const T extends Omit<MultiSelectField, "type">>(field: T) => T & {
+    type: "multiSelect";
+};
+/** Define a `radio` field. */
+declare const defineRadioField: <const T extends Omit<RadioField, "type">>(field: T) => T & {
+    type: "radio";
+};
+/** Define a `relationship` field. */
+declare const defineRelationshipField: <const T extends Omit<RelationshipField, "type">>(field: T) => T & {
+    type: "relationship";
+};
+/** Define an `array` field. */
+declare const defineArrayField: <const T extends Omit<ArrayField, "type">>(field: T) => T & {
+    type: "array";
+};
+/** Define an `object` field. */
+declare const defineObjectField: <const T extends Omit<ObjectField, "type">>(field: T) => T & {
+    type: "object";
+};
+/** Define a `json` field. */
+declare const defineJsonField: <const T extends Omit<JsonField, "type">>(field: T) => T & {
+    type: "json";
+};
+/** Define a `blocks` field. */
+declare const defineBlocksField: <const T extends Omit<BlocksField, "type">>(field: T) => T & {
+    type: "blocks";
+};
+/** Define an `image` field. */
+declare const defineImageField: <const T extends Omit<ImageField, "type">>(field: T) => T & {
+    type: "image";
+};
+/** Define an `email` field. */
+declare const defineEmailField: <const T extends Omit<EmailField, "type">>(field: T) => T & {
+    type: "email";
+};
+/** Define a `url` field. */
+declare const defineUrlField: <const T extends Omit<UrlField, "type">>(field: T) => T & {
+    type: "url";
+};
+/** Define an `icon` field. */
+declare const defineIconField: <const T extends Omit<IconField, "type">>(field: T) => T & {
+    type: "icon";
+};
+/** Define a `join` field. */
+declare const defineJoinField: <const T extends Omit<JoinField, "type">>(field: T) => T & {
+    type: "join";
+};
+/** Define a layout-only `row` field. */
+declare const defineRowField: <const T extends Omit<RowField, "type">>(field: T) => T & {
+    type: "row";
+};
+/**
+ * Group fields under a named tab in the Admin edit form. Tabs are presentational
+ * only: `defineTab` returns the given fields unchanged except that each one's
+ * `admin.tab` is set to `label`, and the Admin panel renders fields that share a
+ * tab name together under that tab. Spread the result into a collection, global,
+ * or group `fields` array, and add one `defineTab` call per tab. Fields left
+ * without a tab are collected into a leading tab named after the collection.
+ *
+ * ```ts
+ * defineCollection({
+ *   slug: 'pages',
+ *   fields: [
+ *     ...defineTab({
+ *       label: 'Content',
+ *       fields: [
+ *         defineTextField({ name: 'title', required: true }),
+ *         defineRichTextField({ name: 'body' }),
+ *       ],
+ *     }),
+ *     ...defineTab({
+ *       label: 'SEO',
+ *       fields: [defineTextField({ name: 'metaTitle' })],
+ *     }),
+ *   ],
+ * })
+ * ```
+ */
+declare function defineTab<const T extends readonly Field[]>(args: {
+    /** Tab name shown in the Admin edit form's tab bar. */
+    label: string;
+    /** Fields to place under this tab; each field's `admin.tab` is set to `label`. */
+    fields: T;
+}): T;
+
+export { AIAgent, type AIAgentOptions, type AIErrorCode, AIMessage, AIThread, AccessPolicyResolver, AdminAuthConfig, ArrayField, AuthConfig, type AuthDocFields, AuthenticatedUser, BUILTIN_JEXL_HELPERS, BaseDocument, Block, BlocksField, BooleanField, type ChunkOptions, type ChunkResult, CollectionConfig, ComputedHandler, type ConfigDiagnostic, ConfigValidationError, DatabaseAdapter, DateField, DateTimeField, type DeclarativeAccessSurface, type DeclarativeAccessValidationIssue, type DeclarativeAdminSurface, type DeclarativeAdminValidationIssue, DeclarativeHookExpression, type DeclarativeHookSurface, type DeclarativeHookValidationIssue, type DeclarativePreviewSurface, type DeclarativePreviewValidationIssue, type DeleteDocumentChunksOptions, DetailComputed, DetailComputedOptions, DetailCustom, DetailCustomOptions, DetailDivider, DetailDividerOptions, DetailField, DetailGrid, DetailGridOptions, DetailItem, DetailRepeat, DetailRepeatOptions, DetailSchema, DetailSection, DetailSectionOptions, DetailTab, DetailTabOptions, DetailTabs, DetailTabsOptions, DetailText, DetailTextOptions, DisplayFieldOptions, DyrectedAIContext, DyrectedAIError, DyrectedConfig, EmailField, EmbeddingService, Field, GlobalConfig, HookRequestContext, IconField, ImageField, type IndexDocumentOptions, type InferDocShape, JoinField, JsonField, LIFECYCLE_EVENTS_COLLECTION, LifecycleEvent, LifecycleEventName, MultiSelectField, NumberField, ObjectField, type Prettify, PublicAdminAuthConfig, type PublishingWorkflowOptions, type RAGSearchOptions, RAGSearchResult, RAGService, RadioField, type ReindexAllOptions, type ReindexCollectionOptions, RelationshipField, RichTextField, RowField, SelectField, type SortClause, type SortDirection, type SqlSortDialect, type SqlWhereResult, type SystemDocFields, TextField, TextareaField, TimeField, type UploadDocFields, UrlField, WORKFLOW_HISTORY_COLLECTION, type WhereClause, type WhereOperator, type WhereOperatorName, WorkflowConfig, WorkflowTransition, abs, addDays, assertValidAdminConditionsInConfig, assertValidDeclarativeAccessInConfig, assertValidDeclarativeHookExpression, assertValidDeclarativeHookResult, assertValidDeclarativeHooksInConfig, assertValidPreviewUrlsInConfig, availableWorkflowTransitions, buildDyrectedSystemPrompt, buildSqlOrderBy, canViewWorkflowDraft, capitalize, ceil, chunkText, clamp, coalesce, collectAdminConditionValidationIssues, collectConfigDiagnostics, collectDeclarativeAccessValidationIssues, collectDeclarativeHookValidationIssues, collectPreviewUrlValidationIssues, compact, cosineSimilarity, count, createDyrectedAITools, createLifecycleEvent, createWorkflowDocument, defaultValue, defineArrayField, defineBlock, defineBlocksField, defineBooleanField, defineCollection, defineConfig, defineDateField, defineDateTimeField, defineEmailField, defineField, defineGlobal, defineIconField, defineImageField, defineJoinField, defineJsonField, defineMultiSelectField, defineNumberField, defineObjectField, definePublishingWorkflow, defineRadioField, defineRelationshipField, defineRichTextField, defineRowField, defineSelectField, defineTab, defineTextField, defineTextareaField, defineTimeField, defineUrlField, diffDays, dispatchLifecycleEvent, dispatchPendingLifecycleEvents, displayComputed, displayCustom, displayCustomComponent, displayDivider, displayField, displayGrid, displayRepeat, displaySection, displayTab, displayTabs, displayText, endsWith, estimateTokens, evaluateDetailComputed, evaluateJexl, evaluateJexlSync, executeFieldAfterRead, executeFieldBeforeChange, extractTextFromDoc, first, floor, formatAIErrorMessage, formatConfigDiagnostics, formatDate, generateDefaultDetailSchema, generateOpenApi, get, getAIModel, getAdminAuthCollection, getEmbeddingModel, getPublicAdminAuthConfig, hashContent, includes, initializeWorkflowDocument, isConfigValidationError, isDetailItemVisible, isEmpty, isFuture, isPast, join, last, length, lower, materializeWorkflowDocument, max, min, normalizeConfig, normalizeDetailItem, normalizeFieldValue, now, numericFieldNames, parseMongoWhere, parseSort, parseSqlWhere, pow, publishedStateName, publishingWorkflow, readingTime, registerJexlHelpers, replace, resolveAdminAuthCollection, round, runCollectionHooks, saveWorkflowDraft, simplePublishingWorkflow, slugify, sqrt, startsWith, sum, today, transitionWorkflow, trim, truncate, unique, upper, validateAdminConditionExpression, validateDeclarativeAccessExpression, validateDeclarativeHookExpression, validatePreviewUrlExpression, wordCount, workflowCapabilities };