@mateusseiboth/ember-orm 0.1.0

package/dist/index-CKqkQhZx.d.cts

@@ -0,0 +1,459 @@
+import { S as SchemaDocument, M as ModelNode } from './index-D0xIdtCl.cjs';
+
+/**
+ * Database driver abstraction. The query engine depends only on these
+ * interfaces (DIP), never on `node-firebird` directly, so a different
+ * backend could be plugged in without touching the engine.
+ */
+interface ConnectionConfig {
+    host: string;
+    port: number;
+    database: string;
+    user: string;
+    password: string;
+    role?: string;
+    encoding?: string;
+    pageSize?: number;
+    /** Max pooled connections. */
+    poolMax?: number;
+    blobAsText?: boolean;
+    lowercaseKeys?: boolean;
+    /**
+     * Authentication plugin. Firebird 3+ defaults to "Srp" (secure remote
+     * password) and is negotiated automatically; use "Legacy_Auth" for legacy
+     * Firebird 2.1/2.5 servers.
+     */
+    authPlugin?: "Srp" | "Legacy_Auth";
+    /** Enable wire compression (Firebird 3+). */
+    wireCompression?: boolean;
+    /**
+     * Target server major version, used to pick version-specific SQL/DDL
+     * (e.g. BOOLEAN vs SMALLINT, IDENTITY vs generator+trigger). Defaults to 3.
+     */
+    version?: FirebirdVersion;
+}
+type FirebirdVersion = "2.1" | "2.5" | "3" | "4" | "5";
+type SqlValue = string | number | boolean | bigint | Date | Buffer | null;
+/** A connection scoped to an open transaction. */
+interface TransactionContext {
+    /** Run a parameterized query and return all rows. */
+    query<T = Record<string, unknown>>(sql: string, params?: readonly SqlValue[]): Promise<T[]>;
+}
+type IsolationLevel = "READ_COMMITTED" | "READ_COMMITTED_READ_ONLY" | "REPEATABLE_READ" | "SERIALIZABLE";
+/** Emitted once per executed statement when a logger is configured. */
+interface QueryEvent {
+    sql: string;
+    params: readonly SqlValue[];
+    durationMs: number;
+    /** Number of rows returned (selects) or affected-ish (best-effort). */
+    rowCount: number;
+}
+type QueryLogger = (event: QueryEvent) => void;
+interface DriverOptions {
+    /** Called after each statement completes (used by the client `log` option). */
+    onQuery?: QueryLogger;
+}
+interface TransactionOptions {
+    isolation?: IsolationLevel;
+}
+/**
+ * The driver contract used by the runtime. Every read and write goes through
+ * `transaction()` so the project rule "every operation runs in a transaction"
+ * holds by construction.
+ */
+interface SqlDriver {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    /**
+     * Run `fn` inside a transaction, committing on success and rolling back on
+     * any thrown error. Nested calls reuse the active transaction.
+     */
+    transaction<T>(fn: (tx: TransactionContext) => Promise<T>, options?: TransactionOptions): Promise<T>;
+}
+
+/**
+ * Strategy interface for SQL generation. Encapsulates every dialect-specific
+ * decision so the query compiler stays backend-agnostic. Only FirebirdDialect
+ * is implemented today, but the engine never assumes Firebird directly.
+ */
+interface SqlDialect {
+    /** Quote an identifier (table/column/alias). */
+    quoteId(name: string): string;
+    /** Quote a `table.column` reference. */
+    quoteRef(table: string, column: string): string;
+    /** Pagination clause placed right after SELECT (e.g. `FIRST 10 SKIP 5`). */
+    paginationClause(take?: number, skip?: number): string;
+    /** Wrap a value for LIKE with case-insensitive mode. */
+    caseInsensitive(expr: string): string;
+    /** Map a default function name (now/uuid/...) to a SQL expression, if any. */
+    defaultFunctionSql(name: string): string | null;
+    /** Coerce a JS value into a driver-bindable SqlValue. */
+    coerceValue(value: unknown): SqlValue;
+    /** True if the dialect can paginate (controls FIRST/SKIP usage). */
+    readonly supportsReturning: boolean;
+    /** Native BOOLEAN type (Firebird 3+) vs SMALLINT fallback (2.1/2.5). */
+    readonly supportsBooleanType: boolean;
+    /** IDENTITY columns (Firebird 3+) vs generator+trigger (2.1/2.5). */
+    readonly supportsIdentity: boolean;
+    /** Window functions like ROW_NUMBER() OVER (...) (Firebird 3+). */
+    readonly supportsWindowFunctions: boolean;
+    /** DDL type used for boolean columns. */
+    booleanColumnType(): string;
+}
+/**
+ * Firebird 3+/4+ dialect.
+ * - Identifiers are double-quoted to preserve case (introspection yields
+ *   UPPER-CASE names and quoting avoids accidental folding).
+ * - Pagination uses `FIRST n SKIP m` after the SELECT keyword.
+ * - Case-insensitive matching uses UPPER() on both sides.
+ */
+interface FirebirdDialectOptions {
+    version?: FirebirdVersion;
+}
+declare class FirebirdDialect implements SqlDialect {
+    readonly supportsReturning = true;
+    readonly version: FirebirdVersion;
+    readonly supportsBooleanType: boolean;
+    readonly supportsIdentity: boolean;
+    readonly supportsWindowFunctions: boolean;
+    constructor(options?: FirebirdDialectOptions);
+    booleanColumnType(): string;
+    quoteId(name: string): string;
+    quoteRef(table: string, column: string): string;
+    paginationClause(take?: number, skip?: number): string;
+    caseInsensitive(expr: string): string;
+    defaultFunctionSql(name: string): string | null;
+    coerceValue(value: unknown): SqlValue;
+}
+
+/**
+ * Runtime-facing query argument shapes. The generated client produces strict,
+ * per-model versions of these; at runtime the engine works with these generic
+ * forms. Mirrors Prisma's query API surface.
+ */
+type SortOrder = "asc" | "desc";
+type QueryMode = "default" | "insensitive";
+/** Scalar field filter, e.g. `{ equals, in, lt, contains, ... }`. */
+interface ScalarFilter {
+    equals?: unknown;
+    not?: unknown | ScalarFilter;
+    in?: unknown[];
+    notIn?: unknown[];
+    lt?: unknown;
+    lte?: unknown;
+    gt?: unknown;
+    gte?: unknown;
+    contains?: string;
+    startsWith?: string;
+    endsWith?: string;
+    mode?: QueryMode;
+}
+/** Relation filter for to-one (`is`/`isNot`) and to-many (`some`/`every`/`none`). */
+interface RelationFilter {
+    is?: WhereInput | null;
+    isNot?: WhereInput | null;
+    some?: WhereInput;
+    every?: WhereInput;
+    none?: WhereInput;
+}
+interface WhereInput {
+    AND?: WhereInput | WhereInput[];
+    OR?: WhereInput[];
+    NOT?: WhereInput | WhereInput[];
+    [field: string]: unknown | ScalarFilter | RelationFilter | WhereInput | WhereInput[] | undefined;
+}
+type OrderByInput = Record<string, SortOrder> | Record<string, SortOrder>[];
+type SelectInput = Record<string, boolean | NestedReadArgs>;
+type IncludeInput = Record<string, boolean | NestedReadArgs>;
+/** Fields to exclude from the result (inverse of select). */
+type OmitInput = Record<string, boolean>;
+interface NestedReadArgs {
+    select?: SelectInput;
+    include?: IncludeInput;
+    where?: WhereInput;
+    orderBy?: OrderByInput;
+    take?: number;
+    skip?: number;
+    distinct?: string[];
+}
+interface FindManyArgs {
+    where?: WhereInput;
+    orderBy?: OrderByInput;
+    select?: SelectInput;
+    include?: IncludeInput;
+    omit?: OmitInput;
+    take?: number;
+    skip?: number;
+    cursor?: Record<string, unknown>;
+    distinct?: string[];
+}
+interface FindUniqueArgs {
+    where: WhereInput;
+    select?: SelectInput;
+    include?: IncludeInput;
+    omit?: OmitInput;
+}
+interface FindFirstArgs extends FindManyArgs {
+}
+interface CreateArgs {
+    data: Record<string, unknown>;
+    select?: SelectInput;
+    include?: IncludeInput;
+    omit?: OmitInput;
+}
+interface CreateManyArgs {
+    data: Record<string, unknown>[];
+    skipDuplicates?: boolean;
+}
+interface CreateManyAndReturnArgs {
+    data: Record<string, unknown>[];
+    select?: SelectInput;
+    omit?: OmitInput;
+    skipDuplicates?: boolean;
+}
+interface UpdateArgs {
+    where: WhereInput;
+    data: Record<string, unknown>;
+    select?: SelectInput;
+    include?: IncludeInput;
+    omit?: OmitInput;
+}
+interface UpdateManyArgs {
+    where?: WhereInput;
+    data: Record<string, unknown>;
+}
+interface UpsertArgs {
+    where: WhereInput;
+    create: Record<string, unknown>;
+    update: Record<string, unknown>;
+    select?: SelectInput;
+    include?: IncludeInput;
+    omit?: OmitInput;
+}
+interface DeleteArgs {
+    where: WhereInput;
+    select?: SelectInput;
+    include?: IncludeInput;
+    omit?: OmitInput;
+}
+interface DeleteManyArgs {
+    where?: WhereInput;
+}
+interface CountArgs {
+    where?: WhereInput;
+    take?: number;
+    skip?: number;
+    select?: Record<string, boolean> | true;
+}
+interface AggregateArgs {
+    where?: WhereInput;
+    orderBy?: OrderByInput;
+    take?: number;
+    skip?: number;
+    _count?: Record<string, boolean> | true;
+    _avg?: Record<string, boolean>;
+    _sum?: Record<string, boolean>;
+    _min?: Record<string, boolean>;
+    _max?: Record<string, boolean>;
+}
+interface GroupByArgs extends AggregateArgs {
+    by: string[];
+    having?: WhereInput;
+}
+
+/**
+ * The query engine executes high-level operations against a driver. Reads use
+ * a projection + relation-stitching pipeline (relations are loaded with
+ * separate batched queries, Prisma-style). Writes are delegated to
+ * WriteProcessor. Every operation runs inside a driver transaction.
+ */
+declare class QueryEngine {
+    private readonly schema;
+    private readonly dialect;
+    private readonly driver;
+    constructor(schema: SchemaDocument, dialect: SqlDialect, driver: SqlDriver);
+    model(name: string): ModelNode;
+    private run;
+    private execOn;
+    findMany(name: string, args?: FindManyArgs): Promise<Record<string, unknown>[]>;
+    findFirst(name: string, args?: FindFirstArgs): Promise<Record<string, unknown> | null>;
+    findFirstOrThrow(name: string, args?: FindFirstArgs): Promise<Record<string, unknown>>;
+    findUnique(name: string, args: FindUniqueArgs): Promise<Record<string, unknown> | null>;
+    findUniqueOrThrow(name: string, args: FindUniqueArgs): Promise<Record<string, unknown>>;
+    count(name: string, args?: CountArgs): Promise<number>;
+    aggregate(name: string, args?: AggregateArgs): Promise<Record<string, unknown>>;
+    groupBy(name: string, args: GroupByArgs): Promise<Record<string, unknown>[]>;
+    create(name: string, args: CreateArgs): Promise<Record<string, unknown>>;
+    createMany(name: string, args: CreateManyArgs): Promise<{
+        count: number;
+    }>;
+    /** Like createMany, but returns the created records (no nested relations). */
+    createManyAndReturn(name: string, args: CreateManyAndReturnArgs): Promise<Record<string, unknown>[]>;
+    update(name: string, args: UpdateArgs): Promise<Record<string, unknown>>;
+    updateMany(name: string, args: UpdateManyArgs): Promise<{
+        count: number;
+    }>;
+    upsert(name: string, args: UpsertArgs): Promise<Record<string, unknown>>;
+    delete(name: string, args: DeleteArgs): Promise<Record<string, unknown>>;
+    deleteMany(name: string, args?: DeleteManyArgs): Promise<{
+        count: number;
+    }>;
+    private readMany;
+    private loadRelation;
+    private readRelations;
+    /**
+     * Resolve which to-many relations to count for `_count` in select/include.
+     * `_count: true` counts every list relation; `_count: { select: { rel } }`
+     * counts the named ones.
+     */
+    private readCountRelations;
+    /** Attach a `_count` object to each row with per-relation child counts. */
+    private loadCounts;
+    private readBack;
+    private readBackOne;
+    private requireOne;
+    private findOneRaw;
+    private countMatching;
+    private pickKeys;
+    private assertUniqueWhere;
+}
+
+/**
+ * The full set of operations exposed on `client.<model>`. The generated client
+ * narrows every argument and return type per model; this is the untyped runtime
+ * surface they share.
+ */
+interface ModelDelegate {
+    findMany(args?: FindManyArgs): Promise<Record<string, unknown>[]>;
+    findFirst(args?: FindFirstArgs): Promise<Record<string, unknown> | null>;
+    findFirstOrThrow(args?: FindFirstArgs): Promise<Record<string, unknown>>;
+    findUnique(args: FindUniqueArgs): Promise<Record<string, unknown> | null>;
+    findUniqueOrThrow(args: FindUniqueArgs): Promise<Record<string, unknown>>;
+    create(args: CreateArgs): Promise<Record<string, unknown>>;
+    createMany(args: CreateManyArgs): Promise<{
+        count: number;
+    }>;
+    createManyAndReturn(args: CreateManyAndReturnArgs): Promise<Record<string, unknown>[]>;
+    update(args: UpdateArgs): Promise<Record<string, unknown>>;
+    updateMany(args: UpdateManyArgs): Promise<{
+        count: number;
+    }>;
+    upsert(args: UpsertArgs): Promise<Record<string, unknown>>;
+    delete(args: DeleteArgs): Promise<Record<string, unknown>>;
+    deleteMany(args?: DeleteManyArgs): Promise<{
+        count: number;
+    }>;
+    count(args?: CountArgs): Promise<number>;
+    aggregate(args?: AggregateArgs): Promise<Record<string, unknown>>;
+    groupBy(args: GroupByArgs): Promise<Record<string, unknown>[]>;
+}
+
+/**
+ * Client Extensions ($extends), middleware ($use) and the fluent API live here.
+ * The delegate factory composes per-operation query hooks, computes `result`
+ * fields, and returns fluent thenables for single-record reads.
+ */
+interface ResultFieldExtension {
+    needs?: Record<string, boolean>;
+    compute: (record: Record<string, unknown>) => unknown;
+}
+interface QueryHookParams {
+    model: string;
+    operation: string;
+    args: Record<string, unknown>;
+    query: (args: Record<string, unknown>) => Promise<unknown>;
+}
+type QueryHook = (params: QueryHookParams) => Promise<unknown>;
+type HookMap = Record<string, QueryHook>;
+interface EmberExtensionArgs {
+    name?: string;
+    result?: Record<string, Record<string, ResultFieldExtension>>;
+    model?: Record<string, Record<string, (...args: unknown[]) => unknown>>;
+    query?: Record<string, HookMap>;
+    client?: Record<string, unknown>;
+}
+/** Prisma-style middleware: `(params, next) => next(params)`. */
+type Middleware = (params: {
+    model?: string;
+    action: string;
+    args: unknown;
+}, next: (params: {
+    model?: string;
+    action: string;
+    args: unknown;
+}) => Promise<unknown>) => Promise<unknown>;
+
+interface ClientOptions {
+    /** Connection URL or explicit config. Overrides the schema datasource. */
+    datasourceUrl?: string;
+    datasource?: ConnectionConfig;
+    /** A pre-parsed schema document (the generated client passes its own). */
+    schema: SchemaDocument;
+    /**
+     * Query logging: `true` logs each statement to the console; pass a function
+     * to receive structured `QueryEvent`s (sql, params, durationMs, rowCount).
+     */
+    log?: boolean | QueryLogger;
+}
+/**
+ * Runtime client. Builds one delegate per model from the schema and exposes
+ * Prisma-style lifecycle and transaction helpers. The generated client extends
+ * this and adds strongly-typed delegate properties.
+ */
+declare class EmberClientBase {
+    protected readonly driver: SqlDriver;
+    protected readonly engine: QueryEngine;
+    protected readonly dialect: SqlDialect;
+    protected readonly schema: SchemaDocument;
+    private connected;
+    /** Mutated by $extends (per instance) and $use (shared). */
+    protected extensions: EmberExtensionArgs[];
+    protected middlewares: Middleware[];
+    private readonly queryListeners;
+    private readonly baseLog?;
+    /** Dynamic model delegates, keyed by camelCased model name. */
+    [delegate: string]: unknown;
+    constructor(options: ClientOptions);
+    private dispatchQuery;
+    private delegateContext;
+    /** (Re)define one delegate property per model using the current extensions. */
+    private installDelegates;
+    /**
+     * Prisma-style Client Extensions. Returns a new client (the original is
+     * unchanged) that shares the connection/engine but applies the extension's
+     * `result` / `model` / `query` / `client` definitions.
+     */
+    $extends(extension: EmberExtensionArgs): this;
+    /** Prisma-style middleware: runs around every operation. */
+    $use(middleware: Middleware): void;
+    /** Subscribe to query events (mirrors the `log` callback). */
+    $on(event: "query", listener: QueryLogger): void;
+    /** Type-safe access to a delegate by model name. */
+    model(name: string): ModelDelegate;
+    $connect(): Promise<void>;
+    $disconnect(): Promise<void>;
+    /**
+     * Run work inside a single transaction.
+     * - Interactive form: `$transaction(async (tx) => { ... })`.
+     * - Sequential form: `$transaction([(tx) => tx.user.create(...), ...])`.
+     *
+     * Because the driver tracks the active transaction via AsyncLocalStorage,
+     * every delegate call made on the passed client runs in the same transaction.
+     */
+    $transaction<T>(fn: (tx: this) => Promise<T>, options?: TransactionOptions): Promise<T>;
+    $transaction<T>(thunks: ((tx: this) => Promise<T>)[], options?: TransactionOptions): Promise<T[]>;
+    /** Execute a raw read query (returns rows) inside a transaction. */
+    $queryRawUnsafe<T = Record<string, unknown>>(sql: string, ...params: unknown[]): Promise<T[]>;
+    /** Execute a raw write statement inside a transaction; returns affected rows when available. */
+    $executeRawUnsafe(sql: string, ...params: unknown[]): Promise<number>;
+    /** Tagged-template raw query: `client.$queryRaw\`SELECT * FROM T WHERE id = ${id}\``. */
+    $queryRaw<T = Record<string, unknown>>(strings: TemplateStringsArray, ...values: unknown[]): Promise<T[]>;
+    $executeRaw(strings: TemplateStringsArray, ...values: unknown[]): Promise<number>;
+}
+/**
+ * Factory for an untyped client when you don't use the generated client.
+ * Prefer the generated `EmberClient` for full type-safety.
+ */
+declare function createClient(options: ClientOptions): EmberClientBase;
+
+export { type AggregateArgs as A, type ConnectionConfig as C, type DriverOptions as D, EmberClientBase as E, type FindManyArgs as F, type GroupByArgs as G, type IncludeInput as I, type ModelDelegate as M, type OrderByInput as O, QueryEngine as Q, type ResultFieldExtension as R, type SqlDriver as S, type TransactionContext as T, type UpdateArgs as U, type WhereInput as W, type TransactionOptions as a, type SqlValue as b, type SqlDialect as c, type ClientOptions as d, type CreateArgs as e, type DeleteArgs as f, type FindUniqueArgs as g, FirebirdDialect as h, type IsolationLevel as i, type SelectInput as j, type UpsertArgs as k, createClient as l, type EmberExtensionArgs as m, type Middleware as n, type QueryEvent as o, type QueryHook as p, type QueryHookParams as q, type QueryLogger as r };

package/dist/index-CMeqhmVc.d.cts

@@ -0,0 +1,72 @@
+import { S as SchemaDocument } from './index-D0xIdtCl.cjs';
+
+/**
+ * Structural validation of a parsed schema. Throws SchemaValidationError with
+ * all detected problems at once so the user can fix them in a single pass.
+ */
+declare function validateSchema(doc: SchemaDocument): void;
+
+/**
+ * Serializes a SchemaDocument back into `.ember` source text.
+ * Used by `ember db pull` (introspection output) and `ember format`.
+ * Field columns are aligned for readability, mirroring Prisma's formatter.
+ */
+declare function printSchema(doc: SchemaDocument): string;
+
+/**
+ * Canonical formatter: parse, auto-complete missing relation sides (like
+ * Prisma's formatter), validate, and re-print with aligned formatting.
+ */
+declare function formatSchema(source: string, file?: string): string;
+/** Parse schema source text into an AST (no validation). */
+declare function parseSchema(source: string, file?: string): SchemaDocument;
+/** Parse and validate schema source text. */
+declare function parseAndValidate(source: string, file?: string): SchemaDocument;
+interface LoadedSchema {
+    document: SchemaDocument;
+    path: string;
+    /** Resolved connection URL (env() expanded). */
+    databaseUrl?: string;
+}
+/** Locate the schema file relative to a base directory. */
+declare function findSchemaPath(base?: string, explicit?: string): string | undefined;
+/** Load, parse, validate a schema file and resolve its datasource URL. */
+declare function loadSchema(path: string): LoadedSchema;
+declare function resolveDatasourceUrl(doc: SchemaDocument, _base: string): string | undefined;
+
+/** Base class for every error thrown by EmberORM. */
+declare class EmberError extends Error {
+    constructor(message: string);
+}
+/** Raised while lexing/parsing a `.ember` schema file. */
+declare class SchemaParseError extends EmberError {
+    readonly line: number;
+    readonly column: number;
+    readonly file?: string | undefined;
+    constructor(message: string, line: number, column: number, file?: string | undefined);
+}
+/** Raised when a parsed schema is structurally invalid. */
+declare class SchemaValidationError extends EmberError {
+    readonly details: string[];
+    constructor(message: string, details?: string[]);
+}
+/** Raised when a query is malformed before it reaches the database. */
+declare class QueryValidationError extends EmberError {
+}
+/** Wraps a low-level driver/database failure with EmberORM context. */
+declare class DatabaseError extends EmberError {
+    readonly cause?: unknown | undefined;
+    readonly sql?: string | undefined;
+    constructor(message: string, cause?: unknown | undefined, sql?: string | undefined);
+}
+/** Thrown by `*OrThrow` operations when no record matches. */
+declare class RecordNotFoundError extends EmberError {
+    constructor(model: string);
+}
+/** Thrown on unique constraint violations (mapped from Firebird errors). */
+declare class UniqueConstraintError extends EmberError {
+    readonly target: string;
+    constructor(target: string, cause?: unknown);
+}
+
+export { DatabaseError as D, EmberError as E, type LoadedSchema as L, QueryValidationError as Q, RecordNotFoundError as R, SchemaParseError as S, UniqueConstraintError as U, SchemaValidationError as a, parseSchema as b, printSchema as c, findSchemaPath as d, formatSchema as f, loadSchema as l, parseAndValidate as p, resolveDatasourceUrl as r, validateSchema as v };

package/dist/index-D0xIdtCl.d.cts

@@ -0,0 +1,145 @@
+/**
+ * EmberORM schema AST (DMMF-like).
+ *
+ * This is the single in-memory source of truth that every other layer
+ * (parser, validator, query engine, generator, introspection) depends on.
+ * It is intentionally decoupled from Firebird specifics so it can be reused
+ * for other dialects in the future.
+ */
+type ScalarType = "String" | "Boolean" | "Int" | "BigInt" | "Float" | "Decimal" | "DateTime" | "Bytes" | "Json";
+declare const SCALAR_TYPES: readonly ScalarType[];
+type FieldKind = "scalar" | "enum" | "object";
+/** Value of an attribute argument, e.g. `@default(now())` or `@map("USER_ID")`. */
+type AttributeArgValue = {
+    kind: "string";
+    value: string;
+} | {
+    kind: "number";
+    value: number;
+} | {
+    kind: "boolean";
+    value: boolean;
+} | {
+    kind: "ref";
+    value: string;
+} | {
+    kind: "function";
+    name: string;
+    args: AttributeArgValue[];
+} | {
+    kind: "array";
+    items: AttributeArgValue[];
+};
+interface DefaultValue {
+    /** A scalar literal default. */
+    literal?: string | number | boolean;
+    /** A function default such as now(), uuid(), cuid(), autoincrement(). */
+    function?: {
+        name: string;
+        args: AttributeArgValue[];
+    };
+}
+interface RelationInfo {
+    /** Relation name (@relation("name")). */
+    name?: string;
+    /** Local fields participating in the FK (`fields: [...]`). */
+    fields?: string[];
+    /** Referenced fields on the other model (`references: [...]`). */
+    references?: string[];
+    onDelete?: ReferentialAction;
+    onUpdate?: ReferentialAction;
+}
+type ReferentialAction = "Cascade" | "Restrict" | "NoAction" | "SetNull" | "SetDefault";
+interface NativeType {
+    /** e.g. "VarChar", "Decimal". */
+    name: string;
+    /** e.g. [255] or [18, 4]. */
+    args: number[];
+}
+interface FieldNode {
+    name: string;
+    /** Resolved type name: a ScalarType, an enum name, or a model name. */
+    type: string;
+    kind: FieldKind;
+    isList: boolean;
+    isRequired: boolean;
+    isId: boolean;
+    isUnique: boolean;
+    isUpdatedAt: boolean;
+    /** Column name in the database (@map). Defaults to `name`. */
+    dbName?: string;
+    default?: DefaultValue;
+    relation?: RelationInfo;
+    nativeType?: NativeType;
+    /** documentation/comment attached above the field (///). */
+    documentation?: string;
+}
+interface UniqueIndex {
+    name?: string;
+    fields: string[];
+}
+interface IndexNode {
+    name?: string;
+    fields: string[];
+    unique: boolean;
+}
+interface ModelNode {
+    name: string;
+    /** Table name in the database (@@map). Defaults to `name`. */
+    dbName?: string;
+    fields: FieldNode[];
+    /** Names of fields forming the primary key (composite supported via @@id). */
+    primaryKey: string[];
+    uniqueIndexes: UniqueIndex[];
+    indexes: IndexNode[];
+    documentation?: string;
+}
+interface EnumNode {
+    name: string;
+    dbName?: string;
+    values: {
+        name: string;
+        dbName?: string;
+    }[];
+    documentation?: string;
+}
+interface DatasourceNode {
+    name: string;
+    provider: string;
+    /** Raw url expression; env("X") resolved at runtime. */
+    url: {
+        kind: "literal" | "env";
+        value: string;
+    };
+}
+interface GeneratorNode {
+    name: string;
+    provider: string;
+    output?: string;
+    config: Record<string, string>;
+}
+interface SchemaDocument {
+    datasource?: DatasourceNode;
+    generators: GeneratorNode[];
+    models: ModelNode[];
+    enums: EnumNode[];
+}
+declare function emptySchema(): SchemaDocument;
+declare function findModel(schema: SchemaDocument, name: string): ModelNode | undefined;
+declare function findEnum(schema: SchemaDocument, name: string): EnumNode | undefined;
+/**
+ * Physical column name. Firebird folds unquoted identifiers to UPPER CASE, and
+ * EmberORM always quotes identifiers, so a field without an explicit `@map`
+ * resolves to its UPPER-CASED name to match the stored column. Use `@map` to
+ * target a column created with case-sensitive (quoted) lower/mixed case.
+ */
+declare function fieldColumn(field: FieldNode): string;
+/** Physical table name; same UPPER-CASE folding rule as {@link fieldColumn}. */
+declare function modelTable(model: ModelNode): string;
+/** Returns scalar fields only (excludes relation/object fields). */
+declare function scalarFields(model: ModelNode): FieldNode[];
+/** Returns relation (object) fields only. */
+declare function relationFields(model: ModelNode): FieldNode[];
+declare function idFields(model: ModelNode): FieldNode[];
+
+export { type AttributeArgValue as A, type DatasourceNode as D, type EnumNode as E, type FieldNode as F, type GeneratorNode as G, type IndexNode as I, type ModelNode as M, type NativeType as N, type ReferentialAction as R, type SchemaDocument as S, type UniqueIndex as U, SCALAR_TYPES as a, type ScalarType as b, type DefaultValue as c, type FieldKind as d, type RelationInfo as e, emptySchema as f, fieldColumn as g, findEnum as h, findModel as i, idFields as j, modelTable as m, relationFields as r, scalarFields as s };