metal-orm 1.0.89 → 1.0.91

package/dist/index.d.ts

@@ -23,7 +23,7 @@ type ReferentialAction = 'NO ACTION' | 'RESTRICT' | 'CASCADE' | 'SET NULL' | 'SE
 interface RawDefaultValue {
     raw: string;
 }
-type DefaultValue = unknown | RawDefaultValue;
+type DefaultValue = string | number | boolean | Date | null | RawDefaultValue;
 interface ForeignKeyReference {
     /** Target table name */
     table: string;
@@ -69,7 +69,7 @@ interface ColumnDef<T extends ColumnType = ColumnType, TRuntime = unknown> {
     /** Column comment/description */
     comment?: string;
     /** Additional arguments for the column type (e.g., VARCHAR length) */
-    args?: unknown[];
+    args?: (string | number)[];
     /** Table name this column belongs to (filled at runtime by defineTable) */
     table?: string;
 }
@@ -161,7 +161,7 @@ declare const col: {
      */
     custom: (type: string, opts?: {
         dialect?: string;
-        args?: unknown[];
+        args?: (string | number)[];
         tsType?: unknown;
     }) => ColumnDef;
     /**
@@ -181,7 +181,7 @@ declare const col: {
     /**
      * Sets a default value for the column
      */
-    default: <T extends ColumnType>(def: ColumnDef<T>, value: unknown) => ColumnDef<T>;
+    default: <T extends ColumnType>(def: ColumnDef<T>, value: DefaultValue) => ColumnDef<T>;
     /**
      * Sets a raw SQL default value for the column
      */
@@ -445,13 +445,18 @@ declare function getColumn<T extends TableDef>(table: T, key: string): ColumnDef
  * Resolves a relation definition to its target table type.
  */
 type RelationTargetTable<TRel extends RelationDef> = TRel extends HasManyRelation<infer TTarget> ? TTarget : TRel extends HasOneRelation<infer TTarget> ? TTarget : TRel extends BelongsToRelation<infer TTarget> ? TTarget : TRel extends BelongsToManyRelation<infer TTarget, TableDef> ? TTarget : never;
+type JsonValue = string | number | boolean | null | JsonArray | JsonObject;
+type JsonArray = Array<JsonValue>;
+interface JsonObject {
+    [key: string]: JsonValue;
+}
 type NormalizedColumnType<T extends ColumnDef> = Lowercase<T['type'] & string>;
 /**
  * Maps a ColumnDef to its TypeScript type representation
  */
 type ColumnToTs<T extends ColumnDef> = [
     unknown
-] extends [T['tsType']] ? NormalizedColumnType<T> extends 'int' | 'integer' ? number : NormalizedColumnType<T> extends 'bigint' ? number | bigint : NormalizedColumnType<T> extends 'decimal' | 'float' | 'double' ? number : NormalizedColumnType<T> extends 'boolean' ? boolean : NormalizedColumnType<T> extends 'json' ? unknown : NormalizedColumnType<T> extends 'blob' | 'binary' | 'varbinary' | 'bytea' ? Buffer : NormalizedColumnType<T> extends 'date' | 'datetime' | 'timestamp' | 'timestamptz' ? string : string : Exclude<T['tsType'], undefined>;
+] extends [T['tsType']] ? NormalizedColumnType<T> extends 'int' | 'integer' ? number : NormalizedColumnType<T> extends 'bigint' ? number | bigint : NormalizedColumnType<T> extends 'decimal' | 'float' | 'double' ? number : NormalizedColumnType<T> extends 'boolean' ? boolean : NormalizedColumnType<T> extends 'json' ? JsonValue : NormalizedColumnType<T> extends 'blob' | 'binary' | 'varbinary' | 'bytea' ? Buffer : NormalizedColumnType<T> extends 'date' | 'datetime' | 'timestamp' | 'timestamptz' ? string : string : Exclude<T['tsType'], undefined>;
 /**
  * Infers a row shape from a table definition
  */
@@ -656,14 +661,6 @@ interface LiteralNode {
     /** The literal value (string, number, boolean, Date, or null) */
     value: string | number | boolean | Date | null;
 }
-/**
- * AST node representing a named parameter placeholder
- */
-interface ParamNode {
-    type: 'Param';
-    /** Stable parameter name */
-    name: string;
-}
 /**
  * AST node representing a reference to a SELECT alias (for ORDER BY / GROUP BY).
  */
@@ -794,7 +791,7 @@ interface ArithmeticExpressionNode {
 /**
  * Union type representing any operand that can be used in expressions
  */
-type OperandNode = AliasRefNode | ColumnNode | LiteralNode | ParamNode | FunctionNode | JsonPathNode | ScalarSubqueryNode | CaseExpressionNode | CastExpressionNode | WindowFunctionNode | ArithmeticExpressionNode | BitwiseExpressionNode | CollateExpressionNode;
+type OperandNode = AliasRefNode | ColumnNode | LiteralNode | FunctionNode | JsonPathNode | ScalarSubqueryNode | CaseExpressionNode | CastExpressionNode | WindowFunctionNode | ArithmeticExpressionNode | BitwiseExpressionNode | CollateExpressionNode;
 declare const isOperandNode: (node: unknown) => node is OperandNode;
 declare const isFunctionNode: (node: unknown) => node is FunctionNode;
 declare const isCaseExpressionNode: (node: unknown) => node is CaseExpressionNode;
@@ -1446,8 +1443,6 @@ interface ExpressionVisitor<R> {
     visitBetweenExpression?(node: BetweenExpressionNode): R;
     visitArithmeticExpression?(node: ArithmeticExpressionNode): R;
     visitBitwiseExpression?(node: BitwiseExpressionNode): R;
-    visitOperand?(node: OperandNode): R;
-    visitSelectQuery?(node: SelectQueryNode): R;
     otherwise?(node: ExpressionNode): R;
 }
 /**
@@ -1456,17 +1451,12 @@ interface ExpressionVisitor<R> {
 interface OperandVisitor<R> {
     visitColumn?(node: ColumnNode): R;
     visitLiteral?(node: LiteralNode): R;
-    visitParam?(node: ParamNode): R;
     visitFunction?(node: FunctionNode): R;
     visitJsonPath?(node: JsonPathNode): R;
     visitScalarSubquery?(node: ScalarSubqueryNode): R;
     visitCaseExpression?(node: CaseExpressionNode): R;
     visitCast?(node: CastExpressionNode): R;
     visitWindowFunction?(node: WindowFunctionNode): R;
-    visitArithmeticExpression?(node: ArithmeticExpressionNode): R;
-    visitBitwiseExpression?(node: BitwiseExpressionNode): R;
-    visitExpression?(node: ExpressionNode): R;
-    visitSelectQuery?(node: SelectQueryNode): R;
     visitCollate?(node: CollateExpressionNode): R;
     visitAliasRef?(node: AliasRefNode): R;
     otherwise?(node: OperandNode): R;
@@ -1483,8 +1473,6 @@ declare const registerExpressionDispatcher: (type: string, dispatcher: Expressio
  * Allows new node kinds without modifying the core switch.
  */
 declare const registerOperandDispatcher: (type: string, dispatcher: OperandDispatch) => void;
-declare const hasExpressionDispatcher: (type: string) => boolean;
-declare const hasOperandDispatcher: (type: string) => boolean;
 /**
  * Clears all registered dispatchers. Primarily for tests.
  */
@@ -1503,14 +1491,6 @@ declare const visitExpression: <R>(node: ExpressionNode, visitor: ExpressionVisi
  */
 declare const visitOperand: <R>(node: OperandNode, visitor: OperandVisitor<R>) => R;
 
-type ParamProxy = ParamNode & {
-    [key: string]: ParamProxy;
-};
-type ParamProxyRoot = {
-    [key: string]: ParamProxy;
-};
-declare const createParamProxy: () => ParamProxyRoot;
-
 /**
  * Adapts a schema ColumnDef to an AST-friendly ColumnRef.
  */
@@ -1828,8 +1808,6 @@ interface CompilerContext {
     params: unknown[];
     /** Function to add a parameter and get its placeholder */
     addParameter(value: unknown): string;
-    /** Whether Param operands are allowed (for schema generation) */
-    allowParams?: boolean;
 }
 /**
  * Result of SQL compilation
@@ -1864,9 +1842,6 @@ declare abstract class Dialect implements SelectCompiler, InsertCompiler, Update
      * @returns Compiled query with SQL and parameters
      */
     compileSelect(ast: SelectQueryNode): CompiledQuery;
-    compileSelectWithOptions(ast: SelectQueryNode, options?: {
-        allowParams?: boolean;
-    }): CompiledQuery;
     compileInsert(ast: InsertQueryNode): CompiledQuery;
     compileUpdate(ast: UpdateQueryNode): CompiledQuery;
     compileDelete(ast: DeleteQueryNode): CompiledQuery;
@@ -1907,12 +1882,9 @@ declare abstract class Dialect implements SelectCompiler, InsertCompiler, Update
     protected compileSelectForExists(ast: SelectQueryNode, ctx: CompilerContext): string;
     /**
      * Creates a new compiler context
-     * @param options - Optional compiler context options
      * @returns Compiler context with parameter management
      */
-    protected createCompilerContext(options?: {
-        allowParams?: boolean;
-    }): CompilerContext;
+    protected createCompilerContext(): CompilerContext;
     /**
      * Formats a parameter placeholder
      * @param index - Parameter index
@@ -2400,7 +2372,6 @@ declare class QueryAstService {
      * @returns Normalized ordering term
      */
     private normalizeOrderingTerm;
-    private toParamNode;
 }
 
 /**
@@ -2710,7 +2681,6 @@ type NormalizedRelationIncludeTree = Record<string, NormalizedRelationIncludeNod
 type QueryResult = {
     columns: string[];
     values: unknown[][];
-    insertId?: number;
 };
 interface DbExecutor {
     /** Capability flags so the runtime can make correct decisions without relying on optional methods. */
@@ -3264,7 +3234,6 @@ declare class UnitOfWork {
      * @param results - Query results
      */
     private applyReturningResults;
-    private applyInsertId;
     /**
      * Normalizes a column name by removing quotes and table prefixes.
      * @param column - The column name to normalize
@@ -3813,191 +3782,6 @@ interface PaginatedResult<T> {
     pageSize: number;
 }
 
-/**
- * OpenAPI 3.1 JSON Schema type representation
- */
-type JsonSchemaType = 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array' | 'null';
-/**
- * Common OpenAPI 3.1 JSON Schema formats
- */
-type JsonSchemaFormat = 'date-time' | 'date' | 'time' | 'email' | 'uuid' | 'uri' | 'binary' | 'base64';
-/**
- * OpenAPI 3.1 JSON Schema property definition
- */
-interface JsonSchemaProperty {
-    type?: JsonSchemaType | JsonSchemaType[];
-    format?: JsonSchemaFormat;
-    description?: string;
-    nullable?: boolean;
-    readOnly?: boolean;
-    writeOnly?: boolean;
-    minimum?: number;
-    maximum?: number;
-    minLength?: number;
-    maxLength?: number;
-    pattern?: string;
-    enum?: (string | number | boolean)[];
-    default?: unknown;
-    example?: unknown;
-    properties?: Record<string, JsonSchemaProperty>;
-    required?: string[];
-    items?: JsonSchemaProperty;
-    $ref?: string;
-    anyOf?: JsonSchemaProperty[];
-    allOf?: JsonSchemaProperty[];
-    oneOf?: JsonSchemaProperty[];
-    [key: string]: unknown;
-}
-/**
- * OpenAPI 3.1 parameter definition
- */
-interface OpenApiParameter {
-    name: string;
-    in: 'query' | 'path' | 'header' | 'cookie';
-    description?: string;
-    required?: boolean;
-    deprecated?: boolean;
-    allowEmptyValue?: boolean;
-    style?: string;
-    explode?: boolean;
-    schema?: JsonSchemaProperty;
-    [key: string]: unknown;
-}
-/**
- * Complete OpenAPI 3.1 Schema for an entity or query result
- */
-interface OpenApiSchema {
-    type: 'object';
-    properties: Record<string, JsonSchemaProperty>;
-    required: string[];
-    description?: string;
-}
-/**
- * OpenAPI 3.1 components container
- */
-interface OpenApiComponents {
-    schemas: Record<string, OpenApiSchema>;
-}
-/**
- * Column-level schema flags
- */
-interface ColumnSchemaOptions {
-    /** Include description from column comments */
-    includeDescriptions?: boolean;
-    /** Include enum values for enum columns */
-    includeEnums?: boolean;
-    /** Include column examples if available */
-    includeExamples?: boolean;
-    /** Include column defaults */
-    includeDefaults?: boolean;
-    /** Include nullable flag when applicable */
-    includeNullable?: boolean;
-}
-/**
- * Output schema generation options (query result)
- */
-interface OutputSchemaOptions extends ColumnSchemaOptions {
-    /** Use selected columns only (from select/include) vs full entity */
-    mode?: 'selected' | 'full';
-    /** Maximum depth for relation recursion */
-    maxDepth?: number;
-    /** Inline schemas vs $ref components */
-    refMode?: 'inline' | 'components';
-    /** Selected schemas inline vs components when refMode is components */
-    selectedRefMode?: 'inline' | 'components';
-    /** Customize component names */
-    componentName?: (table: TableDef) => string;
-    /** Emit output schema as a component $ref when refMode is components */
-    outputAsRef?: boolean;
-}
-type InputRelationMode = 'ids' | 'objects' | 'mixed';
-type InputSchemaMode = 'create' | 'update';
-interface RelationSelection {
-    pick?: string[];
-    omit?: string[];
-}
-/**
- * Input schema generation options (write payloads)
- */
-interface InputSchemaOptions extends ColumnSchemaOptions {
-    /** Create vs update payload shape */
-    mode?: InputSchemaMode;
-    /** Include relation payloads */
-    includeRelations?: boolean;
-    /** How relations are represented (ids, nested objects, or both) */
-    relationMode?: InputRelationMode;
-    /** Maximum depth for relation recursion */
-    maxDepth?: number;
-    /** Omit read-only/generated columns from input */
-    omitReadOnly?: boolean;
-    /** Exclude primary key columns from input */
-    excludePrimaryKey?: boolean;
-    /** Require primary key columns on update payloads */
-    requirePrimaryKey?: boolean;
-    /** Remove relation foreign keys pointing to the parent from nested inputs */
-    excludeRelationForeignKeys?: boolean;
-    /** Per-relation field selection for nested inputs */
-    relationSelections?: Record<string, RelationSelection>;
-}
-/**
- * Schema generation options
- */
-interface SchemaOptions extends OutputSchemaOptions {
-    /** Input schema options, or false to skip input generation */
-    input?: InputSchemaOptions | false;
-}
-/**
- * Input + output schema bundle
- */
-interface OpenApiSchemaBundle {
-    output: OpenApiSchema | JsonSchemaProperty;
-    input?: OpenApiSchema;
-    parameters?: OpenApiParameter[];
-    components?: OpenApiComponents;
-}
-/**
- * Schema extraction context for handling circular references
- */
-interface SchemaExtractionContext {
-    /** Set of already visited tables to detect cycles */
-    visitedTables: Set<string>;
-    /** Map of table names to their generated schemas */
-    schemaCache: Map<string, OpenApiSchema>;
-    /** Current extraction depth */
-    depth: number;
-    /** Maximum depth to recurse */
-    maxDepth: number;
-    /** Component registry when using refMode=components */
-    components?: OpenApiComponents;
-}
-
-/**
- * Maps SQL column types to OpenAPI JSON Schema types
- */
-declare const mapColumnType: (column: ColumnDef, options?: ColumnSchemaOptions) => JsonSchemaProperty;
-/**
- * Maps relation type to array or single object
- */
-declare const mapRelationType: (relationType: string) => {
-    type: "object" | "array";
-    isNullable: boolean;
-};
-/**
- * Gets the OpenAPI format for temporal columns
- */
-declare const getTemporalFormat: (sqlType: string) => JsonSchemaFormat | undefined;
-
-/**
- * Extracts OpenAPI 3.1 schemas for output and optional input payloads.
- */
-declare const extractSchema: (table: TableDef, plan: HydrationPlan | undefined, projectionNodes: ProjectionNode[] | undefined, options?: SchemaOptions) => OpenApiSchemaBundle;
-/**
- * Converts a schema to a JSON string with optional pretty printing
- */
-declare const schemaToJson: (schema: OpenApiSchema, pretty?: boolean) => string;
-
-declare const buildFilterParameters: (table: TableDef, where: ExpressionNode | undefined, from: TableSourceNode | undefined, options?: ColumnSchemaOptions) => OpenApiParameter[];
-
 type SelectDialectInput = Dialect | DialectKey;
 
 type ColumnSelectionValue = ColumnDef | FunctionNode | CaseExpressionNode | WindowFunctionNode | TypedExpression<unknown>;
@@ -4005,9 +3789,6 @@ type SelectionValueType<TValue> = TValue extends TypedExpression<infer TRuntime>
 type SelectionResult<TSelection extends Record<string, ColumnSelectionValue>> = {
     [K in keyof TSelection]: SelectionValueType<TSelection[K]>;
 };
-type ParamOperandCompileOptions = {
-    allowParamOperands?: boolean;
-};
 type SelectionFromKeys<TTable extends TableDef, K extends keyof TTable['columns'] & string> = Pick<InferRow<TTable>, K>;
 type DeepSelectEntry<TTable extends TableDef> = {
     type: 'root';
@@ -4357,11 +4138,6 @@ declare class SelectQueryBuilder<T = EntityInstance<TableDef>, TTable extends Ta
      * Ensures that if no columns are selected, all columns from the table are selected by default.
      */
     private ensureDefaultSelection;
-    /**
-     * Validates that the query does not contain Param operands.
-     * Param proxies are only for schema generation, not execution.
-     */
-    private validateNoParamOperands;
     /**
      * Executes the query and returns hydrated results.
      * If the builder was created with an entity constructor (e.g. via selectFromEntity),
@@ -4601,7 +4377,7 @@ declare class SelectQueryBuilder<T = EntityInstance<TableDef>, TTable extends Ta
      *   .compile('postgres');
      * console.log(compiled.sql); // SELECT "id", "name" FROM "users" WHERE "active" = true
      */
-    compile(dialect: SelectDialectInput, options?: ParamOperandCompileOptions): CompiledQuery;
+    compile(dialect: SelectDialectInput): CompiledQuery;
     /**
      * Converts the query to SQL string for a specific dialect
      * @param dialect - Database dialect to generate SQL for
@@ -4612,24 +4388,15 @@ declare class SelectQueryBuilder<T = EntityInstance<TableDef>, TTable extends Ta
      *   .toSql('postgres');
      * console.log(sql); // SELECT "id", "name" FROM "users" WHERE "active" = true
      */
-    toSql(dialect: SelectDialectInput, options?: ParamOperandCompileOptions): string;
+    toSql(dialect: SelectDialectInput): string;
     /**
-     * Gets hydration plan for query
+     * Gets the hydration plan for the query
      * @returns Hydration plan or undefined if none exists
      * @example
      * const plan = qb.include('posts').getHydrationPlan();
      * console.log(plan?.relations); // Information about included relations
      */
     getHydrationPlan(): HydrationPlan | undefined;
-    /**
-     * Gets OpenAPI 3.1 JSON Schemas for query output and optional input payloads
-     * @param options - Schema generation options
-     * @returns OpenAPI 3.1 JSON Schemas for query output and input payloads
-     * @example
-     * const { output } = qb.select('id', 'title', 'author').getSchema();
-     * console.log(JSON.stringify(output, null, 2));
-     */
-    getSchema(options?: SchemaOptions): OpenApiSchemaBundle;
     /**
      * Gets the Abstract Syntax Tree (AST) representation of the query
      * @returns Query AST with hydration applied
@@ -6393,7 +6160,6 @@ declare class TypeScriptGenerator implements ExpressionVisitor<string>, OperandV
     visitArithmeticExpression(arithExpr: ArithmeticExpressionNode): string;
     visitColumn(node: ColumnNode): string;
     visitLiteral(node: LiteralNode): string;
-    visitParam(node: ParamNode): string;
     visitFunction(node: FunctionNode): string;
     visitJsonPath(node: JsonPathNode): string;
     visitScalarSubquery(node: ScalarSubqueryNode): string;
@@ -6451,7 +6217,6 @@ declare class TypeScriptGenerator implements ExpressionVisitor<string>, OperandV
      * @returns TypeScript code representation
      */
     private printLiteralOperand;
-    private printParamOperand;
     /**
      * Prints a function operand to TypeScript code
      * @param fn - Function node
@@ -7256,4 +7021,772 @@ type PooledExecutorFactoryOptions<TConn> = {
  */
 declare function createPooledExecutorFactory<TConn>(opts: PooledExecutorFactoryOptions<TConn>): DbExecutorFactory;
 
-export { type AliasRefNode, type AnyDomainEvent, type ArithmeticExpressionNode, type TableRef as AstTableRef, AsyncLocalStorage, BelongsTo, BelongsToMany, type BelongsToManyOptions, type BelongsToManyRelation, type BelongsToOptions, type BelongsToReference, type BelongsToReferenceApi, type BelongsToRelation, type BetweenExpressionNode, type BinaryExpressionNode, type BitwiseExpressionNode, type CascadeMode, type CaseExpressionNode, type CastExpressionNode, type CheckConstraint, type CollateExpressionNode, Column, type ColumnDef, type ColumnDiff, type ColumnInput, type ColumnNode, type ColumnOptions, type ColumnRef, type ColumnSchemaOptions, type ColumnToTs, type ColumnType, ConstructorMaterializationStrategy, type CreateTediousClientOptions, type DatabaseCheck, type DatabaseColumn, type DatabaseIndex, type DatabaseSchema, type DatabaseTable, type DbExecutor, type DbExecutorFactory, type DecoratedEntityInstance, DefaultBelongsToReference, DefaultEntityMaterializer, DefaultHasManyCollection, DefaultManyToManyCollection, type DefaultValue, DeleteQueryBuilder, type DialectName, type DomainEvent, DomainEventBus, type DomainEventHandler, Entity, type EntityContext, type EntityInstance, type EntityMaterializationStrategy, type EntityMaterializer, type EntityOptions, type PrimaryKey$1 as EntityPrimaryKey, EntityStatus, type ExecutionContext, type ExistsExpressionNode, type ExpressionNode, type ExpressionVisitor, type ForeignKeyReference, type FunctionNode, type GroupConcatOptions, type HasDomainEvents, HasMany, type HasManyCollection, type HasManyOptions, type HasManyRelation, HasOne, type HasOneOptions, type HasOneReference, type HasOneReferenceApi, type HasOneRelation, type HydrationContext, type HydrationMetadata, type HydrationPivotPlan, type HydrationPlan, type HydrationRelationPlan, type InExpressionNode, type InExpressionRight, type IndexColumn, type IndexDef, type InferRow, type InitialHandlers, type InputRelationMode, type InputSchemaMode, type InputSchemaOptions, InsertQueryBuilder, InterceptorPipeline, type IntrospectOptions, type JsonPathNode, type JsonSchemaFormat, type JsonSchemaProperty, type JsonSchemaType, type Jsonify, type JsonifyScalar, type LiteralNode, type LiteralValue, type LogicalExpressionNode, type ManyToManyCollection, type MssqlClientLike, MySqlDialect, type MysqlClientLike, type NullExpressionNode, type OpenApiComponents, type OpenApiParameter, type OpenApiSchema, type OpenApiSchemaBundle, type OperandNode, type OperandVisitor, Orm, type OrmDomainEvent, type OrmInterceptor, type OrmOptions, OrmSession, type OrmSessionOptions, type OutputSchemaOptions, type PaginatedResult, type ParamNode, type ParamProxy, type ParamProxyRoot, Pool, type PoolAdapter, type PoolLease, type PoolOptions, type PooledConnectionAdapter, type PostgresClientLike, PostgresDialect, PrimaryKey, type Primitive, PrototypeMaterializationStrategy, type QueryContext, type QueryInterceptor, type QueryLogEntry, type QueryLogger, type QueryResult, type RawDefaultValue, type ReferentialAction, type RelationChange, type RelationChangeEntry, type RelationDef, type RelationKey$1 as RelationKey, RelationKinds, type RelationMap, type RelationSelection, type RelationTargetTable, type RelationType, type RenderColumnOptions, STANDARD_COLUMN_TYPES, type SaveGraphInputPayload, type SaveGraphInputScalar, type SaveGraphJsonScalar, type SaveGraphSessionOptions, type ScalarSubqueryNode, type SchemaChange, type SchemaChangeKind, type SchemaDiffOptions, type SchemaExtractionContext, type SchemaGenerateResult, type SchemaIntrospector, type SchemaOptions, type SchemaPlan, SelectQueryBuilder, type SelectQueryInput, type SelectableKeys, type SimpleQueryRunner, SqlServerDialect, type SqliteClientLike, SqliteDialect, type StandardColumnType, type SynchronizeOptions, type TableDef, type TableHooks, type TableOptions, type TableRef$1 as TableRef, type TediousColumn, type TediousConnectionLike, type TediousModule, type TediousRequest, type TediousRequestCtor, type TediousTypes, type TrackedEntity, TypeScriptGenerator, type TypedExpression, type TypedLike, UpdateQueryBuilder, type ValueOperandInput, type WindowFunctionNode, abs, acos, add, addDomainEvent, age, aliasRef, and, arrayAppend, asType, ascii, asin, atan, atan2, avg, belongsTo, belongsToMany, between, bitAnd, bitLength, bitOr, bitXor, bootstrapEntities, buildFilterParameters, caseWhen, cast, cbrt, ceil, ceiling, char, charLength, chr, clearExpressionDispatchers, clearOperandDispatchers, coalesce, col, collate, columnOperand, concat, concatWs, correlateBy, cos, cot, count, countAll, createEntityFromRow, createEntityProxy, createExecutorFromQueryRunner, createMssqlExecutor, createMysqlExecutor, createParamProxy, createPooledExecutorFactory, createPostgresExecutor, createQueryLoggingExecutor, createSqliteExecutor, createTediousExecutor, createTediousMssqlClient, currentDate, currentTime, dateAdd, dateDiff, dateFormat, dateSub, dateTrunc, day, dayOfWeek, defineTable, degrees, deleteFrom, denseRank, diffSchema, div, endOfMonth, entityRef, entityRefs, eq, esel, executeHydrated, executeHydratedPlain, executeHydratedPlainWithContexts, executeHydratedWithContexts, executeSchemaSql, executeSchemaSqlFor, exists, exp, extract, extractSchema, firstValue, floor, fromUnixTime, generateCreateTableSql, generateSchemaSql, generateSchemaSqlFor, getColumn, getDecoratorMetadata, getSchemaIntrospector, getTableDefFromEntity, getTemporalFormat, greatest, groupConcat, gt, gte, hasExpressionDispatcher, hasMany, hasOne, hasOperandDispatcher, hour, hydrateRows, ifNull, inList, inSubquery, initcap, insertInto, instr, introspectSchema, isCaseExpressionNode, isCastExpressionNode, isCollateExpressionNode, isExpressionSelectionNode, isFunctionNode, isNotNull, isNull, isOperandNode, isValueOperandInput, isWindowFunctionNode, jsonArrayAgg, jsonContains, jsonLength, jsonPath, jsonSet, jsonify, lag, lastValue, lead, least, left, length, like, ln, loadBelongsToManyRelation, loadBelongsToRelation, loadHasManyRelation, loadHasOneRelation, localTime, localTimestamp, locate, log, log10, log2, logBase, lower, lpad, lt, lte, ltrim, mapColumnType, mapRelationType, materializeAs, max, md5, min, minute, mod, month, mul, neq, normalizeColumnType, notBetween, notExists, notInList, notInSubquery, notLike, now, ntile, nullif, octetLength, or, outerRef, pi, position, pow, power, quarter, radians, rand, random, rank, registerExpressionDispatcher, registerOperandDispatcher, registerSchemaIntrospector, relationLoaderCache, renderColumnDefinition, renderTypeWithArgs, repeat, replace, reverse, right, round, rowNumber, rowsToQueryResult, rpad, rtrim, schemaToJson, second, sel, selectFrom, selectFromEntity, setRelations, sha1, sha2, shiftLeft, shiftRight, sign, sin, space, sqrt, stddev, sub, substr, sum, synchronizeSchema, tableRef, tan, toColumnRef, toTableRef, trim, trunc, truncate, unixTimestamp, update, upper, utcNow, valueToOperand, variance, visitExpression, visitOperand, weekOfYear, windowFunction, year };
+/**
+ * DTO (Data Transfer Object) type utilities for metal-orm.
+ * Derives API types from TableDef/Entity metadata.
+ */
+
+/**
+ * Checks if a type is a TableDef.
+ */
+type IsTableDef$1<T> = T extends {
+    name: string;
+    columns: any;
+} ? true : false;
+/**
+ * Extracts the row type from either a TableDef or EntityConstructor.
+ */
+type ExtractRow<T> = IsTableDef$1<T> extends true ? InferRow<T extends TableDef<infer C> ? TableDef<C> : never> : T extends EntityConstructor<infer E> ? E : never;
+/**
+ * Utility to flatten intersection types for better IDE display.
+ */
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/**
+ * Response DTO - excludes specified columns from the entity.
+ * Use this to hide sensitive fields like passwordHash, apiKey, etc.
+ *
+ * @example
+ * ```ts
+ * // With TableDef
+ * type UserResponse = Dto<typeof usersTable, 'passwordHash'>;
+ *
+ * // With Entity class
+ * type UserResponse = Dto<User, 'passwordHash'>;
+ *
+ * // Exclude multiple fields
+ * type UserPublic = Dto<User, 'passwordHash' | 'email'>;
+ *
+ * // Include all fields (no exclusions)
+ * type UserFull = Dto<User>;
+ * ```
+ */
+type Dto<T extends TableDef | EntityConstructor, TExclude extends keyof ExtractRow<T> = never> = Simplify<Omit<ExtractRow<T>, TExclude>>;
+/**
+ * Compose a DTO with relations.
+ *
+ * @example
+ * ```ts
+ * type UserWithPosts = WithRelations<UserResponse, {
+ *   posts: PostResponse[]
+ * }>;
+ *
+ * type PostWithAuthor = WithRelations<PostResponse, {
+ *   author: Dto<User, 'passwordHash' | 'email'>
+ * }>;
+ * ```
+ */
+type WithRelations<TBase, TRelations> = Simplify<TBase & TRelations>;
+type ColumnMap<T extends TableDef> = T['columns'];
+/**
+ * Checks if a column has a default value.
+ */
+type HasDefault<TCol extends ColumnDef> = TCol['default'] extends undefined ? false : true;
+/**
+ * Checks if a column is auto-generated (autoIncrement or generated always/byDefault).
+ */
+type IsAutoGenerated<TCol extends ColumnDef> = TCol['autoIncrement'] extends true ? true : TCol['generated'] extends 'always' | 'byDefault' ? true : false;
+/**
+ * Checks if a column is insertable (not auto-generated).
+ */
+type IsInsertable<TCol extends ColumnDef> = IsAutoGenerated<TCol> extends true ? false : true;
+/**
+ * Checks if a column is required for insert (notNull, no default, not auto-generated).
+ */
+type IsRequiredInsert<TCol extends ColumnDef> = TCol['notNull'] extends true ? IsAutoGenerated<TCol> extends true ? false : HasDefault<TCol> extends true ? false : true : false;
+/**
+ * Keys that are required for insert (notNull, no default, not auto-generated).
+ */
+type RequiredInsertKeys<T extends TableDef> = {
+    [K in keyof ColumnMap<T>]: ColumnMap<T>[K] extends ColumnDef ? IsInsertable<ColumnMap<T>[K]> extends true ? IsRequiredInsert<ColumnMap<T>[K]> extends true ? K : never : never : never;
+}[keyof ColumnMap<T>];
+/**
+ * Keys that are optional for insert (nullable, has default, or optional).
+ */
+type OptionalInsertKeys<T extends TableDef> = {
+    [K in keyof ColumnMap<T>]: ColumnMap<T>[K] extends ColumnDef ? IsInsertable<ColumnMap<T>[K]> extends true ? IsRequiredInsert<ColumnMap<T>[K]> extends false ? K : never : never : never;
+}[keyof ColumnMap<T>];
+/**
+ * Create DTO - includes only insertable columns with proper optionality.
+ * Auto-generated columns (autoIncrement, generated) are excluded.
+ * Columns with defaults or nullable are optional.
+ *
+ * Works with both TableDef and EntityConstructor:
+ * - For TableDef: Uses column metadata to determine required/optional fields
+ * - For EntityConstructor: All fields are optional (simpler type inference)
+ *
+ * @example
+ * ```ts
+ * // With TableDef - auto-excludes id (autoIncrement), createdAt (has default)
+ * type CreateUserDto = CreateDto<typeof usersTable>;
+ * // → { name: string; email: string; bio?: string }
+ *
+ * // With Entity class - simpler inference, all fields optional
+ * type CreateUserDto = CreateDto<User>;
+ *
+ * // Exclude additional fields (e.g., authorId comes from context)
+ * type CreatePostDto = CreateDto<typeof Post, 'authorId'>;
+ * ```
+ */
+type CreateDto<T extends TableDef | EntityConstructor, TExclude extends keyof ExtractRow<T> = never> = T extends TableDef<any> ? Simplify<{
+    [K in Exclude<RequiredInsertKeys<T>, TExclude>]: ColumnToTs<ColumnMap<T>[K]>;
+} & {
+    [K in Exclude<OptionalInsertKeys<T>, TExclude>]?: ColumnToTs<ColumnMap<T>[K]>;
+}> : Simplify<{
+    [K in Exclude<keyof ExtractRow<T>, TExclude>]?: ExtractRow<T>[K];
+}>;
+/**
+ * Update DTO - all columns are optional (partial update).
+ * Excludes specified columns (e.g., id, createdAt).
+ *
+ * @example
+ * ```ts
+ * // With TableDef
+ * type UpdateUserDto = UpdateDto<typeof User>;
+ * // → { name?: string; email?: string; bio?: string; ... }
+ *
+ * // With Entity class
+ * type UpdateUserDto = UpdateDto<User>;
+ *
+ * // Exclude fields that shouldn't be updated
+ * type UpdateUserDto = UpdateDto<typeof User, 'id' | 'createdAt'>;
+ * ```
+ */
+type UpdateDto<T extends TableDef | EntityConstructor, TExclude extends keyof ExtractRow<T> = never> = T extends TableDef<any> ? Simplify<{
+    [K in Exclude<keyof ColumnMap<T>, TExclude>]?: ColumnToTs<ColumnMap<T>[K]>;
+}> : Simplify<{
+    [K in Exclude<keyof ExtractRow<T>, TExclude>]?: ExtractRow<T>[K];
+}>;
+/**
+ * Enhanced paginated response with computed navigation metadata.
+ * Extends the basic PaginatedResult with additional convenience fields.
+ *
+ * @example
+ * ```ts
+ * type UsersPagedResponse = PagedResponse<UserResponse>;
+ *
+ * // Response:
+ * // {
+ * //   items: UserResponse[];
+ * //   totalItems: number;
+ * //   page: number;
+ * //   pageSize: number;
+ * //   totalPages: number;
+ * //   hasNextPage: boolean;
+ * //   hasPrevPage: boolean;
+ * // }
+ * ```
+ */
+type PagedResponse<T> = {
+    items: T[];
+    totalItems: number;
+    page: number;
+    pageSize: number;
+    totalPages: number;
+    hasNextPage: boolean;
+    hasPrevPage: boolean;
+};
+
+/**
+ * Filter types for building type-safe query filters from JSON input.
+ * Designed for REST API query parameters.
+ */
+
+/**
+ * Checks if a type is a TableDef.
+ */
+type IsTableDef<T> = T extends {
+    name: string;
+    columns: any;
+} ? true : false;
+/**
+ * Maps TypeScript types to SQL column types for EntityConstructor columns.
+ */
+type TsTypeToColumnType<T> = T extends string ? 'VARCHAR' : T extends number ? 'INT' : T extends boolean ? 'BOOLEAN' : T extends Date ? 'TIMESTAMP' : 'VARCHAR';
+/**
+ * Extracts the column map from either a TableDef or EntityConstructor.
+ * For EntityConstructor, infers column type from TypeScript property type.
+ */
+type ExtractColumns<T> = IsTableDef<T> extends true ? T extends TableDef<infer C> ? C : never : T extends EntityConstructor<infer E> ? {
+    [K in keyof E]: ColumnDef<TsTypeToColumnType<E[K]>, E[K]>;
+} : never;
+/**
+ * Filter operators for string columns.
+ */
+interface StringFilter {
+    equals?: string;
+    not?: string;
+    in?: string[];
+    notIn?: string[];
+    contains?: string;
+    startsWith?: string;
+    endsWith?: string;
+    /** Case-insensitive matching (for contains, startsWith, endsWith) */
+    mode?: 'default' | 'insensitive';
+}
+/**
+ * Filter operators for numeric columns (number, bigint).
+ */
+interface NumberFilter {
+    equals?: number;
+    not?: number;
+    in?: number[];
+    notIn?: number[];
+    lt?: number;
+    lte?: number;
+    gt?: number;
+    gte?: number;
+}
+/**
+ * Filter operators for boolean columns.
+ */
+interface BooleanFilter {
+    equals?: boolean;
+    not?: boolean;
+}
+/**
+ * Filter operators for date/datetime columns.
+ * Accepts ISO date strings.
+ */
+interface DateFilter {
+    equals?: string;
+    not?: string;
+    in?: string[];
+    notIn?: string[];
+    lt?: string;
+    lte?: string;
+    gt?: string;
+    gte?: string;
+}
+type NormalizedType<T extends ColumnDef> = Lowercase<T['type'] & string>;
+/**
+ * Maps a column definition to its appropriate filter type.
+ */
+type FieldFilter<TCol extends ColumnDef> = NormalizedType<TCol> extends 'int' | 'integer' | 'bigint' | 'decimal' | 'float' | 'double' ? NumberFilter : NormalizedType<TCol> extends 'boolean' ? BooleanFilter : NormalizedType<TCol> extends 'date' | 'datetime' | 'timestamp' | 'timestamptz' ? DateFilter : StringFilter;
+/**
+ * Full where input with all columns filterable.
+ * All conditions are implicitly AND-ed.
+ * Works with both TableDef and EntityConstructor.
+ *
+ * @example
+ * ```ts
+ * // With TableDef
+ * type UserFilter = WhereInput<typeof usersTable>;
+ *
+ * // With Entity class
+ * type UserFilter = WhereInput<User>;
+ * ```
+ */
+type WhereInput<T extends TableDef | EntityConstructor> = {
+    [K in keyof ExtractColumns<T>]?: ExtractColumns<T>[K] extends ColumnDef<any, any> ? FieldFilter<ExtractColumns<T>[K]> : FieldFilter<ColumnDef<any, any>>;
+};
+/**
+ * Restricted where input - only specified columns are filterable.
+ * Use this to limit which fields can be filtered via API.
+ *
+ * Works with both TableDef and EntityConstructor.
+ *
+ * @example
+ * ```ts
+ * // With TableDef - only allow filtering by name and email
+ * type UserFilter = SimpleWhereInput<typeof usersTable, 'name' | 'email'>;
+ *
+ * // With Entity class
+ * type UserFilter = SimpleWhereInput<User, 'name' | 'email'>;
+ *
+ * // Request: { "name": { "contains": "john" }, "email": { "endsWith": "@gmail.com" } }
+ * ```
+ */
+type SimpleWhereInput<T extends TableDef | EntityConstructor, K extends keyof ExtractColumns<T>> = {
+    [P in K]?: ExtractColumns<T>[P] extends ColumnDef<any, any> ? FieldFilter<ExtractColumns<T>[P]> : FieldFilter<ColumnDef<any, any>>;
+};
+/**
+ * All possible filter operators.
+ */
+type FilterOperator = 'equals' | 'not' | 'in' | 'notIn' | 'lt' | 'lte' | 'gt' | 'gte' | 'contains' | 'startsWith' | 'endsWith';
+/**
+ * Generic filter value that covers all operator types.
+ */
+type FilterValue = StringFilter | NumberFilter | BooleanFilter | DateFilter;
+
+/**
+ * Runtime filter application - converts JSON filter objects to query builder conditions.
+ */
+
+/**
+ * Applies a filter object to a SelectQueryBuilder.
+ * All conditions are AND-ed together.
+ *
+ * @param qb - The query builder to apply filters to
+ * @param tableOrEntity - The table definition or entity constructor (used to resolve column references)
+ * @param where - The filter object from: API request
+ * @returns The query builder with filters applied
+ *
+ * @example
+ * ```ts
+ * // In a controller - using Entity class
+ * @Get()
+ * async list(@Query() where?: UserFilter): Promise<UserResponse[]> {
+ *   let query = selectFromEntity(User);
+ *   query = applyFilter(query, User, where);
+ *   return query.execute(db);
+ * }
+ *
+ * // Using TableDef directly
+ * @Get()
+ * async list(@Query() where?: UserFilter): Promise<UserResponse[]> {
+ *   let query = selectFrom(usersTable);
+ *   query = applyFilter(query, usersTable, where);
+ *   return query.execute(db);
+ * }
+ *
+ * // Request: { "name": { "contains": "john" }, "email": { "endsWith": "@gmail.com" } }
+ * // SQL: WHERE name LIKE '%john%' AND email LIKE '%@gmail.com'
+ * ```
+ */
+declare function applyFilter<T, TTable extends TableDef>(qb: SelectQueryBuilder<T, TTable>, tableOrEntity: TTable | EntityConstructor, where?: WhereInput<TTable | EntityConstructor> | null): SelectQueryBuilder<T, TTable>;
+/**
+ * Builds an expression tree from a filter object without applying it.
+ * Useful for combining with other conditions.
+ *
+ * @param tableOrEntity - The table definition or entity constructor
+ * @param where - The filter object
+ * @returns An expression node or null if no filters
+ *
+ * @example
+ * ```ts
+ * // Using Entity class
+ * const filterExpr = buildFilterExpression(User, { name: { contains: "john" } });
+ *
+ * // Using TableDef directly
+ * const filterExpr = buildFilterExpression(usersTable, { name: { contains: "john" } });
+ *
+ * if (filterExpr) {
+ *   qb = qb.where(and(filterExpr, eq(users.columns.active, true)));
+ * }
+ * ```
+ */
+declare function buildFilterExpression(tableOrEntity: TableDef | EntityConstructor, where?: WhereInput<TableDef | EntityConstructor> | null): ExpressionNode | null;
+
+/**
+ * DTO transformation utilities for working with DTO instances.
+ *
+ * These helpers make it easier to convert between DTO types, apply defaults,
+ * and handle auto-generated fields without manual object construction.
+ */
+/**
+ * Transforms a CreateDto or UpdateDto into a ResponseDto by merging with auto-generated fields.
+ *
+ * @example
+ * ```ts
+ * const newUser: UserResponse = toResponse(body, {
+ *   id: newId,
+ *   createdAt: new Date().toISOString()
+ * });
+ *
+ * // Or use the curried form for reuse
+ * const createUserResponse = toResponseBuilder<UserCreateDto, UserResponse>({
+ *   id: () => nextId++,
+ *   createdAt: () => new Date().toISOString()
+ * });
+ * const user = createUserResponse(body);
+ * ```
+ */
+declare function toResponse<TInput, TOutput>(input: TInput, autoFields: Partial<TOutput>): TOutput;
+/**
+ * Creates a toResponse function with pre-configured auto-fields.
+ * Useful for reusing same transformation logic across multiple endpoints.
+ *
+ * @example
+ * ```ts
+ * const userResponseBuilder = toResponseBuilder<CreateUserDto, UserResponse>({
+ *   id: () => generateId(),
+ *   createdAt: () => new Date().toISOString(),
+ *   active: true
+ * });
+ *
+ * app.post('/users', (req, res) => {
+ *   const user = userResponseBuilder(req.body);
+ *   res.status(201).json(user);
+ * });
+ * ```
+ */
+declare function toResponseBuilder<TInput, TOutput>(autoFields: Partial<TOutput> | (() => Partial<TOutput>)): (input: TInput) => TOutput;
+/**
+ * Merges default values into a DTO. Returns a complete object with all defaults applied.
+ *
+ * @example
+ * ```ts
+ * const user = withDefaults(body, {
+ *   active: true,
+ *   createdAt: new Date().toISOString()
+ * });
+ * ```
+ */
+declare function withDefaults<T>(dto: Partial<T>, defaults: T): T;
+/**
+ * Creates a withDefaults function with pre-configured defaults.
+ *
+ * @example
+ * ```ts
+ * const userWithDefaults = withDefaultsBuilder<CreateUserDto>({
+ *   active: true
+ * });
+ *
+ * app.post('/users', (req, res) => {
+ *   const userInput = userWithDefaults(req.body);
+ *   // ...
+ * });
+ * ```
+ */
+declare function withDefaultsBuilder<T>(defaults: T | (() => T)): (dto: Partial<T>) => T;
+/**
+ * Excludes specified fields from an object. Useful for removing sensitive fields
+ * from database results before sending to the client.
+ *
+ * @example
+ * ```ts
+ * const userFromDb = await db.select().from(users).where(...).first();
+ * const userResponse = exclude(userFromDb, 'passwordHash', 'apiKey');
+ * ```
+ */
+declare function exclude<T extends object, K extends keyof T>(obj: T, ...keys: K[]): Omit<T, K>;
+/**
+ * Picks only specified fields from an object. Useful for creating DTOs from
+ * larger database entities.
+ *
+ * @example
+ * ```ts
+ * const userFromDb = await db.select().from(users).where(...).first();
+ * const userResponse = pick(userFromDb, 'id', 'name', 'email');
+ * ```
+ */
+declare function pick<T extends object, K extends keyof T>(obj: T, ...keys: K[]): Pick<T, K>;
+/**
+ * Maps field names from one DTO to another. Useful when your DTO has different
+ * field names than your entity (e.g., camelCase vs snake_case).
+ *
+ * @example
+ * ```ts
+ * type ApiUser = { firstName: string; lastName: string };
+ * type DbUser = { first_name: string; last_name: string };
+ *
+ * const dbUser = mapFields(apiUser, {
+ *   firstName: 'first_name',
+ *   lastName: 'last_name'
+ * });
+ * ```
+ */
+type MappedFields<T, M extends Partial<Record<keyof T, string>>> = {
+    [K in keyof M as M[K] extends string ? M[K] : never]: K extends keyof T ? T[K] : never;
+};
+declare function mapFields<T extends object, M extends Partial<Record<keyof T, string>>>(obj: T, fieldMap: M): Omit<T, keyof M> & MappedFields<T, M>;
+
+/**
+ * Pagination utility functions for DTO responses.
+ * Converts basic PaginatedResult to enhanced PagedResponse with computed metadata.
+ */
+
+/**
+ * Converts PaginatedResult to PagedResponse with computed metadata.
+ *
+ * @param result - The basic paginated result from executePaged()
+ * @returns Enhanced paginated response with totalPages, hasNextPage, hasPrevPage
+ *
+ * @example
+ * ```ts
+ * // In your controller
+ * const basic = await qb.executePaged(session, { page: 2, pageSize: 20 });
+ * const response = toPagedResponse(basic);
+ * return res.json(response);
+ * // → { items: [...], totalItems: 150, page: 2, pageSize: 20,
+ * //     totalPages: 8, hasNextPage: true, hasPrevPage: true }
+ * ```
+ */
+declare function toPagedResponse<T>(result: PaginatedResult<T>): PagedResponse<T>;
+/**
+ * Creates a reusable toPagedResponse function with fixed pageSize.
+ * Useful when your API uses a consistent page size across all endpoints.
+ *
+ * @param fixedPageSize - The fixed page size to use
+ * @returns A function that converts PaginatedResult to PagedResponse
+ *
+ * @example
+ * ```ts
+ * const toUserPagedResponse = toPagedResponseBuilder<UserResponse>(20);
+ *
+ * app.get('/users', async (req, res) => {
+ *   const basic = await qb.executePaged(session, { page: req.query.page || 1, pageSize: 20 });
+ *   const response = toUserPagedResponse(basic);
+ *   res.json(response);
+ * });
+ * ```
+ */
+declare function toPagedResponseBuilder<T>(fixedPageSize: number): (result: Omit<PaginatedResult<T>, 'pageSize'> & {
+    pageSize?: number;
+}) => PagedResponse<T>;
+/**
+ * Calculates total pages from total items and page size.
+ *
+ * @param totalItems - Total number of items
+ * @param pageSize - Number of items per page
+ * @returns Total number of pages (minimum 1)
+ *
+ * @example
+ * ```ts
+ * const totalPages = calculateTotalPages(150, 20); // → 8
+ * const totalPages = calculateTotalPages(150, 50); // → 3
+ * ```
+ */
+declare function calculateTotalPages(totalItems: number, pageSize: number): number;
+/**
+ * Checks if there is a next page.
+ *
+ * @param currentPage - Current page number (1-based)
+ * @param totalPages - Total number of pages
+ * @returns true if there is a next page
+ *
+ * @example
+ * ```ts
+ * const hasNext = hasNextPage(2, 8); // → true
+ * const hasNext = hasNextPage(8, 8); // → false
+ * ```
+ */
+declare function hasNextPage(currentPage: number, totalPages: number): boolean;
+/**
+ * Checks if there is a previous page.
+ *
+ * @param currentPage - Current page number (1-based)
+ * @returns true if there is a previous page
+ *
+ * @example
+ * ```ts
+ * const hasPrev = hasPrevPage(2); // → true
+ * const hasPrev = hasPrevPage(1); // → false
+ * ```
+ */
+declare function hasPrevPage(currentPage: number): boolean;
+/**
+ * Computes all pagination metadata from basic pagination info.
+ *
+ * @param totalItems - Total number of items
+ * @param page - Current page number (1-based)
+ * @param pageSize - Number of items per page
+ * @returns Object with totalPages, hasNextPage, hasPrevPage
+ *
+ * @example
+ * ```ts
+ * const meta = computePaginationMetadata(150, 2, 20);
+ * // → { totalPages: 8, hasNextPage: true, hasPrevPage: true }
+ * ```
+ */
+declare function computePaginationMetadata(totalItems: number, page: number, pageSize: number): Pick<PagedResponse<unknown>, 'totalPages' | 'hasNextPage' | 'hasPrevPage'>;
+
+type OpenApiType = 'string' | 'number' | 'integer' | 'boolean' | 'array' | 'object' | 'null';
+interface OpenApiSchema {
+    type?: OpenApiType | OpenApiType[];
+    properties?: Record<string, OpenApiSchema>;
+    items?: OpenApiSchema;
+    required?: string[];
+    enum?: unknown[];
+    format?: string;
+    description?: string;
+    example?: unknown;
+    nullable?: boolean;
+    minimum?: number;
+    maximum?: number;
+    default?: unknown;
+    $ref?: string;
+    allOf?: OpenApiSchema[];
+    oneOf?: OpenApiSchema[];
+}
+interface OpenApiParameter {
+    name: string;
+    in: 'query' | 'path' | 'header' | 'cookie';
+    required?: boolean;
+    schema?: OpenApiSchema;
+    description?: string;
+}
+interface OpenApiOperation {
+    summary?: string;
+    description?: string;
+    parameters?: OpenApiParameter[];
+    requestBody?: {
+        description?: string;
+        required?: boolean;
+        content: {
+            'application/json': {
+                schema: OpenApiSchema;
+            };
+        };
+    };
+    responses?: Record<string, {
+        description: string;
+        content?: {
+            'application/json': {
+                schema: OpenApiSchema;
+            };
+        };
+    }>;
+}
+interface OpenApiDocumentInfo {
+    title: string;
+    version: string;
+    description?: string;
+}
+interface ApiRouteDefinition {
+    path: string;
+    method: 'get' | 'post' | 'put' | 'patch' | 'delete';
+    operation: OpenApiOperation;
+}
+interface OpenApiComponent {
+    schemas?: Record<string, OpenApiSchema>;
+    parameters?: Record<string, OpenApiSchema>;
+    responses?: Record<string, OpenApiSchema>;
+    securitySchemes?: Record<string, unknown>;
+}
+interface OpenApiDocument {
+    openapi: string;
+    info: OpenApiDocumentInfo;
+    paths: Record<string, Record<string, OpenApiOperation>>;
+    components?: OpenApiComponent;
+}
+
+interface TypeMappingStrategy {
+    supports(columnType: string): boolean;
+    getOpenApiType(): OpenApiType;
+    getFormat(columnType: string): string | undefined;
+}
+declare class IntegerTypeStrategy implements TypeMappingStrategy {
+    private readonly types;
+    supports(type: string): boolean;
+    getOpenApiType(): OpenApiType;
+    getFormat(): string | undefined;
+}
+declare class BigIntTypeStrategy implements TypeMappingStrategy {
+    private readonly types;
+    supports(type: string): boolean;
+    getOpenApiType(): OpenApiType;
+    getFormat(): string | undefined;
+}
+declare class DecimalTypeStrategy implements TypeMappingStrategy {
+    private readonly types;
+    supports(type: string): boolean;
+    getOpenApiType(): OpenApiType;
+    getFormat(): string | undefined;
+}
+declare class BooleanTypeStrategy implements TypeMappingStrategy {
+    private readonly types;
+    supports(type: string): boolean;
+    getOpenApiType(): OpenApiType;
+    getFormat(): undefined;
+}
+declare class UuidTypeStrategy implements TypeMappingStrategy {
+    private readonly types;
+    supports(type: string): boolean;
+    getOpenApiType(): OpenApiType;
+    getFormat(): string;
+}
+declare class DateTimeTypeStrategy implements TypeMappingStrategy {
+    private readonly types;
+    supports(type: string): boolean;
+    getOpenApiType(): OpenApiType;
+    getFormat(columnType?: string): string;
+}
+declare class StringTypeStrategy implements TypeMappingStrategy {
+    private readonly types;
+    supports(type: string): boolean;
+    getOpenApiType(): OpenApiType;
+    getFormat(): undefined;
+}
+declare class DefaultTypeStrategy implements TypeMappingStrategy {
+    supports(): boolean;
+    getOpenApiType(): OpenApiType;
+    getFormat(): undefined;
+}
+declare class TypeMappingService {
+    private readonly strategies;
+    constructor();
+    getOpenApiType(column: ColumnDef): OpenApiType;
+    getFormat(column: ColumnDef): string | undefined;
+    private findStrategy;
+    registerStrategy(strategy: TypeMappingStrategy, index?: number): void;
+}
+declare const typeMappingService: TypeMappingService;
+declare function columnTypeToOpenApiType(col: ColumnDef): OpenApiType;
+declare function columnTypeToOpenApiFormat(col: ColumnDef): string | undefined;
+
+declare function schemaToJson(schema: OpenApiSchema): string;
+declare function deepCloneSchema(schema: OpenApiSchema): OpenApiSchema;
+declare function mergeSchemas(base: OpenApiSchema, override: Partial<OpenApiSchema>): OpenApiSchema;
+declare function generateOpenApiDocument(info: OpenApiDocumentInfo, routes: ApiRouteDefinition[]): OpenApiDocument;
+
+declare function isTableDef(target: TableDef | EntityConstructor): target is TableDef;
+declare function getColumnMap(target: TableDef | EntityConstructor): Record<string, ColumnDef>;
+type TargetType<T extends TableDef | EntityConstructor> = T;
+
+declare function columnToOpenApiSchema(col: ColumnDef): OpenApiSchema;
+
+declare function dtoToOpenApiSchema<T extends TableDef | EntityConstructor, TExclude extends keyof any>(target: T, exclude?: TExclude[]): OpenApiSchema;
+declare function createDtoToOpenApiSchema<T extends TableDef | EntityConstructor, TExclude extends keyof any>(target: T, exclude?: TExclude[]): OpenApiSchema;
+declare function updateDtoToOpenApiSchema<T extends TableDef | EntityConstructor, TExclude extends keyof any>(target: T, exclude?: TExclude[]): OpenApiSchema;
+
+declare function whereInputToOpenApiSchema<T extends TableDef | EntityConstructor>(target: T): OpenApiSchema;
+
+declare function relationFilterToOpenApiSchema(relation: RelationDef, options?: {
+    exclude?: string[];
+    include?: string[];
+}): OpenApiSchema;
+declare function whereInputWithRelationsToOpenApiSchema<T extends TableDef | EntityConstructor>(target: T, options?: {
+    columnExclude?: string[];
+    columnInclude?: string[];
+    relationExclude?: string[];
+    relationInclude?: string[];
+    maxDepth?: number;
+}): OpenApiSchema;
+declare function nestedWhereInputToOpenApiSchema<T extends TableDef | EntityConstructor>(target: T, depth?: number): OpenApiSchema;
+
+interface ComponentOptions {
+    prefix?: string;
+    exclude?: string[];
+    include?: string[];
+}
+interface NestedDtoOptions {
+    maxDepth?: number;
+    includeRelations?: boolean;
+    componentOptions?: ComponentOptions;
+}
+interface ComponentReference {
+    $ref: string;
+}
+declare function isComponentReference(schema: OpenApiSchema): schema is ComponentReference;
+declare function nestedDtoToOpenApiSchema<T extends TableDef | EntityConstructor>(target: T, options?: NestedDtoOptions): OpenApiSchema;
+declare function updateDtoWithRelationsToOpenApiSchema<T extends TableDef | EntityConstructor>(target: T, _options?: NestedDtoOptions): OpenApiSchema;
+declare function generateComponentSchemas(targets: Array<{
+    name: string;
+    table: TableDef | EntityConstructor;
+}>, options?: ComponentOptions): Record<string, OpenApiSchema>;
+declare function generateRelationComponents(tables: Array<{
+    name: string;
+    table: TableDef;
+}>, options?: ComponentOptions): Record<string, OpenApiSchema>;
+declare function createApiComponentsSection(schemas: Record<string, OpenApiSchema>, parameters?: Record<string, OpenApiSchema>, responses?: Record<string, OpenApiSchema>): OpenApiComponent;
+declare function createRef(path: string): ComponentReference;
+declare function schemaToRef(schemaName: string): ComponentReference;
+declare function parameterToRef(paramName: string): ComponentReference;
+declare function responseToRef(responseName: string): ComponentReference;
+declare function replaceWithRefs(schema: OpenApiSchema, schemaMap: Record<string, OpenApiSchema>, path?: string): OpenApiSchema;
+declare function extractReusableSchemas(schema: OpenApiSchema, existing?: Record<string, OpenApiSchema>, prefix?: string): Record<string, OpenApiSchema>;
+
+interface PaginationParams {
+    page?: number;
+    pageSize?: number;
+    sortBy?: string;
+    sortOrder?: 'asc' | 'desc';
+}
+declare const paginationParamsSchema: OpenApiSchema;
+declare function toPaginationParams(): OpenApiParameter[];
+declare function pagedResponseToOpenApiSchema<T extends OpenApiSchema>(itemSchema: T): OpenApiSchema;
+
+export { type AliasRefNode, type AnyDomainEvent, type ApiRouteDefinition, type ArithmeticExpressionNode, type TableRef as AstTableRef, AsyncLocalStorage, BelongsTo, BelongsToMany, type BelongsToManyOptions, type BelongsToManyRelation, type BelongsToOptions, type BelongsToReference, type BelongsToReferenceApi, type BelongsToRelation, type BetweenExpressionNode, BigIntTypeStrategy, type BinaryExpressionNode, type BitwiseExpressionNode, type BooleanFilter, BooleanTypeStrategy, type CascadeMode, type CaseExpressionNode, type CastExpressionNode, type CheckConstraint, type CollateExpressionNode, Column, type ColumnDef, type ColumnDiff, type ColumnInput, type ColumnNode, type ColumnOptions, type ColumnRef, type ColumnToTs, type ColumnType, type ComponentOptions, type ComponentReference, ConstructorMaterializationStrategy, type CreateDto, type CreateTediousClientOptions, type DatabaseCheck, type DatabaseColumn, type DatabaseIndex, type DatabaseSchema, type DatabaseTable, type DateFilter, DateTimeTypeStrategy, type DbExecutor, type DbExecutorFactory, DecimalTypeStrategy, type DecoratedEntityInstance, DefaultBelongsToReference, DefaultEntityMaterializer, DefaultHasManyCollection, DefaultManyToManyCollection, DefaultTypeStrategy, type DefaultValue, DeleteQueryBuilder, type DialectName, type DomainEvent, DomainEventBus, type DomainEventHandler, type Dto, Entity, type EntityContext, type EntityInstance, type EntityMaterializationStrategy, type EntityMaterializer, type EntityOptions, type PrimaryKey$1 as EntityPrimaryKey, EntityStatus, type ExecutionContext, type ExistsExpressionNode, type ExpressionNode, type ExpressionVisitor, type FieldFilter, type FilterOperator, type FilterValue, type ForeignKeyReference, type FunctionNode, type GroupConcatOptions, type HasDomainEvents, HasMany, type HasManyCollection, type HasManyOptions, type HasManyRelation, HasOne, type HasOneOptions, type HasOneReference, type HasOneReferenceApi, type HasOneRelation, type HydrationContext, type HydrationMetadata, type HydrationPivotPlan, type HydrationPlan, type HydrationRelationPlan, type InExpressionNode, type InExpressionRight, type IndexColumn, type IndexDef, type InferRow, type InitialHandlers, InsertQueryBuilder, IntegerTypeStrategy, InterceptorPipeline, type IntrospectOptions, type JsonArray, type JsonObject, type JsonPathNode, type JsonValue, type Jsonify, type JsonifyScalar, type LiteralNode, type LiteralValue, type LogicalExpressionNode, type ManyToManyCollection, type MssqlClientLike, MySqlDialect, type MysqlClientLike, type NestedDtoOptions, type NullExpressionNode, type NumberFilter, type OpenApiComponent, type OpenApiDocument, type OpenApiDocumentInfo, type OpenApiOperation, type OpenApiParameter, type OpenApiSchema, type OpenApiType, type OperandNode, type OperandVisitor, Orm, type OrmDomainEvent, type OrmInterceptor, type OrmOptions, OrmSession, type OrmSessionOptions, type PagedResponse, type PaginatedResult, type PaginationParams, Pool, type PoolAdapter, type PoolLease, type PoolOptions, type PooledConnectionAdapter, type PostgresClientLike, PostgresDialect, PrimaryKey, type Primitive, PrototypeMaterializationStrategy, type QueryContext, type QueryInterceptor, type QueryLogEntry, type QueryLogger, type QueryResult, type RawDefaultValue, type ReferentialAction, type RelationChange, type RelationChangeEntry, type RelationDef, type RelationKey$1 as RelationKey, RelationKinds, type RelationMap, type RelationTargetTable, type RelationType, type RenderColumnOptions, STANDARD_COLUMN_TYPES, type SaveGraphInputPayload, type SaveGraphInputScalar, type SaveGraphJsonScalar, type SaveGraphSessionOptions, type ScalarSubqueryNode, type SchemaChange, type SchemaChangeKind, type SchemaDiffOptions, type SchemaGenerateResult, type SchemaIntrospector, type SchemaPlan, SelectQueryBuilder, type SelectQueryInput, type SelectableKeys, type SimpleQueryRunner, type SimpleWhereInput, type Simplify, SqlServerDialect, type SqliteClientLike, SqliteDialect, type StandardColumnType, type StringFilter, StringTypeStrategy, type SynchronizeOptions, type TableDef, type TableHooks, type TableOptions, type TableRef$1 as TableRef, type TargetType, type TediousColumn, type TediousConnectionLike, type TediousModule, type TediousRequest, type TediousRequestCtor, type TediousTypes, type TrackedEntity, TypeMappingService, type TypeMappingStrategy, TypeScriptGenerator, type TypedExpression, type TypedLike, type UpdateDto, UpdateQueryBuilder, UuidTypeStrategy, type ValueOperandInput, type WhereInput, type WindowFunctionNode, type WithRelations, abs, acos, add, addDomainEvent, age, aliasRef, and, applyFilter, arrayAppend, asType, ascii, asin, atan, atan2, avg, belongsTo, belongsToMany, between, bitAnd, bitLength, bitOr, bitXor, bootstrapEntities, buildFilterExpression, calculateTotalPages, caseWhen, cast, cbrt, ceil, ceiling, char, charLength, chr, clearExpressionDispatchers, clearOperandDispatchers, coalesce, col, collate, columnOperand, columnToOpenApiSchema, columnTypeToOpenApiFormat, columnTypeToOpenApiType, computePaginationMetadata, concat, concatWs, correlateBy, cos, cot, count, countAll, createApiComponentsSection, createDtoToOpenApiSchema, createEntityFromRow, createEntityProxy, createExecutorFromQueryRunner, createMssqlExecutor, createMysqlExecutor, createPooledExecutorFactory, createPostgresExecutor, createQueryLoggingExecutor, createRef, createSqliteExecutor, createTediousExecutor, createTediousMssqlClient, currentDate, currentTime, dateAdd, dateDiff, dateFormat, dateSub, dateTrunc, day, dayOfWeek, deepCloneSchema, defineTable, degrees, deleteFrom, denseRank, diffSchema, div, dtoToOpenApiSchema, endOfMonth, entityRef, entityRefs, eq, esel, exclude, executeHydrated, executeHydratedPlain, executeHydratedPlainWithContexts, executeHydratedWithContexts, executeSchemaSql, executeSchemaSqlFor, exists, exp, extract, extractReusableSchemas, firstValue, floor, fromUnixTime, generateComponentSchemas, generateCreateTableSql, generateOpenApiDocument, generateRelationComponents, generateSchemaSql, generateSchemaSqlFor, getColumn, getColumnMap, getDecoratorMetadata, getSchemaIntrospector, getTableDefFromEntity, greatest, groupConcat, gt, gte, hasMany, hasNextPage as hasNextPageMeta, hasOne, hasPrevPage as hasPrevPageMeta, hour, hydrateRows, ifNull, inList, inSubquery, initcap, insertInto, instr, introspectSchema, isCaseExpressionNode, isCastExpressionNode, isCollateExpressionNode, isComponentReference, isExpressionSelectionNode, isFunctionNode, isNotNull, isNull, isOperandNode, isTableDef, isValueOperandInput, isWindowFunctionNode, jsonArrayAgg, jsonContains, jsonLength, jsonPath, jsonSet, jsonify, lag, lastValue, lead, least, left, length, like, ln, loadBelongsToManyRelation, loadBelongsToRelation, loadHasManyRelation, loadHasOneRelation, localTime, localTimestamp, locate, log, log10, log2, logBase, lower, lpad, lt, lte, ltrim, mapFields, materializeAs, max, md5, mergeSchemas, min, minute, mod, month, mul, neq, nestedDtoToOpenApiSchema, nestedWhereInputToOpenApiSchema, normalizeColumnType, notBetween, notExists, notInList, notInSubquery, notLike, now, ntile, nullif, octetLength, or, outerRef, pagedResponseToOpenApiSchema, paginationParamsSchema, parameterToRef, pi, pick, position, pow, power, quarter, radians, rand, random, rank, registerExpressionDispatcher, registerOperandDispatcher, registerSchemaIntrospector, relationFilterToOpenApiSchema, relationLoaderCache, renderColumnDefinition, renderTypeWithArgs, repeat, replace, replaceWithRefs, responseToRef, reverse, right, round, rowNumber, rowsToQueryResult, rpad, rtrim, schemaToJson, schemaToRef, second, sel, selectFrom, selectFromEntity, setRelations, sha1, sha2, shiftLeft, shiftRight, sign, sin, space, sqrt, stddev, sub, substr, sum, synchronizeSchema, tableRef, tan, toColumnRef, toPagedResponse, toPagedResponseBuilder, toPaginationParams, toResponse, toResponseBuilder, toTableRef, trim, trunc, truncate, typeMappingService, unixTimestamp, update, updateDtoToOpenApiSchema, updateDtoWithRelationsToOpenApiSchema, upper, utcNow, valueToOperand, variance, visitExpression, visitOperand, weekOfYear, whereInputToOpenApiSchema, whereInputWithRelationsToOpenApiSchema, windowFunction, withDefaults, withDefaultsBuilder, year };