@an5/orm 1.0.9 → 1.1.0

package/dist/generator/src/suggest.d.ts

@@ -0,0 +1,17 @@
+/**
+ * "Did you mean" for typos.
+ *
+ * Lives on its own because two callers need it and neither should own it:
+ * the config loader (a mistyped option key) and the field type registry (a
+ * type written for the wrong database). Both want the nearest candidate out
+ * of a known list, or nothing at all when the input is not close enough that
+ * a suggestion would be honest.
+ */
+/** Levenshtein distance between two strings. */
+export declare function editDistance(a: string, b: string): number;
+/**
+ * The candidate closest to `input`, or null when none is close enough to be a
+ * plausible typo. Comparing case-insensitively keeps `nvarchar` from suggesting
+ * something unrelated just because of capitalisation.
+ */
+export declare function suggest(input: string, candidates: readonly string[]): string | null;

package/dist/generator/src/suggest.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * "Did you mean" for typos.
+ *
+ * Lives on its own because two callers need it and neither should own it:
+ * the config loader (a mistyped option key) and the field type registry (a
+ * type written for the wrong database). Both want the nearest candidate out
+ * of a known list, or nothing at all when the input is not close enough that
+ * a suggestion would be honest.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.editDistance = editDistance;
+exports.suggest = suggest;
+/** Levenshtein distance between two strings. */
+function editDistance(a, b) {
+    const rows = [];
+    for (let i = 0; i <= a.length; i++)
+        rows.push([i, ...new Array(b.length).fill(0)]);
+    for (let j = 0; j <= b.length; j++)
+        rows[0][j] = j;
+    for (let i = 1; i <= a.length; i++) {
+        for (let j = 1; j <= b.length; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            rows[i][j] = Math.min(rows[i - 1][j] + 1, rows[i][j - 1] + 1, rows[i - 1][j - 1] + cost);
+        }
+    }
+    return rows[a.length][b.length];
+}
+/**
+ * The candidate closest to `input`, or null when none is close enough to be a
+ * plausible typo. Comparing case-insensitively keeps `nvarchar` from suggesting
+ * something unrelated just because of capitalisation.
+ */
+function suggest(input, candidates) {
+    let best = null;
+    let bestDistance = Infinity;
+    for (const candidate of candidates) {
+        const distance = editDistance(input.toLowerCase(), candidate.toLowerCase());
+        if (distance < bestDistance) {
+            bestDistance = distance;
+            best = candidate;
+        }
+    }
+    return best !== null && bestDistance <= Math.max(2, Math.floor(input.length / 3)) ? best : null;
+}

package/dist/generator/src/type-kinds.d.ts

@@ -0,0 +1,27 @@
+/**
+ * What a field *is*, for the generators that need a real type.
+ *
+ * The parser gives every generator the same TypeScript type, and that type loses
+ * what a language needs: `INT`, `FLOAT` and `DECIMAL` all arrive as `number`, so
+ * the Go client generated every numeric column as a `string`, and the Python, Rust
+ * and .NET clients turned a `DECIMAL` into an integer type. The declared type is
+ * right there in `Field.sqlType`, so it decides — with the TypeScript type as the
+ * fallback for metadata generated before that was recorded.
+ */
+import { Provider } from './field-types';
+/** The categories a generated language type can be built from. */
+export type FieldKind = 'int' | 'bigint' | 'float' | 'bool' | 'date' | 'bytes' | 'json' | 'vector' | 'string';
+export interface KindInput {
+    /** The TypeScript type the parser produced, e.g. `number | bigint`. */
+    type: string;
+    /** The type as written in the schema, e.g. `DECIMAL(10,2)`. */
+    sqlType?: string | undefined;
+}
+/**
+ * The category a field belongs to.
+ *
+ * `TIMESTAMP` is the reason `provider` is a parameter: it is a rowversion on SQL
+ * Server and a point in time everywhere else, and the same word has to produce
+ * bytes in one and a date in the other.
+ */
+export declare function fieldKind(field: KindInput, provider?: Provider | undefined): FieldKind;

package/dist/generator/src/type-kinds.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fieldKind = fieldKind;
+const INT = ['INT', 'INTEGER', 'SMALLINT', 'TINYINT', 'MEDIUMINT', 'INT2', 'INT4', 'SERIAL', 'SMALLSERIAL', 'YEAR'];
+const BIGINT = ['BIGINT', 'INT8', 'BIGSERIAL', 'UNSIGNED BIG INT'];
+const FLOAT = ['FLOAT', 'REAL', 'DOUBLE', 'DOUBLE PRECISION', 'DECIMAL', 'NUMERIC', 'MONEY', 'SMALLMONEY', 'FIXED'];
+const BOOL = ['BIT', 'BOOL', 'BOOLEAN'];
+const DATE = [
+    'DATE', 'DATETIME', 'DATETIME2', 'SMALLDATETIME', 'DATETIMEOFFSET',
+    'TIME', 'TIMETZ', 'TIMESTAMPTZ', 'TIME WITH TIME ZONE', 'TIME WITHOUT TIME ZONE',
+    'TIMESTAMP WITH TIME ZONE', 'TIMESTAMP WITHOUT TIME ZONE',
+];
+const BYTES = ['BINARY', 'VARBINARY', 'IMAGE', 'BLOB', 'TINYBLOB', 'MEDIUMBLOB', 'LONGBLOB', 'BYTEA', 'ROWVERSION', 'BYTES'];
+const JSON = ['JSON', 'JSONB', 'SQL_VARIANT'];
+/** `DECIMAL(10,2)` → `DECIMAL`. */
+function declaredBase(sqlType) {
+    const withoutParams = sqlType.replace(/\([^)]*\)/g, ' ').trim();
+    return withoutParams.replace(/\s+/g, ' ').toUpperCase();
+}
+/**
+ * The category a field belongs to.
+ *
+ * `TIMESTAMP` is the reason `provider` is a parameter: it is a rowversion on SQL
+ * Server and a point in time everywhere else, and the same word has to produce
+ * bytes in one and a date in the other.
+ */
+function fieldKind(field, provider) {
+    const base = field.sqlType ? declaredBase(field.sqlType) : '';
+    if (base) {
+        if (base === 'TIMESTAMP')
+            return provider === 'mssql' ? 'bytes' : 'date';
+        if (INT.includes(base))
+            return 'int';
+        if (BIGINT.includes(base))
+            return 'bigint';
+        if (FLOAT.includes(base))
+            return 'float';
+        if (BOOL.includes(base))
+            return 'bool';
+        if (DATE.includes(base) || base === 'TIMESTAMP')
+            return 'date';
+        if (BYTES.includes(base))
+            return 'bytes';
+        if (JSON.includes(base))
+            return 'json';
+        if (base === 'VECTOR')
+            return 'vector';
+        return 'string';
+    }
+    // No declared type: fall back to what the TypeScript type can still tell us. A
+    // plain `number` is an integer here, which is what every generator assumed
+    // before `sqlType` was available.
+    const raw = field.type.trim().toLowerCase();
+    // Checked before the brackets are stripped, or `number[] | string` — the vector
+    // type — would read as a number.
+    if (raw.includes('[]'))
+        return 'vector';
+    const ts = raw.replace(/[?\]]/g, '').trim();
+    if (ts.startsWith('number | bigint'))
+        return 'bigint';
+    if (ts.startsWith('number'))
+        return 'int';
+    if (ts.startsWith('date'))
+        return 'date';
+    if (ts.startsWith('bool'))
+        return 'bool';
+    if (ts.startsWith('buffer'))
+        return 'bytes';
+    if (ts === 'any')
+        return 'json';
+    return 'string';
+}

package/dist/generator/src/types.d.ts

@@ -1,3 +1,4 @@
+import { Provider } from './field-types';
 export interface Field {
     name: string;
     type: string;
@@ -15,13 +16,45 @@ export interface Relation {
     foreignKey: string;
     localKey: string;
     relationName: string;
+    /** From a trailing @description("...") on the relation line. */
+    description?: string;
 }
 export interface Model {
     name: string;
     tableName: string;
+    /** Empty for a database with no schemas, or when `@@schema("")` says so. */
     schemaName: string;
+    /**
+     * The database this schema targets. Set by `SchemaParser`, and what decides how a
+     * table name is written — see `bracketedTableName`.
+     */
+    provider?: Provider | undefined;
     fields: Field[];
     relations: Relation[];
     compoundUniques?: string[][];
     description?: string;
 }
+/**
+ * The table name as it goes into the generated metadata.
+ *
+ * SQL Server keeps the bracketed form it has always had. Every other provider gets
+ * the bare name, with the schema as a plain prefix, because the brackets are not
+ * portable: `[dbo].[users]` is invalid SQL in PostgreSQL, and on SQLite it fails with
+ * "no such table: dbo.users" — which is why the adapters had to strip it afterwards.
+ * A bare name is correct everywhere once the adapter quotes it, and the adapters
+ * already quote per dialect (`quote()` in `@an5/adapters`, `An5DbContext.Quote()` in
+ * the .NET client), so the one form that needs no translation is the one emitted.
+ *
+ * `dbo` is SQL Server's default schema and only SQL Server's: with `@@schema("")` —
+ * an empty schema, meant for databases that have no schema concept — the prefix has
+ * to go, because `[].[users]` is not valid SQL. The `[${schemaName}].[${tableName}]`
+ * formula used to be written out in six places, so every dialect got `[dbo]`.
+ */
+export declare function bracketedTableName(model: Model): string;
+/**
+ * The table name as `schema.table`, for clients that pass a string instead of SQL.
+ *
+ * Unquoted for the same reason as `bracketedTableName`: these strings go to the same
+ * per-dialect quoting.
+ */
+export declare function dottedTableName(model: Model): string;

package/dist/generator/src/types.js

@@ -1,2 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.bracketedTableName = bracketedTableName;
+exports.dottedTableName = dottedTableName;
+/**
+ * The table name as it goes into the generated metadata.
+ *
+ * SQL Server keeps the bracketed form it has always had. Every other provider gets
+ * the bare name, with the schema as a plain prefix, because the brackets are not
+ * portable: `[dbo].[users]` is invalid SQL in PostgreSQL, and on SQLite it fails with
+ * "no such table: dbo.users" — which is why the adapters had to strip it afterwards.
+ * A bare name is correct everywhere once the adapter quotes it, and the adapters
+ * already quote per dialect (`quote()` in `@an5/adapters`, `An5DbContext.Quote()` in
+ * the .NET client), so the one form that needs no translation is the one emitted.
+ *
+ * `dbo` is SQL Server's default schema and only SQL Server's: with `@@schema("")` —
+ * an empty schema, meant for databases that have no schema concept — the prefix has
+ * to go, because `[].[users]` is not valid SQL. The `[${schemaName}].[${tableName}]`
+ * formula used to be written out in six places, so every dialect got `[dbo]`.
+ */
+function bracketedTableName(model) {
+    const qualified = model.schemaName
+        ? `${model.schemaName}.${model.tableName}`
+        : model.tableName;
+    if ((model.provider ?? 'mssql') !== 'mssql')
+        return qualified;
+    return model.schemaName
+        ? `[${model.schemaName}].[${model.tableName}]`
+        : `[${model.tableName}]`;
+}
+/**
+ * The table name as `schema.table`, for clients that pass a string instead of SQL.
+ *
+ * Unquoted for the same reason as `bracketedTableName`: these strings go to the same
+ * per-dialect quoting.
+ */
+function dottedTableName(model) {
+    return model.schemaName
+        ? `${model.schemaName}.${model.tableName}`
+        : model.tableName;
+}

package/dist/migration-core.d.ts

@@ -1,3 +1,4 @@
+import { Provider } from './generator/src/field-types';
 export interface SchemaField {
     name: string;
     sqlType: string;
@@ -16,6 +17,11 @@ export interface SchemaIndexDefinition {
 }
 export interface SchemaModel {
     name: string;
+    /**
+     * The table to create, schema-qualified when the model named a schema other than
+     * `dbo`. `dbo` stays implicit so an unqualified model produces the same SQL it
+     * always has.
+     */
     tableName: string;
     fields: SchemaField[];
     compoundUniques: Array<string[] | SchemaIndexDefinition>;
@@ -70,7 +76,16 @@ export declare function buildAlterColumnWarnings(previousSqlType: string, nextSq
 export declare function buildAlterColumnPreflightSql(tableName: string, columnName: string, previousSqlType: string, nextSqlType: string, previousNullable: boolean, nextNullable: boolean): string[];
 export declare function buildAddColumnPreflightSql(tableName: string, field: SchemaField): string[];
 export declare function buildUniqueConstraintPreflightSql(tableName: string, fields: string[]): string[];
-export declare function parseSchemaText(text: string): SchemaModel[];
+/**
+ * Reads a `.an5` schema into models to compare against the database.
+ *
+ * `provider` decides what counts as a column and what counts as a relation; it
+ * defaults to SQL Server. A type the provider does not have is reported rather
+ * than skipped — skipping it means the migration silently never mentions that
+ * column. A token matching a model in the schema is a relation, so that
+ * comparison waits until the whole schema has been read.
+ */
+export declare function parseSchemaText(text: string, provider?: Provider): SchemaModel[];
 export declare function buildCreateTableSql(model: SchemaModel): string;
 export declare function buildIndexDiff(model: SchemaModel, artifacts: TableArtifacts, ops: MigrationOp[]): void;
 export declare function generateColumnDiff(model: SchemaModel, dbColumns: DbColumn[], ops: MigrationOp[]): void;

package/dist/migration-core.js

@@ -21,15 +21,7 @@ exports.parseMigrationSections = parseMigrationSections;
 exports.splitSqlBatches = splitSqlBatches;
 exports.parseRollbackSelection = parseRollbackSelection;
 exports.parseMigrationCommandOptions = parseMigrationCommandOptions;
-const AN5_TYPES = new Set([
-    'NVARCHAR', 'VARCHAR', 'CHAR', 'NCHAR', 'TEXT', 'NTEXT', 'XML',
-    'INT', 'SMALLINT', 'TINYINT', 'BIGINT', 'FLOAT', 'REAL', 'DECIMAL', 'NUMERIC',
-    'MONEY', 'SMALLMONEY', 'BIT',
-    'DATETIME', 'DATETIME2', 'SMALLDATETIME', 'DATE', 'TIME', 'DATETIMEOFFSET',
-    'VARBINARY', 'BINARY', 'IMAGE',
-    'UNIQUEIDENTIFIER', 'SQL_VARIANT', 'ROWVERSION',
-    'HIERARCHYID', 'GEOGRAPHY', 'GEOMETRY', 'VECTOR',
-]);
+const field_types_1 = require("./generator/src/field-types");
 function parseSqlType(raw) {
     const match = raw.match(/^(\w+)/);
     return match?.[1]?.toUpperCase() ?? raw.toUpperCase();
@@ -264,8 +256,21 @@ function buildUniqueConstraintPreflightSql(tableName, fields) {
 )
   THROW 51000, 'an5 migration preflight failed: ${escapeSqlString(label)} has duplicate values for a UNIQUE constraint.', 1`];
 }
-function parseSchemaText(text) {
+/**
+ * Reads a `.an5` schema into models to compare against the database.
+ *
+ * `provider` decides what counts as a column and what counts as a relation; it
+ * defaults to SQL Server. A type the provider does not have is reported rather
+ * than skipped — skipping it means the migration silently never mentions that
+ * column. A token matching a model in the schema is a relation, so that
+ * comparison waits until the whole schema has been read.
+ */
+function parseSchemaText(text, provider = field_types_1.DEFAULT_PROVIDER) {
     const models = [];
+    const typeIssues = [];
+    const modelRefs = [];
+    /** `@@schema` per model, applied after the model is read rather than mid-loop. */
+    const schemas = new Map();
     const lines = text.split('\n');
     let current = null;
     for (let line of lines) {
@@ -292,11 +297,25 @@ function parseSchemaText(text) {
         if (!current)
             continue;
         if (line.startsWith('@@map')) {
+            // Just the table name. A schema comes from `@@schema` alone, because a mapped
+            // name may legitimately contain a dot: `@@map("reports.daily")` is one table
+            // whose name has a dot in it, not a table called `daily` in a schema called
+            // `reports`.
             const m = line.match(/@@map\("(.+)"\)/);
             if (m?.[1])
                 current.tableName = m[1];
             continue;
         }
+        if (line.startsWith('@@schema')) {
+            // The directive used to be dropped here while `db:push` and the generators
+            // honoured it, so a migration created the table in the connection's default
+            // schema and the client then read the one the schema file named. Composed in
+            // once the whole model has been read, below.
+            const m = line.match(/@@schema\("(.*)"\)/);
+            if (m !== null)
+                schemas.set(current, m[1]?.trim() ?? '');
+            continue;
+        }
         if (line.startsWith('@@unique')) {
             const parsed = parseMappedIndex(line, '@@unique');
             if (parsed)
@@ -311,25 +330,45 @@ function parseSchemaText(text) {
         }
         if (line.startsWith('@@'))
             continue;
-        const parts = line.split(/\s+/);
-        const fieldName = parts[0];
-        const fieldType = parts[1];
-        if (!fieldName || !fieldType)
+        const head = (0, field_types_1.readFieldLineHead)(line);
+        if (!head)
             continue;
-        const cleanType = fieldType.replace('[]', '').replace('?', '');
-        const sqlBase = parseSqlType(cleanType);
-        if (!AN5_TYPES.has(sqlBase))
+        if (!(0, field_types_1.resolveFieldType)(head.type, provider)) {
+            modelRefs.push({ model: current.name, field: head.name, type: head.type });
             continue;
+        }
         current.fields.push({
-            name: fieldName,
-            sqlType: cleanType.toUpperCase(),
-            isOptional: fieldType.endsWith('?'),
+            name: head.name,
+            sqlType: head.type.toUpperCase(),
+            isOptional: head.isOptional,
             isId: line.includes('@id'),
             isUnique: line.includes('@unique'),
             uniqueName: line.match(/@unique\([^)]*\bmap\s*:\s*"([^"]+)"/)?.[1],
-            defaultValue: line.match(/@default\((.*)\)/)?.[1],
+            // `@updatedAt` is `now()` under another name, and db:push treats it as such.
+            // Without this here a stamp column looked like it had no default and every
+            // diff wanted to add one.
+            defaultValue: line.match(/@default\((.*)\)/)?.[1]
+                ?? (line.includes('@updatedAt') ? 'now()' : undefined),
         });
     }
+    // `dbo` stays implicit: an unqualified model produces the SQL it always has, and a
+    // named one is qualified with the schema the schema file asked for.
+    for (const model of models) {
+        const schema = schemas.get(model) ?? '';
+        if (schema && schema !== 'dbo')
+            model.tableName = `${schema}.${model.tableName}`;
+    }
+    const modelNames = models.map((model) => model.name);
+    for (const ref of modelRefs) {
+        if (!modelNames.includes(ref.type)) {
+            typeIssues.push({
+                path: `${ref.model}.${ref.field}`,
+                message: (0, field_types_1.unknownFieldTypeMessage)(ref.type, provider, modelNames),
+            });
+        }
+    }
+    if (typeIssues.length > 0)
+        throw new field_types_1.FieldTypeError(provider, typeIssues);
     return models;
 }
 function buildCreateTableSql(model) {

package/dist/orm.d.ts

@@ -0,0 +1,147 @@
+import { An5Adapter, AdapterTableClient } from "@an5/adapters";
+import { An5Metadata } from "./metadata";
+type ExecutorFn = ((queryText: string, params?: Record<string, any>) => Promise<any[]>) & {
+    executeRaw?: (queryText: string, params?: Record<string, any>) => Promise<number>;
+    transaction?: <R>(fn: (txExecutor: ExecutorFn) => Promise<R>, options?: {
+        timeout?: number;
+    }) => Promise<R>;
+    beginTransaction?: () => Promise<InteractiveTransactionExecutor>;
+};
+type InteractiveTransactionExecutor = {
+    executor: ExecutorFn;
+    commit: () => Promise<void>;
+    rollback: () => Promise<void>;
+};
+export declare class TableClient<T = any> extends AdapterTableClient<T> {
+    private executor;
+    private orm;
+    readonly rawTableName: string;
+    constructor(modelName: string, rawTableName: string, executor: ExecutorFn, orm: An5ORM);
+    private executeRaw;
+    findMany(args?: any): Promise<T[]>;
+    findFirst(args?: any): Promise<T | null>;
+    findUnique(args?: any): Promise<T | null>;
+    count(args?: any): Promise<number>;
+    private scopedRelationWhere;
+    private handleNestedWrites;
+    create(args: any): Promise<T>;
+    update(args: any): Promise<T>;
+    updateMany(args: any): Promise<{
+        count: number;
+    }>;
+    delete(args: any): Promise<T>;
+    deleteMany(args?: any): Promise<{
+        count: number;
+    }>;
+    vectorSearch(args: {
+        vector: number[];
+        take?: number;
+        where?: any;
+        include?: any;
+        vectorField?: string;
+        distanceMetric?: 'cosine' | 'euclidean' | 'dot';
+        vectorElementType?: 'float32' | 'float16' | 'uint8';
+    }): Promise<(T & {
+        distance: number;
+    })[]>;
+    createMany(args: {
+        data: any[];
+        skipDuplicates?: boolean;
+    }): Promise<{
+        count: number;
+    }>;
+    aggregate(args: any): Promise<any>;
+    groupBy(args: any): Promise<any[]>;
+    private sequentialUpsert;
+    upsert(args: any): Promise<T>;
+}
+export interface MiddlewareParams {
+    model?: string;
+    action: string;
+    args: any;
+    runInTransaction?: boolean;
+}
+export type MiddlewareNext = (params: MiddlewareParams) => Promise<any>;
+export type Middleware = (params: MiddlewareParams, next: MiddlewareNext) => Promise<any>;
+export type LogLevel = "query" | "info" | "warn" | "error";
+export interface QueryEvent {
+    timestamp: Date;
+    query: string;
+    params?: Record<string, any>;
+    duration: number;
+    model?: string;
+    action?: string;
+    error?: Error;
+}
+export interface LogEvent {
+    timestamp: Date;
+    message: string;
+    level: LogLevel;
+    duration?: number;
+    query?: string;
+    params?: Record<string, any>;
+    error?: Error;
+}
+export type EventListener<T = any> = (event: T) => void;
+export declare class ViewClient<T = any> {
+    viewName: string;
+    rawTableName: string;
+    executor: ExecutorFn;
+    orm?: An5ORM | undefined;
+    private tableClient;
+    constructor(viewName: string, rawTableName: string, executor: ExecutorFn, orm?: An5ORM | undefined);
+    findMany(args?: any): Promise<T[]>;
+    findFirst(args?: any): Promise<T | null>;
+    findUnique(args?: any): Promise<T | null>;
+    count(args?: any): Promise<number>;
+    aggregate(args?: any): Promise<any>;
+    groupBy(args?: any): Promise<any[]>;
+    vectorSearch(args: any): Promise<T[]>;
+    create(): Promise<never>;
+    createMany(): Promise<never>;
+    update(): Promise<never>;
+    updateMany(): Promise<never>;
+    delete(): Promise<never>;
+    deleteMany(): Promise<never>;
+    upsert(): Promise<never>;
+}
+export declare class An5ORM {
+    private readonly inTransaction;
+    private transactionControl?;
+    [key: string]: any;
+    private middlewares;
+    private eventListeners;
+    slowQueryThresholdMs: number;
+    readonly metadata: An5Metadata;
+    private customExecutor?;
+    constructor(customExecutor?: ExecutorFn | An5Adapter | any, metadata?: An5Metadata, inTransaction?: boolean, transactionControl?: Pick<InteractiveTransactionExecutor, "commit" | "rollback"> | undefined);
+    $on(event: "query", listener: EventListener<QueryEvent>): void;
+    $on(event: "info" | "warn" | "error", listener: EventListener<LogEvent>): void;
+    $off(event: string, listener: EventListener): void;
+    $emit(event: string, payload: any): void;
+    private getExecutor;
+    table(name: string): TableClient;
+    view(name: string): ViewClient;
+    $view(name: string): ViewClient;
+    $queryProc<T = any>(procName: string, params?: Record<string, any> | any[]): Promise<T[]>;
+    $executeProc(procName: string, params?: Record<string, any> | any[]): Promise<number>;
+    $queryFunction<T = any>(fnName: string, params?: Record<string, any> | any[]): Promise<T[]>;
+    $use(middleware: Middleware): void;
+    parseWhere(modelName: string, where: any, params: Record<string, any>, prefix?: string): string;
+    _executeMiddleware(params: MiddlewareParams, finalAction: (params: MiddlewareParams) => Promise<any>): Promise<any>;
+    $connect(): Promise<void>;
+    $disconnect(): Promise<void>;
+    $queryRaw(queryParts: any, ...values: any[]): Promise<any[]>;
+    $queryRawUnsafe<R = any>(queryText: string, ...values: any[]): Promise<R>;
+    $executeRaw(queryParts: any, ...values: any[]): Promise<number>;
+    $executeRawUnsafe(queryText: string, ...values: any[]): Promise<number>;
+    $transaction<R>(fn: ((tx: any) => Promise<R>) | Promise<any>[], options?: {
+        timeout?: number;
+    }): Promise<any>;
+    $begin(): Promise<any>;
+    $commit(): Promise<void>;
+    $rollback(): Promise<void>;
+}
+export declare const an5Orm: An5ORM;
+export default an5Orm;
+//# sourceMappingURL=orm.d.ts.map