@aotter/mantle 0.1.5-alpha.1 → 0.2.0-alpha.10

package/dist/build/compiler.d.ts

@@ -0,0 +1,721 @@
+export interface SiteDefaults {
+    readonly locales?: ReadonlyArray<string>;
+    readonly brand?: string;
+    readonly title?: string;
+    readonly description?: string;
+    readonly origin?: string;
+    readonly icons?: ReadonlyArray<SiteIcon>;
+    readonly media?: SiteMediaDefaults;
+}
+export interface SiteMediaDefaults {
+    readonly purposes?: ReadonlyArray<MediaPurposePolicy>;
+}
+export interface MediaPurposePolicy {
+    readonly name: string;
+    readonly required: readonly string[];
+    readonly maxBytes: Readonly<Record<string, number>>;
+}
+export interface SiteIcon {
+    readonly src: string;
+    readonly mimeType?: "image/png" | "image/jpeg" | "image/svg+xml" | "image/webp";
+    readonly sizes?: ReadonlyArray<string>;
+    readonly theme?: "light" | "dark";
+}
+export interface ManifestSourceSet {
+    readonly sources: readonly ManifestSource[];
+}
+export interface ManifestSource {
+    readonly sourceId: string;
+    readonly text: string;
+}
+export interface MantleDialect {
+    readonly name: string;
+    readonly version: string;
+    check(plan: SqlPlan, context: SqlContext): readonly SqlDiagnostic[];
+    readonly lowering: PolicyLowering;
+    readonly nativeOrder?: boolean;
+    readonly nativeSql?: boolean;
+    print?(ast: SqlNode, schemas: Readonly<Record<string, StorageSchema>>): string;
+    readonly lowerKey?: string;
+    readonly restricted?: boolean;
+}
+export interface StorageSchema extends SqlSchemaDef {
+    readonly checks?: readonly SqlNode[];
+    readonly search?: readonly string[];
+    readonly unique?: readonly (readonly string[])[];
+    readonly indexes?: readonly (readonly string[])[];
+}
+export type SqlNode = Record<string, any>;
+export interface SqlSchemaDef {
+    readonly translates?: {
+        readonly parent: string;
+        readonly on: string;
+    };
+    readonly scope?: string;
+    readonly userScopes?: readonly UserScope[];
+    readonly ttl?: string;
+    readonly ttlSeconds?: number;
+    readonly publishing?: boolean;
+    readonly fields: Readonly<Record<string, string>>;
+    readonly names?: Readonly<Record<string, string>>;
+    readonly schema?: {
+        readonly required?: readonly string[];
+        readonly properties?: Readonly<Record<string, {
+            readonly type?: unknown;
+            readonly nullable?: boolean;
+            readonly enum?: readonly unknown[];
+            readonly oneOf?: readonly {
+                readonly const?: unknown;
+            }[];
+        }>>;
+    };
+}
+export interface UserScope {
+    readonly column: string;
+    readonly field: string;
+    readonly type: "string" | "number";
+}
+export interface PolicyLowering {
+    anyOf?(x: SqlNode, set: SqlNode, type: 'string' | 'number'): SqlNode;
+    input(param: SqlNode, type: string): SqlNode;
+    func(f: string, n: SqlNode, scope: LoweringScope): SqlNode | undefined;
+    call(out: SqlNode): SqlNode;
+    cast(n: SqlNode, scope: LoweringScope): SqlNode;
+    sublink(out: SqlNode): SqlNode;
+    newId(): SqlNode;
+    columns(s: StorageSchema): SqlNode[];
+    system?(param: SqlNode, type: "timestamptz"): SqlNode;
+}
+export interface LoweringScope {
+    readonly inputs: Readonly<Record<string, string>>;
+    param(spec: BindSpec): SqlNode;
+    tx(node: SqlNode | undefined): SqlNode;
+    alias(name: string): {
+        schema: string;
+        def: StorageSchema;
+        searchQuery?: SqlNode;
+    };
+    seen(position: RelationPosition): void;
+}
+export type RelationPosition = 'from' | 'join.left' | 'join.right' | 'from-subquery' | 'cte' | 'setop.left' | 'setop.right' | 'sublink' | 'json_each' | 'window' | 'insert-target' | 'insert-select' | 'update-target' | 'delete-target' | 'conflict-update' | 'search' | 'near';
+export type BindSpec = {
+    k: 'uid';
+} | {
+    k: 'now';
+} | {
+    k: 'admin';
+} | {
+    k: 'cutoff';
+    seconds: number;
+} | {
+    k: 'const';
+    value: unknown;
+} | {
+    k: 'input';
+    name: string;
+    type: string;
+} | {
+    k: 'scoped';
+    column: string;
+    field: string;
+    type: 'string' | 'number';
+    name?: string;
+    value?: string | number;
+} | {
+    k: 'user';
+    field: string;
+    type: 'string' | 'number';
+    multiple: boolean;
+    scope?: true;
+} | DialectBind | {
+    k: 'version';
+} | {
+    k: 'cursor';
+    i: number;
+};
+export type DialectBind = {
+    readonly k: 'dialect';
+    readonly [key: string]: unknown;
+};
+export interface SqlDiagnostic {
+    readonly code: SqlDiagnosticCode;
+    readonly message: string;
+    readonly offset?: number;
+    readonly line?: number;
+    readonly column?: number;
+    readonly token?: string;
+}
+export type SqlDiagnosticCode = Extract<DiagnosticCode, `SQL_${string}` | `USER_FIELD_${string}` | "USER_REF_SCOPE_ONLY" | "AUTH_ROLE_REMOVED">;
+export type DiagnosticCode = (typeof DIAGNOSTIC_CODES)[number];
+export declare const DIAGNOSTIC_CODES: readonly [
+    "AUTH_ROLE_REMOVED",
+    "USER_FIELD_VALUES_UNENUMERATED",
+    "USER_FIELD_INVALID",
+    "USER_FIELD_CONFLICT",
+    "USER_FIELD_POSITION",
+    "USER_REF_SCOPE_ONLY",
+    "USER_SCOPE_PUBLIC_ANON_EMPTY",
+    "RESOURCE_EXHAUSTED",
+    "RESOURCE_UNAVAILABLE",
+    "RATE_LIMITED",
+    "OUTCOME_UNKNOWN",
+    "PARTIAL_FAILURE",
+    "PRECONDITION_FAILED",
+    "INVALID_MANIFEST_ENVELOPE",
+    "DUPLICATE_NAME",
+    "VIEW_INPUT_INVALID_SHAPE",
+    "VIEW_INPUT_RESERVED_NAME",
+    "VIEW_CACHE_INVALID",
+    "VIEW_UI_INVALID",
+    "REQUIRED_FIELD_UNKNOWN",
+    "INVALID_PATTERN",
+    "JSON_SCHEMA_UNSUPPORTED",
+    "JSON_SCHEMA_REF_INVALID",
+    "JSON_SCHEMA_LIMIT_EXCEEDED",
+    "AUTH_PREDICATE_NOT_IN_ENUM",
+    "GUARD_PROCEDURE_UNKNOWN",
+    "GUARD_SELF_REFERENCE",
+    "GUARD_PROCEDURE_NOT_REF",
+    "GUARD_CHAIN_NOT_ALLOWED",
+    "SCHEMA_INDEX_INVALID",
+    "SCHEMA_INDEX_FIELD_UNKNOWN",
+    "UNIQUE_INDEX_FIELD_UNKNOWN",
+    "SCHEMA_SEARCH_INVALID",
+    "SCHEMA_SEARCH_FIELD_UNKNOWN",
+    "SCHEMA_TTL_INVALID",
+    "SCHEMA_UI_INVALID",
+    "SCHEMA_NAME_CASE_COLLISION",
+    "SCHEMA_READER_NAME_COLLISION",
+    "FIELD_NAME_CASE_COLLISION",
+    "MANIFEST_ROOT_NOT_FOUND",
+    "MANIFEST_READ_FAILED",
+    "GENERATE_FEATURE_DEPENDENCY_MISSING",
+    "SQL_SYNTAX",
+    "SQL_UNSUPPORTED",
+    "SQL_FUNCTION",
+    "SQL_RELATION",
+    "SQL_COLUMN",
+    "SQL_WRITE",
+    "SQL_SHAPE",
+    "SQL_TYPE",
+    "FIXTURE_SCHEMA_VIOLATION",
+    "HANDLER_NOT_REGISTERED",
+    "HANDLER_NOT_DECLARED",
+    "PLAN_FINGERPRINT_MISMATCH",
+    "SCHEDULE_NOT_WIRED",
+    "STORAGE_CHANGE_BLOCKED",
+    "STORAGE_TABLE_NOT_OWNED",
+    "INVOCATION_DEPTH_EXCEEDED",
+    "TRIGGER_TARGET_PROCEDURE_UNKNOWN",
+    "SCHEDULE_INPUT_INVALID",
+    "SCHEDULE_AUTH_INVALID",
+    "TRIGGER_PATH_COLLISION",
+    "TRIGGER_PATH_INVALID",
+    "MCP_TOOL_NAME_COLLISION",
+    "MCP_TOOL_DESCRIPTION_MISSING",
+    "MCP_TOOL_INPUT_UNION_AMBIGUOUS",
+    "MCP_TOOL_INPUT_UNBOUNDED",
+    "MANTLE_REF_INVALID",
+    "PROCEDURE_TARGET_INVALID",
+    "PROCEDURE_NOT_FOUND",
+    "NOT_FOUND",
+    "METHOD_NOT_ALLOWED",
+    "LIFECYCLE_SCHEMA_UNKNOWN",
+    "LIFECYCLE_HOOK_REJECTED",
+    "LIFECYCLE_TARGET_NOT_REF",
+    "SCHEMA_LOCALIZED_REQUIRES_SITE_LOCALES",
+    "TRANSLATES_PARENT_UNKNOWN",
+    "TRANSLATES_REQUIRES_LOCALIZED",
+    "TRANSLATES_REQUIRES_CONTENT_FIELD",
+    "TRANSLATES_FIELD_NOT_IN_PARENT",
+    "TRANSLATES_FIELD_NOT_IN_CHILD",
+    "TRANSLATES_PARENT_IS_LOCALIZED",
+    "SCHEMA_TTL_TRANSLATION_UNSUPPORTED",
+    "INPUT_VALIDATION_FAILED",
+    "UNAUTHENTICATED",
+    "AUTH_DENIED",
+    "ENTITLEMENT_REQUIRED",
+    "CONFLICT",
+    "DISPATCHER_NOT_BUILT",
+    "INTERNAL_ERROR",
+    "OUTPUT_VALIDATION_FAILED",
+    "INVALID_LOCALE",
+    "MEDIA_NOT_CONFIGURED",
+    "SITE_NOT_CONFIGURED",
+    "MEDIA_UPLOAD_EXPIRED",
+    "MEDIA_OBJECT_NOT_FOUND",
+    "MEDIA_MIME_REJECTED",
+    "MEDIA_SIZE_EXCEEDED",
+    "MEDIA_SVG_REJECTED",
+    "MEDIA_CHECKSUM_MISMATCH",
+    "MEDIA_PURPOSE_REJECTED",
+    "MEDIA_VARIANTS_INCOMPLETE",
+    "MEDIA_VARIANT_SIZE_EXCEEDED",
+    "MEDIA_VARIANTS_SUSPICIOUS_SIZE",
+    "MEDIA_ASSET_NOT_FOUND"
+];
+export interface SqlContext {
+    readonly schemas: Readonly<Record<string, SqlSchemaDef>>;
+    readonly columns?: SchemaColumns;
+    readonly inputs: Readonly<Record<string, string>>;
+    readonly kind: "view" | "procedure";
+    readonly public?: boolean;
+    readonly views?: Readonly<Record<string, {
+        readonly select?: SqlNode;
+        readonly refusal?: string;
+    }>>;
+}
+export interface SchemaColumns {
+    readonly known: ReadonlySet<string>;
+    readonly scopes: ReadonlySet<string>;
+    readonly types: ReadonlyMap<string, string>;
+}
+export interface SqlPlan {
+    readonly grammar: number;
+    readonly stmts: readonly SqlNode[];
+}
+export declare const d1Dialect: MantleDialect;
+export interface RuntimePlan {
+    readonly access?: {
+        readonly roles: readonly string[];
+        readonly userFields: Readonly<Record<string, UserFieldSpec>>;
+        readonly warnings: readonly string[];
+    };
+    readonly version: typeof RUNTIME_PLAN_VERSION;
+    readonly dialect: {
+        readonly name: string;
+        readonly version: string;
+    };
+    readonly fingerprint: string;
+    readonly schemas: Readonly<Record<string, PlanSchema>>;
+    readonly views: Readonly<Record<string, PlanView>>;
+    readonly procedures: Readonly<Record<string, PlanProcedure>>;
+    readonly triggers: Readonly<Record<string, PlanTrigger>>;
+    readonly lowered?: PlanLowered;
+}
+export interface PlanLowered {
+    readonly mantle: string;
+    readonly dialect: {
+        readonly name: string;
+        readonly version: string;
+        readonly key: string;
+    };
+    readonly views: Readonly<Record<string, Readonly<Partial<Record<LoweredMode, LoweredView>>>>>;
+    readonly procedures: Readonly<Record<string, Readonly<Partial<Record<"caller" | "trusted", readonly LoweredStatement[]>>>>>;
+}
+export interface LoweredStatement {
+    readonly sql: string;
+    readonly binds: readonly {
+        readonly k: string;
+        readonly [key: string]: unknown;
+    }[];
+    readonly kind: "read" | "row" | "set";
+    readonly schema?: string;
+    readonly verb?: "insert" | "update" | "delete";
+    readonly hooked?: true;
+    readonly publish?: true;
+    readonly returns?: true;
+    readonly target?: string;
+}
+export interface LoweredView extends LoweredStatement {
+    readonly nkeys: number;
+    readonly paged: Readonly<Record<string, LoweredPage>>;
+}
+export interface LoweredPage {
+    readonly sql: string;
+    readonly sources: readonly ({
+        readonly cursor: number;
+    } | {
+        readonly search: true;
+    } | {
+        readonly eq: number;
+    } | {
+        readonly limit: true;
+    })[];
+    readonly flat?: true;
+    readonly names: readonly string[];
+    readonly nkeys: number;
+}
+export type LoweredMode = "caller" | "public" | "trusted";
+export interface PlanTrigger {
+    readonly source: TriggerSource;
+    readonly procedure: string;
+}
+export type TriggerSource = HttpTriggerSource | LifecycleTriggerSource | McpTriggerSource | ScheduleTriggerSource;
+export interface ScheduleTriggerSource {
+    readonly kind: "schedule";
+    readonly cron: string;
+    readonly enabled?: boolean;
+}
+export interface McpTriggerSource {
+    readonly kind: "mcp";
+    readonly surface: McpTriggerSurface;
+}
+export type McpTriggerSurface = (typeof MCP_TRIGGER_SURFACES)[number];
+export declare const MCP_TRIGGER_SURFACES: readonly [
+    "admin",
+    "public"
+];
+export interface LifecycleTriggerSource {
+    readonly kind: "lifecycle";
+    readonly schema: string;
+    readonly on: readonly LifecycleHook[];
+}
+export type LifecycleHook = (typeof LIFECYCLE_HOOKS)[number];
+export declare const LIFECYCLE_HOOKS: readonly [
+    "before_create",
+    "after_create",
+    "before_update",
+    "after_update",
+    "before_delete",
+    "after_delete",
+    "before_publish",
+    "after_publish"
+];
+export interface HttpTriggerSource {
+    readonly kind: "http";
+    readonly method: HttpMethod;
+    readonly path: string;
+}
+export type HttpMethod = "POST" | "PUT" | "PATCH" | "DELETE";
+export interface PlanProcedure {
+    readonly restrict?: PlanRestrict;
+    readonly trustedOnly?: true;
+    readonly title?: LocalizedText;
+    readonly description?: LocalizedText;
+    readonly uiSchema?: Readonly<Record<string, unknown>>;
+    readonly input: JsonSchema;
+    readonly output: JsonSchema;
+    readonly inputs: Readonly<Record<string, string>>;
+    readonly requires?: AuthorizationRequirements;
+    readonly target?: ProcedureTarget;
+    readonly mcp?: ProcedureMcpAnnotations;
+    readonly handler: {
+        readonly ref: string;
+    } | {
+        readonly sql: SqlPlan;
+        readonly source: string;
+    };
+}
+export interface ProcedureMcpAnnotations {
+    readonly readOnlyHint?: boolean;
+    readonly destructiveHint?: boolean;
+    readonly openWorldHint?: boolean;
+}
+export interface ProcedureTarget {
+    readonly schema: string;
+    readonly id: string;
+    readonly version?: string;
+}
+export interface AuthorizationRequirements {
+    readonly auth?: {
+        readonly all: readonly AuthPredicate[];
+    };
+    readonly guard?: {
+        readonly procedure: string;
+    };
+}
+export type AuthPredicate = CtxUserPredicate | "ctx.admin" | CtxAuthPredicate | CtxAuthScopePredicate;
+export interface CtxAuthScopePredicate {
+    readonly "ctx.auth.scope": string;
+}
+export type CtxAuthPredicate = "ctx.auth";
+export type CtxUserPredicate = "ctx.user";
+export type JsonSchema = {
+    readonly $defs?: Readonly<Record<string, JsonSchema>>;
+    readonly $ref?: string;
+    readonly oneOf?: readonly JsonSchema[];
+    readonly const?: unknown;
+    readonly type?: string | readonly string[];
+    readonly properties?: Readonly<Record<string, JsonSchema>>;
+    readonly required?: readonly string[];
+    readonly items?: JsonSchema;
+    readonly enum?: readonly unknown[];
+    readonly format?: string;
+    readonly pattern?: string;
+    readonly minLength?: number;
+    readonly maxLength?: number;
+    readonly minimum?: number;
+    readonly maximum?: number;
+    readonly minItems?: number;
+    readonly maxItems?: number;
+    readonly nullable?: boolean;
+    readonly readOnly?: boolean;
+    readonly default?: unknown;
+    readonly additionalProperties?: boolean | JsonSchema;
+    readonly description?: LocalizedText;
+    readonly title?: LocalizedText;
+    readonly "x-mantle-ref"?: string | MantleRefTarget;
+    readonly "x-mcp-hint"?: string;
+    readonly [key: string]: unknown;
+};
+export interface MantleRefTarget {
+    readonly schema: string;
+    readonly field: string;
+}
+export type LocalizedText = string | Readonly<Record<string, string>>;
+export type PlanRestrict = Readonly<Record<string, {
+    readonly owner?: string;
+    readonly terms: readonly UserScope[];
+}>>;
+export interface PlanView extends SqlPlan {
+    readonly restrict?: PlanRestrict;
+    readonly title?: LocalizedText;
+    readonly description?: LocalizedText;
+    readonly uiSchema?: Readonly<Record<string, unknown>>;
+    readonly inputs: Readonly<Record<string, string>>;
+    readonly input?: JsonSchema;
+    readonly source: string;
+    readonly surface: "public" | "admin" | "internal";
+    readonly requires?: AuthorizationRequirements;
+    readonly sharedMaxAge?: number;
+    readonly columns?: Readonly<Record<string, {
+        readonly schema: string;
+        readonly field: string;
+    }>>;
+}
+export interface PlanSchema {
+    readonly userScopes?: readonly UserScope[];
+    readonly name: string;
+    readonly title?: LocalizedText;
+    readonly description?: LocalizedText;
+    readonly uiSchema?: Readonly<Record<string, unknown>>;
+    readonly localized?: boolean;
+    readonly scope?: string;
+    readonly ttl?: string;
+    readonly ttlSeconds?: number;
+    readonly publishing?: boolean;
+    readonly fields: Readonly<Record<string, string>>;
+    readonly names: Readonly<Record<string, string>>;
+    readonly schema: JsonSchema;
+    readonly checks?: readonly SqlNode[];
+    readonly translates?: {
+        readonly parent: string;
+        readonly on: string;
+    };
+    readonly search?: readonly string[];
+    readonly unique?: readonly (readonly string[])[];
+    readonly indexes?: readonly (readonly string[])[];
+}
+export declare const RUNTIME_PLAN_VERSION: 6;
+export interface UserFieldSpec {
+    readonly type: "string" | "number";
+    readonly integer?: true;
+    readonly multiple: boolean;
+    readonly enum?: readonly (string | number)[];
+}
+export declare const RESERVED_PROCEDURE_INPUT_NAMES: readonly [
+    "expectedVersion"
+];
+export declare const INPUT_RULE_KEYWORDS: readonly [
+    "dependentRequired",
+    "anyOf",
+    "if",
+    "then",
+    "else"
+];
+export declare const EXPECTED_VERSION_PROPERTY: "expectedVersion";
+export declare const RESERVED_ENTRY_COLUMNS: readonly [
+    "id",
+    "status",
+    "version",
+    "createdAt",
+    "updatedAt",
+    "authorId"
+];
+export type TriggerManifest = ManifestEnvelope<"Trigger", TriggerManifestSpec>;
+export interface TriggerManifestSpec {
+    readonly source: TriggerSource;
+    readonly target: {
+        readonly procedure: string;
+    };
+}
+interface ManifestEnvelope<K extends ManifestKind, S> {
+    readonly apiVersion: ApiVersion;
+    readonly kind: K;
+    readonly metadata: ManifestMetadata;
+    readonly spec: S;
+}
+export interface ManifestMetadata {
+    readonly name: string;
+}
+export type ApiVersion = typeof API_VERSION;
+export declare const API_VERSION: "cms.mantle.aotter.net/v2";
+export type ManifestKind = "Schema" | "View" | "Procedure" | "Trigger";
+export type ProcedureManifest = ManifestEnvelope<"Procedure", ProcedureManifestSpec>;
+export interface ProcedureManifestSpec {
+    readonly title?: LocalizedText;
+    readonly description?: LocalizedText;
+    readonly requires?: AuthorizationRequirements;
+    readonly restrict?: Readonly<Record<string, string>>;
+    readonly input: JsonSchema;
+    readonly uiSchema?: Record<string, unknown>;
+    readonly output: JsonSchema;
+    readonly handler: HandlerBinding;
+    readonly mcp?: ProcedureMcpAnnotations;
+    readonly target?: ProcedureTarget;
+}
+export type HandlerBinding = HandlerRefBinding | HandlerSqlBinding;
+export interface HandlerSqlBinding {
+    readonly sql: string;
+}
+export interface HandlerRefBinding {
+    readonly ref: string;
+}
+export type ViewManifest = ManifestEnvelope<"View", ViewManifestSpec>;
+export interface ViewManifestSpec {
+    readonly title?: LocalizedText;
+    readonly description?: LocalizedText;
+    readonly uiSchema?: Record<string, unknown>;
+    readonly sql: string;
+    readonly surface: ViewSurface;
+    readonly cache?: ViewCachePolicy;
+    readonly requires?: AuthorizationRequirements;
+    readonly restrict?: Readonly<Record<string, string>>;
+    readonly input?: JsonSchema;
+}
+export interface ViewCachePolicy {
+    readonly sharedMaxAge: number;
+}
+export type ViewSurface = (typeof VIEW_SURFACES)[number];
+export declare const VIEW_SURFACES: readonly [
+    "public",
+    "admin",
+    "internal"
+];
+export type SchemaManifest = ManifestEnvelope<"Schema", SchemaManifestSpec>;
+export interface SchemaManifestSpec {
+    readonly title: LocalizedText;
+    readonly description?: LocalizedText;
+    readonly schema: JsonSchema;
+    readonly uiSchema?: Record<string, unknown>;
+    readonly checks?: readonly string[];
+    readonly uniqueIndexes?: ReadonlyArray<ReadonlyArray<string>>;
+    readonly indexes?: ReadonlyArray<ReadonlyArray<string>>;
+    readonly searchableFields?: readonly string[];
+    readonly localized?: boolean;
+    readonly translates?: TranslatesBinding;
+    readonly lifecycle?: LifecycleMode;
+    readonly ttl?: {
+        readonly field: string;
+        readonly expireAfterSeconds: number;
+    };
+    readonly scope?: string;
+}
+export type LifecycleMode = "publishing" | "operational";
+export interface TranslatesBinding {
+    readonly parent: string;
+    readonly on: string;
+}
+export type Manifest = SchemaManifest | ViewManifest | ProcedureManifest | TriggerManifest;
+export type AdminRole = string;
+export declare function isAdminRole(s: string): s is AdminRole;
+export declare const PROCEDURE_MCP_ANNOTATION_KEYS: readonly [
+    "readOnlyHint",
+    "destructiveHint",
+    "openWorldHint"
+];
+export declare const PROCEDURE_TARGET_KEYS: readonly [
+    "schema",
+    "id",
+    "version"
+];
+export declare const VIEW_INPUT_RESERVED: readonly [
+    "limit",
+    "cursor"
+];
+export declare function resolveLocalizedText(value: LocalizedText | null | undefined, preferred: string, canonical?: string | null): string | null;
+export declare const isLocalizedText: (v: unknown) => v is LocalizedText;
+export declare const MANTLE_BIND_KEYWORD: "x-mantle-bind";
+export declare const MCP_HINT_KEYWORD: "x-mcp-hint";
+export declare function resolveMantleRef(property: unknown): MantleRefTarget | null;
+export declare function enumOptions(property: JsonSchema | undefined): {
+    readonly value: string;
+    readonly title?: LocalizedText;
+}[] | undefined;
+export declare const MANTLE_REF_KEYWORD: "x-mantle-ref";
+export type MediaMcpHint = "media" | "media-image" | "media-video" | "media-file";
+export declare function isMediaMcpHint(value: unknown): value is MediaMcpHint;
+export interface Diagnostic {
+    readonly code: DiagnosticCode;
+    readonly phase: Phase;
+    readonly severity: "error" | "warning";
+    readonly path: string;
+    readonly source?: SourceLocation;
+    readonly value?: unknown;
+    readonly expected?: string;
+    readonly candidates?: readonly string[];
+    readonly suggestion?: string;
+    readonly message: string;
+    readonly failure?: {
+        readonly outcome: "not-applied" | "partial" | "unknown";
+        readonly retry: "never" | "after-change" | "safe" | "reconcile";
+        readonly resource?: string;
+    };
+    readonly conflict?: {
+        readonly opIndex?: number;
+        readonly reason: "lock" | "expect" | "unique";
+    };
+}
+export interface SourceLocation {
+    readonly sourceId: string;
+    readonly documentIndex: number;
+    readonly path: string;
+    readonly span?: SourceSpan;
+}
+export interface SourceSpan {
+    readonly start: SourcePosition;
+    readonly end: SourcePosition;
+}
+export interface SourcePosition {
+    readonly line: number;
+    readonly column: number;
+    readonly offset: number;
+}
+export type Phase = "validate" | "test" | "boot" | "runtime";
+export declare class DiagnosticError extends Error {
+    static [Symbol.hasInstance](value: unknown): boolean;
+    readonly [BRAND] = true;
+    readonly diagnostics: readonly Diagnostic[];
+    constructor(diagnostic: Diagnostic | readonly Diagnostic[], options?: ErrorOptions);
+    get diagnostic(): Diagnostic;
+}
+declare const BRAND: unique symbol;
+type PhaselessInput = Omit<Diagnostic, "phase" | "message"> & {
+    message?: string;
+};
+export declare const runtimeDiagnostic: (input: PhaselessInput) => Diagnostic;
+export declare const bootDiagnostic: (input: PhaselessInput) => Diagnostic;
+export declare const validateDiagnostic: (input: PhaselessInput) => Diagnostic;
+export declare function makeDiagnostic(input: Omit<Diagnostic, "message"> & {
+    message?: string;
+}): Diagnostic;
+export declare function checkShapeProblem(v: unknown, columns: ReadonlyMap<string, string>): string | undefined;
+export declare const CHECK_FUNCTIONS: ReadonlyMap<string, {
+    readonly takes: readonly string[];
+    readonly returns: "text" | "integer" | "argument";
+}>;
+export declare function storageColumnClash(fields: Readonly<Record<string, string>>): string | undefined;
+export declare function notNullColumns(s: SqlSchemaDef): Set<string>;
+export declare const NATIVE_COLUMNS: Readonly<Record<string, string>>;
+export declare const NATIVE_NOT_NULL: ReadonlySet<string>;
+export declare const AGGREGATES: ReadonlySet<string>;
+export declare function storageColumns(s: {
+    readonly fields?: Readonly<Record<string, string>>;
+    readonly scope?: string;
+    readonly publishing?: boolean;
+}): Map<string, string>;
+export declare function viewCacheProblem(stmts: readonly SqlNode[], schemas: Readonly<Record<string, SqlSchemaDef>>): string | undefined;
+export declare const PG_GRAMMAR = 180004;
+export interface RowTemplate {
+    readonly owner?: string;
+    readonly terms: readonly {
+        readonly column: string;
+        readonly field: string;
+    }[];
+}
+export declare function parseRowTemplate(text: unknown): RowTemplate | string;
+export declare const NATIVE_OUTPUT_TYPES: Readonly<Record<string, string>>;
+export declare function planFingerprint(plan: Omit<RuntimePlan, "fingerprint">): Promise<string>;
+export declare const fnv: (s: string) => string;
+export declare function canonical(v: unknown): string;