@datrix/core 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,1935 @@
+type QueryPrimitive = string | number | boolean | null | Date;
+type ScalarValue = string | number | boolean | Date;
+type QueryType = "select" | "insert" | "update" | "delete" | "count";
+type ComparisonOperators<T = QueryPrimitive> = {
+    readonly $eq?: T;
+    readonly $ne?: T;
+    readonly $gt?: T extends number | Date ? T : never;
+    readonly $gte?: T extends number | Date ? T : never;
+    readonly $lt?: T extends number | Date ? T : never;
+    readonly $lte?: T extends number | Date ? T : never;
+    readonly $in?: readonly T[];
+    readonly $nin?: readonly T[];
+    readonly $like?: T extends string ? string : never;
+    readonly $ilike?: T extends string ? string : never;
+    readonly $startsWith?: T extends string ? string : never;
+    readonly $endsWith?: T extends string ? string : never;
+    readonly $contains?: T extends string ? string : never;
+    readonly $notContains?: T extends string ? string : never;
+    readonly $icontains?: T extends string ? string : never;
+    readonly $regex?: T extends string ? RegExp | string : never;
+    readonly $exists?: boolean;
+    readonly $null?: boolean;
+    readonly $notNull?: boolean;
+};
+type LogicalOperators<T extends DatrixEntry = DatrixRecord> = {
+    readonly $and?: WhereClause<T>[];
+    readonly $or?: WhereClause<T>[];
+    readonly $not?: WhereClause<T>;
+};
+type Writable<T> = {
+    -readonly [K in keyof T]: T[K];
+};
+type FallbackWhereClause = {
+    [key: string]: QueryPrimitive | ComparisonOperators | FallbackWhereClause | FallbackWhereClause[] | undefined;
+    $and?: FallbackWhereClause[];
+    $or?: FallbackWhereClause[];
+    $not?: FallbackWhereClause;
+};
+type TypedWhereClause<T extends DatrixEntry> = Writable<{
+    [K in keyof T]?: T[K] extends RelationInput<infer R extends DatrixEntry> ? WhereClause<R> : T[K] extends ScalarValue ? T[K] | ComparisonOperators<T[K]> : never;
+}> & LogicalOperators<T>;
+type WhereClause<T extends DatrixEntry = DatrixRecord> = DatrixRecord extends T ? FallbackWhereClause : TypedWhereClause<T>;
+type SelectClause<T extends DatrixEntry = DatrixRecord> = (DatrixRecord extends T ? readonly string[] : readonly (keyof T)[]) | "*" | (DatrixRecord extends T ? string : keyof T);
+type PopulateOptions<T extends DatrixEntry> = {
+    readonly select?: SelectClause<T> | undefined;
+    readonly where?: WhereClause<T> | undefined;
+    readonly populate?: PopulateClause<T> | undefined;
+    readonly limit?: number | undefined;
+    readonly offset?: number | undefined;
+    readonly orderBy?: QueryOrderBy | undefined;
+};
+type PopulateClause<T extends DatrixEntry = DatrixRecord> = boolean | "*" | "true" | (DatrixRecord extends T ? readonly string[] : readonly (keyof T)[]) | {
+    readonly [K in DatrixRecord extends T ? string : keyof T]?: PopulateOptions<T> | "*" | boolean;
+};
+type OrderDirection = "asc" | "desc";
+type OrderByItem<T extends DatrixEntry> = {
+    readonly field: keyof T;
+    readonly direction: OrderDirection;
+    readonly nulls?: "first" | "last";
+};
+type FallbackOrderByItem = {
+    readonly field: string;
+    readonly direction: OrderDirection;
+    readonly nulls?: "first" | "last";
+};
+type QueryOrderBy<T extends DatrixEntry = DatrixRecord> = DatrixRecord extends T ? readonly FallbackOrderByItem[] : readonly OrderByItem<T>[];
+type OrderByClause<T extends DatrixEntry = DatrixRecord> = DatrixRecord extends T ? readonly FallbackOrderByItem[] | Record<string, OrderDirection> | readonly string[] : QueryOrderBy<T> | Partial<Record<keyof T, OrderDirection>> | readonly (keyof T | `-${string & keyof T}`)[];
+type QuerySelect<T extends DatrixEntry = DatrixRecord> = DatrixRecord extends T ? readonly string[] : readonly (keyof T)[];
+type QueryPopulateOptions<T extends DatrixEntry> = {
+    readonly select: QuerySelect<T>;
+    readonly where?: WhereClause<T> | undefined;
+    readonly populate?: QueryPopulate<T> | undefined;
+    readonly limit?: number | undefined;
+    readonly offset?: number | undefined;
+    readonly orderBy?: QueryOrderBy | undefined;
+};
+type QueryPopulate<T extends DatrixEntry = DatrixRecord> = {
+    readonly [K in keyof T]?: T[K] extends RelationInput<infer R extends DatrixEntry> ? QueryPopulateOptions<R> : never;
+};
+type NormalizedNestedData<T extends DatrixEntry> = {
+    readonly data: Partial<T>;
+    readonly relations?: QueryRelations<T> | undefined;
+};
+type NormalizedRelationOperations<R extends DatrixEntry> = {
+    readonly connect?: readonly number[];
+    readonly disconnect?: readonly number[];
+    readonly set?: readonly number[];
+    readonly delete?: readonly number[];
+    readonly create?: readonly NormalizedNestedData<R>[];
+    readonly update?: readonly NormalizedRelationUpdate<R>[];
+};
+interface NormalizedRelationUpdate<T extends DatrixEntry> extends NormalizedNestedData<T> {
+    readonly where: {
+        readonly id: number;
+    };
+}
+type QueryRelations<T extends DatrixEntry> = {
+    readonly [K in keyof T]?: T[K] extends RelationInput<infer R extends DatrixEntry> ? NormalizedRelationOperations<R> : never;
+};
+interface QueryBase {
+    readonly table: string;
+}
+interface QuerySelectObject<T extends DatrixEntry> extends QueryBase {
+    readonly type: "select";
+    readonly select: QuerySelect<T>;
+    where?: WhereClause<T>;
+    readonly populate?: QueryPopulate<T> | undefined;
+    readonly orderBy?: QueryOrderBy | undefined;
+    readonly limit?: number | undefined;
+    readonly offset?: number | undefined;
+    readonly distinct?: boolean | undefined;
+    readonly groupBy?: readonly string[] | undefined;
+    readonly having?: WhereClause<T> | undefined;
+}
+interface QueryCountObject<T extends DatrixEntry> extends QueryBase {
+    readonly type: "count";
+    where?: WhereClause<T>;
+    readonly groupBy?: readonly string[];
+    readonly having?: WhereClause<T>;
+}
+interface QueryInsertObject<T extends DatrixEntry> extends QueryBase {
+    readonly type: "insert";
+    readonly data: readonly Partial<T>[];
+    readonly relations?: QueryRelations<T> | undefined;
+    readonly select?: QuerySelect<T> | undefined;
+    readonly populate?: QueryPopulate<T> | undefined;
+}
+interface QueryUpdateObject<T extends DatrixEntry> extends QueryBase {
+    readonly type: "update";
+    readonly data: Partial<T>;
+    where?: WhereClause<T>;
+    readonly relations?: QueryRelations<T> | undefined;
+    readonly select?: QuerySelect<T> | undefined;
+    readonly populate?: QueryPopulate<T> | undefined;
+}
+interface QueryDeleteObject<T extends DatrixEntry> extends QueryBase {
+    readonly type: "delete";
+    where: WhereClause<T>;
+    readonly select?: QuerySelect<T>;
+    readonly populate?: QueryPopulate<T>;
+}
+type QueryObject<T extends DatrixEntry = DatrixRecord> = QuerySelectObject<T> | QueryCountObject<T> | QueryInsertObject<T> | QueryUpdateObject<T> | QueryDeleteObject<T>;
+type QueryObjectForType<T extends DatrixEntry, TType extends QueryType> = TType extends "select" ? QuerySelectObject<T> : TType extends "count" ? QueryCountObject<T> : TType extends "insert" ? QueryInsertObject<T> : TType extends "update" ? QueryUpdateObject<T> : TType extends "delete" ? QueryDeleteObject<T> : QueryObject<T>;
+
+declare class DatrixError<TContext extends Record<string, unknown> = Record<string, unknown>> extends Error {
+    readonly code: string;
+    readonly timestamp: Date;
+    readonly operation?: string | undefined;
+    readonly context?: TContext | undefined;
+    readonly cause?: Error | undefined;
+    readonly suggestion?: string | undefined;
+    readonly expected?: string | undefined;
+    readonly received?: unknown;
+    readonly documentation?: string | undefined;
+    constructor(message: string, options: DatrixErrorOptions<TContext>);
+    toJSON(): SerializedDatrixError;
+    toDetailedMessage(): string;
+    static isDatrixError(error: unknown): error is DatrixError;
+}
+interface DatrixErrorOptions<TContext extends Record<string, unknown> = Record<string, unknown>> {
+    readonly code: string;
+    readonly operation?: string | undefined;
+    readonly context?: TContext | undefined;
+    readonly cause?: Error | undefined;
+    readonly suggestion?: string | undefined;
+    readonly expected?: string | undefined;
+    readonly received?: unknown | undefined;
+    readonly documentation?: string | undefined;
+}
+interface SerializedDatrixError {
+    readonly type: string;
+    readonly message: string;
+    readonly code: string;
+    readonly timestamp: string;
+    operation?: string;
+    context?: Record<string, unknown>;
+    suggestion?: string;
+    expected?: string;
+    received?: unknown;
+    documentation?: string;
+    cause?: {
+        readonly message: string;
+        readonly name: string;
+    };
+}
+
+type ParserType = "where" | "populate" | "fields" | "sort" | "pagination" | "query";
+interface ErrorLocation {
+    readonly path: string;
+    readonly parts: readonly string[];
+    readonly queryParam?: string | undefined;
+    readonly index?: number | undefined;
+    readonly depth?: number | undefined;
+}
+interface BaseErrorContext {
+    readonly [key: string]: unknown;
+}
+interface WhereErrorContext extends BaseErrorContext {
+    readonly operator?: string;
+    readonly operatorPath?: string;
+    readonly validOperators?: readonly string[];
+    readonly arrayIndex?: number;
+    readonly previousOperator?: string;
+    readonly fieldValidationReason?: string;
+}
+interface PopulateErrorContext extends BaseErrorContext {
+    readonly relation?: string;
+    readonly relationPath?: string;
+    readonly currentDepth?: number;
+    readonly maxDepth?: number;
+    readonly nestedRelations?: readonly string[];
+    readonly fieldValidationReason?: string;
+}
+interface FieldsErrorContext extends BaseErrorContext {
+    readonly fieldName?: string;
+    readonly invalidFields?: readonly string[];
+    readonly validationReasons?: readonly string[];
+    readonly suspiciousParams?: readonly string[];
+    readonly fieldValidationReason?: string;
+}
+interface PaginationErrorContext extends BaseErrorContext {
+    readonly parameter?: "page" | "pageSize" | "limit" | "offset";
+    readonly minValue?: number;
+    readonly maxValue?: number;
+}
+interface SortErrorContext extends BaseErrorContext {
+    readonly sortField?: string;
+    readonly sortDirection?: string;
+    readonly invalidFields?: readonly string[];
+    readonly fieldValidationReason?: string;
+}
+type ParserErrorContext = WhereErrorContext | PopulateErrorContext | FieldsErrorContext | PaginationErrorContext | SortErrorContext | BaseErrorContext;
+type ParserErrorCode = "INVALID_SYNTAX" | "INVALID_OPERATOR" | "INVALID_VALUE_TYPE" | "INVALID_VALUE_FORMAT" | "INVALID_FIELD_NAME" | "INVALID_PATH" | "MAX_DEPTH_EXCEEDED" | "MAX_LENGTH_EXCEEDED" | "MAX_SIZE_EXCEEDED" | "MIN_VALUE_VIOLATION" | "MAX_VALUE_VIOLATION" | "MISSING_REQUIRED" | "EMPTY_VALUE" | "ARRAY_INDEX_ERROR" | "CONSECUTIVE_INDEX_ERROR" | "UNKNOWN_PARAMETER" | "DUPLICATE_FIELD" | "INVALID_PAGINATION" | "PAGE_OUT_OF_RANGE" | "PARSER_INTERNAL_ERROR";
+interface ParserErrorOptions {
+    readonly code: ParserErrorCode;
+    readonly parser: ParserType;
+    readonly location: ErrorLocation;
+    readonly context?: ParserErrorContext;
+    readonly suggestion?: string;
+    readonly received?: unknown;
+    readonly expected?: string;
+}
+interface SerializedParserError extends SerializedDatrixError {
+    readonly parser: ParserType;
+    readonly location: ErrorLocation;
+}
+declare class ParserError extends DatrixError<ParserErrorContext> {
+    readonly parser: ParserType;
+    readonly location: ErrorLocation;
+    constructor(message: string, options: ParserErrorOptions);
+    toJSON(): SerializedParserError;
+    toDetailedMessage(): string;
+}
+declare function buildErrorLocation(parts: string[], options?: {
+    queryParam?: string | undefined;
+    index?: number | undefined;
+    depth?: number | undefined;
+}): ErrorLocation;
+
+type RawQueryParams = Record<string, string | readonly string[] | undefined>;
+interface ParsedQuery<T extends DatrixEntry = DatrixEntry> {
+    readonly select?: SelectClause<T>;
+    readonly where?: WhereClause<T>;
+    readonly populate?: PopulateClause<T>;
+    readonly orderBy?: OrderByClause<T>;
+    readonly page?: number;
+    readonly pageSize?: number;
+}
+interface ParserOptions {
+    readonly maxPageSize?: number;
+    readonly defaultPageSize?: number;
+    readonly maxPopulateDepth?: number;
+    readonly allowedOperators?: readonly string[];
+    readonly strictMode?: boolean;
+}
+
+declare const WHERE_OPERATORS: readonly ["$eq", "$ne", "$lt", "$lte", "$gt", "$gte", "$in", "$nin", "$contains", "$notContains", "$startsWith", "$endsWith", "$null", "$notNull", "$like", "$ilike", "$and", "$or", "$not"];
+type WhereOperator = (typeof WHERE_OPERATORS)[number];
+declare function isWhereOperator(value: string): value is WhereOperator;
+interface PaginationParams {
+    readonly page?: number;
+    readonly pageSize?: number;
+}
+interface ParsedPagination {
+    readonly page: number;
+    readonly pageSize: number;
+}
+type SortParam = string | readonly string[];
+type ParsedSort<T extends DatrixEntry = DatrixRecord> = readonly OrderByItem<T>[];
+
+interface UploadFile {
+    readonly filename: string;
+    readonly originalName: string;
+    readonly mimetype: string;
+    readonly size: number;
+    readonly buffer: Uint8Array;
+}
+interface UploadResult {
+    readonly key: string;
+    readonly size: number;
+    readonly mimetype: string;
+    readonly uploadedAt: Date;
+}
+interface StorageProvider {
+    readonly name: string;
+    upload(file: UploadFile): Promise<UploadResult>;
+    delete(key: string): Promise<void>;
+    getUrl(key: string): string;
+    exists(key: string): Promise<boolean>;
+}
+interface MediaVariant {
+    readonly key: string;
+    readonly url: string;
+    readonly width: number;
+    readonly height: number;
+    readonly size: number;
+    readonly mimeType: string;
+}
+type MediaVariants<TResolutions extends string = string> = {
+    readonly [K in TResolutions]?: MediaVariant;
+};
+interface MediaEntry<TResolutions extends string = string> extends DatrixEntry {
+    readonly filename: string;
+    readonly originalName: string;
+    readonly mimeType: string;
+    readonly size: number;
+    readonly url: string;
+    readonly key: string;
+    readonly variants: MediaVariants<TResolutions> | null;
+}
+interface UploadConfig {
+    readonly provider: StorageProvider;
+    readonly modelName?: string;
+    readonly maxSize?: number;
+    readonly allowedMimeTypes?: readonly string[];
+    readonly permission?: SchemaPermission;
+}
+interface LocalProviderOptions {
+    readonly basePath: string;
+    readonly baseUrl: string;
+    readonly ensureDirectory?: boolean;
+}
+interface S3ProviderOptions {
+    readonly bucket: string;
+    readonly region: string;
+    readonly accessKeyId: string;
+    readonly secretAccessKey: string;
+    readonly endpoint?: string;
+    readonly pathPrefix?: string;
+}
+declare function generateUniqueFilename(originalFilename: string): string;
+declare function getFileExtension(filename: string): string;
+declare function sanitizeFilename(filename: string): string;
+interface IUpload {
+    getSchemas(): Promise<SchemaDefinition[]> | SchemaDefinition[];
+    handleRequest(request: Request, datrix: unknown): Promise<Response>;
+    getModelName(): string;
+    injectUrls(data: unknown): Promise<unknown>;
+    getUrl(key: string): string;
+    readonly provider: StorageProvider;
+}
+declare function isStorageProvider(value: unknown): value is StorageProvider;
+
+interface AuthenticatedUser<TRoles extends string = string, TUser extends DatrixEntry = DatrixEntry> extends DatrixEntry {
+    user: TUser;
+    email: string;
+    password: string;
+    passwordSalt: string;
+    role: TRoles;
+}
+interface AuthUser {
+    readonly id: number;
+    readonly email: string;
+    readonly role: string;
+}
+interface AuthContext {
+    readonly user: AuthUser | undefined;
+    readonly sessionId?: string;
+    readonly token?: string;
+}
+interface LoginResult {
+    readonly user: AuthUser;
+    readonly token?: string;
+    readonly sessionId?: string;
+}
+interface IAuthManager {
+    hashPassword(password: string): Promise<{
+        hash: string;
+        salt: string;
+    }>;
+    verifyPassword(password: string, hash: string, salt: string): Promise<boolean>;
+    login(user: AuthUser, options?: {
+        createToken?: boolean;
+        createSession?: boolean;
+    }): Promise<LoginResult>;
+    logout(sessionId: string): Promise<void>;
+    authenticate(request: Request): Promise<AuthContext | null>;
+    destroy(): Promise<void>;
+}
+
+type AdapterName = "postgres" | "mysql" | "mongodb" | "json";
+type AdapterOperation = "connect" | "disconnect" | "query" | "transaction" | "populate" | "join" | "aggregation" | "migration" | "introspection" | "lock" | "read" | "write" | "validate";
+type AdapterErrorCode = "ADAPTER_CONNECTION_ERROR" | "ADAPTER_QUERY_ERROR" | "ADAPTER_TRANSACTION_ERROR" | "ADAPTER_MIGRATION_ERROR" | "ADAPTER_INTROSPECTION_ERROR" | "ADAPTER_AGGREGATION_ERROR" | "ADAPTER_POPULATE_ERROR" | "ADAPTER_JOIN_ERROR" | "ADAPTER_LATERAL_JOIN_ERROR" | "ADAPTER_JSON_AGGREGATION_ERROR" | "ADAPTER_RESULT_PROCESSING_ERROR" | "ADAPTER_INVALID_POPULATE_OPTIONS" | "ADAPTER_MODEL_NOT_FOUND" | "ADAPTER_SCHEMA_NOT_FOUND" | "ADAPTER_RELATION_NOT_FOUND" | "ADAPTER_INVALID_RELATION" | "ADAPTER_TARGET_MODEL_NOT_FOUND" | "ADAPTER_JUNCTION_TABLE_NOT_FOUND" | "ADAPTER_MAX_DEPTH_EXCEEDED" | "ADAPTER_LOCK_TIMEOUT" | "ADAPTER_LOCK_ERROR" | "ADAPTER_FILE_READ_ERROR" | "ADAPTER_FILE_WRITE_ERROR" | "ADAPTER_FILE_NOT_FOUND" | "ADAPTER_INVALID_DATA" | "ADAPTER_QUERY_MISSING_DATA" | "ADAPTER_INVALID_WHERE_FIELD" | "ADAPTER_INVALID_RELATION_WHERE" | "ADAPTER_UNIQUE_CONSTRAINT" | "ADAPTER_FOREIGN_KEY_CONSTRAINT" | "ADAPTER_META_FIELD_EXISTS" | "ADAPTER_META_FIELD_NOT_FOUND";
+interface AdapterErrorContext {
+    readonly table?: string;
+    readonly model?: string;
+    readonly field?: string;
+    readonly relationName?: string;
+    readonly targetModel?: string;
+    readonly junctionTable?: string;
+    readonly query?: Record<string, unknown>;
+    readonly sql?: string;
+    readonly params?: readonly unknown[];
+    readonly depth?: number;
+    readonly maxDepth?: number;
+    readonly relationPath?: string;
+    readonly file?: string;
+    readonly lockTimeout?: number;
+    readonly [key: string]: unknown;
+}
+interface DatrixAdapterErrorOptions {
+    readonly adapter: AdapterName;
+    readonly code: AdapterErrorCode;
+    readonly operation?: AdapterOperation | undefined;
+    readonly context?: AdapterErrorContext | undefined;
+    readonly cause?: Error | undefined;
+    readonly suggestion?: string | undefined;
+    readonly expected?: string | undefined;
+    readonly received?: unknown | undefined;
+}
+interface SerializedDatrixAdapterError extends SerializedDatrixError {
+    readonly adapter: AdapterName;
+    readonly adapterOperation?: AdapterOperation;
+}
+declare class DatrixAdapterError extends DatrixError<AdapterErrorContext> {
+    readonly adapter: AdapterName;
+    readonly adapterOperation?: AdapterOperation | undefined;
+    constructor(message: string, options: DatrixAdapterErrorOptions);
+    toJSON(): SerializedDatrixAdapterError;
+    toDetailedMessage(): string;
+}
+
+declare function truncateSqlForError(sql: string): string;
+declare function throwNotConnected(params: {
+    adapter: AdapterName;
+}): never;
+declare function throwConnectionError(params: {
+    adapter: AdapterName;
+    message: string;
+    operation?: "connect" | "disconnect";
+    cause?: Error | undefined;
+}): never;
+declare function throwMigrationError(params: {
+    adapter: AdapterName;
+    message: string;
+    table?: string | undefined;
+    cause?: Error | undefined;
+    suggestion?: string | undefined;
+}): never;
+declare function throwIntrospectionError(params: {
+    adapter: AdapterName;
+    message: string;
+    table?: string | undefined;
+    cause?: Error | undefined;
+}): never;
+declare function throwQueryError(params: {
+    adapter: AdapterName;
+    message: string;
+    query?: QueryObject | undefined;
+    sql?: string | undefined;
+    cause?: Error | undefined;
+    suggestion?: string | undefined;
+    expected?: string | undefined;
+    received?: unknown;
+}): never;
+declare function throwQueryMissingData(params: {
+    adapter: AdapterName;
+    queryType: string;
+    table: string;
+}): never;
+declare function throwTransactionError(params: {
+    adapter: AdapterName;
+    message: string;
+    cause?: Error | undefined;
+}): never;
+declare function throwTransactionAlreadyCommitted(params: {
+    adapter: AdapterName;
+}): never;
+declare function throwTransactionAlreadyRolledBack(params: {
+    adapter: AdapterName;
+}): never;
+declare function throwTransactionSavepointNotSupported(params: {
+    adapter: AdapterName;
+}): never;
+declare function throwRawQueryNotSupported(params: {
+    adapter: AdapterName;
+}): never;
+declare function throwModelNotFound(params: {
+    adapter: AdapterName;
+    table: string;
+}): never;
+declare function throwSchemaNotFound(params: {
+    adapter: AdapterName;
+    modelName: string;
+}): never;
+declare function throwRelationNotFound(params: {
+    adapter: AdapterName;
+    relationName: string;
+    schemaName: string;
+}): never;
+declare function throwInvalidRelationType(params: {
+    adapter: AdapterName;
+    relationName: string;
+    fieldType: string;
+    schemaName: string;
+}): never;
+declare function throwTargetModelNotFound(params: {
+    adapter: AdapterName;
+    targetModel: string;
+    relationName: string;
+    schemaName: string;
+}): never;
+declare function throwJunctionTableNotFound(params: {
+    adapter: AdapterName;
+    junctionTable: string;
+    relationName: string;
+    schemaName: string;
+}): never;
+declare function throwMaxDepthExceeded(params: {
+    adapter: AdapterName;
+    currentDepth: number;
+    maxDepth: number;
+    relationPath: string;
+}): never;
+declare function throwPopulateQueryError<T extends DatrixEntry>(params: {
+    adapter: AdapterName;
+    query: QueryObject<T>;
+    sql: string;
+    cause: Error;
+    strategy?: string | undefined;
+    queryParams?: readonly unknown[] | undefined;
+}): never;
+declare function throwInvalidPopulateOptions(params: {
+    adapter: AdapterName;
+    relationName: string;
+    optionName: string;
+    optionValue: unknown;
+}): never;
+declare function throwJoinBuildError(params: {
+    adapter: AdapterName;
+    relationName: string;
+    relationKind: string;
+    cause?: Error | undefined;
+}): never;
+declare function throwLateralJoinError(params: {
+    adapter: AdapterName;
+    relationName: string;
+    cause?: Error | undefined;
+}): never;
+declare function throwJsonAggregationError(params: {
+    adapter: AdapterName;
+    relationName: string;
+    cause?: Error | undefined;
+}): never;
+declare function throwResultProcessingError(params: {
+    adapter: AdapterName;
+    operation: string;
+    cause?: Error | undefined;
+}): never;
+declare function throwMetaFieldAlreadyExists(params: {
+    adapter: AdapterName;
+    field: string;
+    table: string;
+}): never;
+declare function throwMetaFieldNotFound(params: {
+    adapter: AdapterName;
+    field: string;
+    table: string;
+}): never;
+declare function throwLockTimeout(params: {
+    adapter: AdapterName;
+    lockTimeout: number;
+}): never;
+declare function throwLockError(params: {
+    adapter: AdapterName;
+    cause?: Error | undefined;
+}): never;
+declare function throwFileReadError(params: {
+    adapter: AdapterName;
+    file: string;
+    cause?: Error | undefined;
+}): never;
+declare function throwFileWriteError(params: {
+    adapter: AdapterName;
+    file: string;
+    cause?: Error | undefined;
+}): never;
+declare function throwFileNotFound(params: {
+    adapter: AdapterName;
+    file: string;
+}): never;
+declare function throwUniqueConstraintField(params: {
+    adapter: AdapterName;
+    field: string;
+    value: unknown;
+    table: string;
+}): never;
+declare function throwUniqueConstraintIndex(params: {
+    adapter: AdapterName;
+    fields: readonly string[];
+    table: string;
+}): never;
+declare function throwForeignKeyConstraint(params: {
+    adapter: AdapterName;
+    foreignKey: string;
+    value: unknown;
+    targetModel: string;
+    table: string;
+}): never;
+declare function throwInvalidWhereField(params: {
+    adapter: AdapterName;
+    field: string;
+    schemaName: string;
+    availableFields: readonly string[];
+}): never;
+declare function throwInvalidRelationWhereSyntax(params: {
+    adapter: AdapterName;
+    relationName: string;
+    schemaName: string;
+    foreignKey: string;
+}): never;
+
+interface ExportMeta {
+    readonly version: number;
+    readonly exportedAt: string;
+}
+interface ExportWriter {
+    writeMeta(meta: ExportMeta): Promise<void>;
+    writeSchema(schema: SchemaDefinition): Promise<void>;
+    writeChunk(tableName: string, rows: Record<string, unknown>[]): Promise<void>;
+    finalize(): Promise<void>;
+}
+interface ImportReader {
+    readMeta(): Promise<ExportMeta>;
+    readSchemas(): AsyncIterable<SchemaDefinition>;
+    getTables(): Promise<readonly string[]>;
+    readChunks(tableName: string): AsyncIterable<Record<string, unknown>[]>;
+}
+
+interface QueryMetadata {
+    readonly rowCount?: number;
+    readonly affectedRows?: number;
+    readonly insertIds?: readonly number[];
+    readonly count?: number;
+}
+interface QueryResult<T = unknown> {
+    readonly rows: readonly T[];
+    readonly metadata: QueryMetadata;
+}
+interface QueryRunner {
+    executeQuery<TResult extends DatrixEntry>(query: QueryObject<TResult>): Promise<QueryResult<TResult>>;
+    executeRawQuery<TResult extends DatrixEntry>(sql: string, params: readonly unknown[]): Promise<QueryResult<TResult>>;
+}
+interface SchemaOperations {
+    createTable(schema: SchemaDefinition): Promise<void>;
+    dropTable(tableName: string): Promise<void>;
+    renameTable(from: string, to: string): Promise<void>;
+    alterTable(tableName: string, operations: readonly AlterOperation[]): Promise<void>;
+    addIndex(tableName: string, index: IndexDefinition): Promise<void>;
+    dropIndex(tableName: string, indexName: string): Promise<void>;
+}
+interface Transaction extends QueryRunner, SchemaOperations {
+    readonly id: string;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    savepoint(name: string): Promise<void>;
+    rollbackTo(name: string): Promise<void>;
+    release(name: string): Promise<void>;
+}
+type AlterOperation = {
+    readonly type: "addColumn";
+    readonly column: string;
+    readonly definition: FieldDefinition;
+} | {
+    readonly type: "dropColumn";
+    readonly column: string;
+} | {
+    readonly type: "modifyColumn";
+    readonly column: string;
+    readonly newDefinition: FieldDefinition;
+} | {
+    readonly type: "renameColumn";
+    readonly from: string;
+    readonly to: string;
+} | {
+    readonly type: "addMetaField";
+    readonly field: string;
+    readonly definition: FieldDefinition;
+} | {
+    readonly type: "dropMetaField";
+    readonly field: string;
+} | {
+    readonly type: "modifyMetaField";
+    readonly field: string;
+    readonly newDefinition: FieldDefinition;
+};
+type ConnectionState = "disconnected" | "connecting" | "connected" | "error";
+interface DatabaseAdapter<TConfig = object> extends QueryRunner, SchemaOperations {
+    readonly name: string;
+    readonly config: TConfig;
+    connect(schemas: ISchemaRegistry): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    getConnectionState(): ConnectionState;
+    beginTransaction(): Promise<Transaction>;
+    getTables(): Promise<readonly string[]>;
+    getTableSchema(tableName: string): Promise<SchemaDefinition | null>;
+    tableExists(tableName: string): Promise<boolean>;
+    exportData(writer: ExportWriter): Promise<void>;
+    importData(reader: ImportReader): Promise<void>;
+}
+declare function isDatabaseAdapter(value: unknown): value is DatabaseAdapter<unknown>;
+type ParameterStyle = "numbered" | "question" | "named";
+type SqlDialect = "postgres" | "mysql" | "sqlite";
+interface QueryTranslator<T extends DatrixEntry = DatrixEntry> {
+    translate(query: QueryObject<T>): {
+        readonly sql: string;
+        readonly params: readonly unknown[];
+    };
+    translateWhere(where: WhereClause<T>, startIndex: number): {
+        readonly sql: string;
+        readonly params: readonly unknown[];
+    };
+    escapeIdentifier(identifier: string): string;
+    escapeValue(value: unknown): string;
+    getParameterPlaceholder(index: number): string;
+}
+
+interface DatrixConfig<TAdapter extends DatabaseAdapter = DatabaseAdapter> {
+    readonly adapter: TAdapter;
+    readonly schemas: readonly SchemaDefinition[];
+    readonly plugins?: readonly DatrixPlugin[];
+    readonly migration?: MigrationConfig;
+    readonly dev?: DevConfig;
+}
+interface MigrationConfig {
+    readonly auto?: boolean;
+    readonly directory?: string;
+    readonly modelName?: string;
+}
+interface DevConfig {
+    readonly logging?: boolean;
+    readonly validateQueries?: boolean;
+    readonly prettyErrors?: boolean;
+}
+type ConfigFileExport<T extends DatrixConfig = DatrixConfig> = T | {
+    default: T;
+};
+interface LoadConfigOptions {
+    readonly configPath?: string;
+    readonly environment?: "development" | "production" | "test";
+    readonly cwd?: string;
+}
+declare function isDatrixConfig(value: unknown): value is DatrixConfig;
+declare function hasDefaultExport<T>(value: unknown): value is {
+    default: T;
+};
+declare const DEFAULT_MIGRATION_CONFIG: Required<MigrationConfig>;
+declare const DEFAULT_DEV_CONFIG: Required<DevConfig>;
+
+interface RawCrudOptions<T extends DatrixEntry = DatrixRecord> {
+    select?: SelectClause<T> | undefined;
+    populate?: PopulateClause<T> | undefined;
+    noReturning?: boolean;
+    action?: QueryAction;
+}
+interface RawFindManyOptions<T extends DatrixEntry = DatrixRecord> extends RawCrudOptions<T> {
+    orderBy?: OrderByClause<T> | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+    where?: WhereClause<T> | undefined;
+}
+type FallbackScalar = string | number | boolean | Date | null | undefined | object;
+type FallbackInput = {
+    [key: string]: FallbackScalar | FallbackScalar[] | AnyRelationInput;
+};
+interface IRawCrud {
+    findOne<T extends DatrixEntry = DatrixRecord>(model: string, where: WhereClause<T>, options?: RawCrudOptions<T>): Promise<T | null>;
+    findById<T extends DatrixEntry = DatrixRecord>(model: string, id: number, options?: RawCrudOptions<T>): Promise<T | null>;
+    findMany<T extends DatrixEntry = DatrixRecord>(model: string, options?: RawFindManyOptions<T>): Promise<T[]>;
+    count<T extends DatrixEntry = DatrixRecord>(model: string, where?: WhereClause<T>): Promise<number>;
+    create<T extends DatrixEntry = DatrixRecord, TInput extends FallbackInput = FallbackInput>(model: string, data: TInput, options?: RawCrudOptions<T>): Promise<T>;
+    createMany<T extends DatrixEntry = DatrixRecord, TInput extends FallbackInput = FallbackInput>(model: string, data: TInput[], options?: RawCrudOptions<T>): Promise<T[]>;
+    update<T extends DatrixEntry = DatrixRecord, TInput extends FallbackInput = FallbackInput>(model: string, id: number, data: TInput, options?: RawCrudOptions<T>): Promise<T>;
+    updateMany<T extends DatrixEntry = DatrixRecord, TInput extends FallbackInput = FallbackInput>(model: string, where: WhereClause<T>, data: TInput, options?: RawCrudOptions<T>): Promise<T[]>;
+    delete<T extends DatrixEntry = DatrixRecord>(model: string, id: number, options?: RawCrudOptions<T>): Promise<T>;
+    deleteMany<T extends DatrixEntry = DatrixRecord>(model: string, where: WhereClause<T>, options?: RawCrudOptions<T>): Promise<T[]>;
+}
+interface IDatrix extends IRawCrud {
+    shutdown(): Promise<void>;
+    getConfig(): DatrixConfig;
+    getAdapter<T extends DatabaseAdapter = DatabaseAdapter>(): T;
+    getPlugins(): readonly DatrixPlugin[];
+    getPlugin<T extends DatrixPlugin = DatrixPlugin>(name: string): T | null;
+    hasPlugin(name: string): boolean;
+    getSchemas(): ISchemaRegistry;
+    getSchema(name: string): SchemaDefinition | undefined;
+    getMigrationConfig(): Required<MigrationConfig>;
+    getDevConfig(): Required<DevConfig>;
+    isInitialized(): boolean;
+    readonly raw: IRawCrud;
+}
+
+type QueryAction = "findOne" | "findMany" | "count" | "create" | "createMany" | "update" | "updateMany" | "delete" | "deleteMany";
+interface QueryContext {
+    readonly action: QueryAction;
+    readonly datrix: IDatrix;
+    readonly metadata: Record<string, unknown>;
+    user?: AuthUser | undefined;
+}
+
+interface DatrixEntry {
+    readonly id: number;
+    createdAt: Date;
+    updatedAt: Date;
+}
+type FallbackValue = {
+    [key: string]: string | number | boolean | Date | null | FallbackValue | FallbackValue[];
+};
+type DatrixRecord = DatrixEntry & FallbackValue;
+
+interface LifecycleHooks<T extends DatrixEntry = DatrixEntry> {
+    readonly beforeCreate?: (query: QueryInsertObject<T>, ctx: QueryContext) => Promise<QueryInsertObject<T>> | QueryInsertObject<T>;
+    readonly afterCreate?: (records: T[], ctx: QueryContext) => Promise<T[]> | T[];
+    readonly beforeUpdate?: (query: QueryUpdateObject<T>, ctx: QueryContext) => Promise<QueryUpdateObject<T>> | QueryUpdateObject<T>;
+    readonly afterUpdate?: (records: T[], ctx: QueryContext) => Promise<T[]> | T[];
+    readonly beforeDelete?: (query: QueryDeleteObject<T>, ctx: QueryContext) => Promise<QueryDeleteObject<T>> | QueryDeleteObject<T>;
+    readonly afterDelete?: (records: T[], ctx: QueryContext) => Promise<void> | void;
+    readonly beforeFind?: (query: QuerySelectObject<T>, ctx: QueryContext) => Promise<QuerySelectObject<T>> | QuerySelectObject<T>;
+    readonly afterFind?: (records: T[], ctx: QueryContext) => Promise<T[]> | T[];
+}
+
+declare const MAX_FIELD_NAME_LENGTH = 63;
+declare const MAX_WHERE_VALUE_LENGTH = 10000;
+declare const MAX_LOGICAL_NESTING_DEPTH = 10;
+declare const MAX_ARRAY_INDEX = 1000;
+declare const COMPARISON_OPERATORS: readonly ["$eq", "$ne", "$gt", "$gte", "$lt", "$lte"];
+declare const STRING_OPERATORS: readonly ["$contains", "$notContains", "$startsWith", "$endsWith", "$like", "$ilike"];
+declare const ARRAY_OPERATORS: readonly ["$in", "$nin"];
+declare const NULL_OPERATORS: readonly ["$null", "$notNull"];
+declare const LOGICAL_OPERATORS: readonly ["$and", "$or", "$not"];
+declare const ALL_WHERE_OPERATORS: readonly ["$eq", "$ne", "$gt", "$gte", "$lt", "$lte", "$contains", "$notContains", "$startsWith", "$endsWith", "$like", "$ilike", "$in", "$nin", "$null", "$notNull", "$and", "$or", "$not"];
+type OperatorValueType = "any" | "array" | "number" | "string" | "boolean" | "conditions";
+declare const OPERATOR_VALUE_TYPES: Record<string, OperatorValueType>;
+declare function isValidWhereOperator(operator: string): operator is (typeof ALL_WHERE_OPERATORS)[number];
+declare function isLogicalOperator(operator: string): operator is (typeof LOGICAL_OPERATORS)[number];
+declare function requiresArrayValue(operator: string): boolean;
+declare function requiresConditions(operator: string): boolean;
+declare function getOperatorValueType(operator: string): OperatorValueType | undefined;
+declare const FORJA_META_MODEL = "_datrix";
+declare const FORJA_META_KEY_PREFIX = "_schema_";
+declare const FIELD_NAME_PATTERN: RegExp;
+declare const CONTROL_CHARS_PATTERN: RegExp;
+declare const RESERVED_FIELD_NAMES: readonly ["__proto__", "constructor", "prototype"];
+type FieldInvalidReason = "EMPTY" | "TOO_LONG" | "RESERVED_FIELD" | "CONTROL_CHARS" | "INVALID_FORMAT";
+type FieldValidationResult = {
+    valid: true;
+} | {
+    valid: false;
+    reason: FieldInvalidReason;
+    detail?: string;
+};
+declare function validateFieldName(fieldName: string): FieldValidationResult;
+declare function isValidFieldName(fieldName: string): boolean;
+
+type MigrationStatus = "pending" | "running" | "completed" | "failed";
+interface MigrationMetadata {
+    readonly name: string;
+    readonly version: string;
+    readonly timestamp: number;
+    readonly description?: string;
+    readonly author?: string;
+}
+interface MigrationContext {
+    readonly version: string;
+    readonly dryRun?: boolean;
+}
+type MigrationOperationType = "createTable" | "dropTable" | "alterTable" | "createIndex" | "dropIndex" | "renameTable" | "raw" | "dataTransfer";
+interface BaseMigrationOperation {
+    readonly type: MigrationOperationType;
+}
+interface CreateTableOperation extends BaseMigrationOperation {
+    readonly type: "createTable";
+    readonly schema: SchemaDefinition;
+}
+interface DropTableOperation extends BaseMigrationOperation {
+    readonly type: "dropTable";
+    readonly tableName: string;
+}
+interface AlterTableOperation extends BaseMigrationOperation {
+    readonly type: "alterTable";
+    readonly tableName: string;
+    readonly operations: readonly AlterOperation[];
+}
+interface CreateIndexOperation extends BaseMigrationOperation {
+    readonly type: "createIndex";
+    readonly tableName: string;
+    readonly index: IndexDefinition;
+}
+interface DropIndexOperation extends BaseMigrationOperation {
+    readonly type: "dropIndex";
+    readonly tableName: string;
+    readonly indexName: string;
+}
+interface RenameTableOperation extends BaseMigrationOperation {
+    readonly type: "renameTable";
+    readonly from: string;
+    readonly to: string;
+}
+interface RawSQLOperation extends BaseMigrationOperation {
+    readonly type: "raw";
+    readonly sql: string;
+    readonly params?: readonly unknown[];
+}
+interface DataTransferOperation extends BaseMigrationOperation {
+    readonly type: "dataTransfer";
+    readonly description: string;
+    readonly execute: (runner: QueryRunner) => Promise<void>;
+}
+type MigrationOperation = CreateTableOperation | DropTableOperation | AlterTableOperation | CreateIndexOperation | DropIndexOperation | RenameTableOperation | RawSQLOperation | DataTransferOperation;
+interface Migration {
+    readonly metadata: MigrationMetadata;
+    readonly operations: readonly MigrationOperation[];
+}
+type SchemaDiffType = "tableAdded" | "tableRemoved" | "tableRenamed" | "fieldAdded" | "fieldRemoved" | "fieldModified" | "fieldRenamed" | "indexAdded" | "indexRemoved";
+interface BaseSchemaDiff {
+    readonly type: SchemaDiffType;
+}
+interface TableAddedDiff extends BaseSchemaDiff {
+    readonly type: "tableAdded";
+    readonly schema: SchemaDefinition;
+}
+interface TableRemovedDiff extends BaseSchemaDiff {
+    readonly type: "tableRemoved";
+    readonly tableName: string;
+}
+interface TableRenamedDiff extends BaseSchemaDiff {
+    readonly type: "tableRenamed";
+    readonly from: string;
+    readonly to: string;
+}
+interface FieldAddedDiff extends BaseSchemaDiff {
+    readonly type: "fieldAdded";
+    readonly tableName: string;
+    readonly fieldName: string;
+    readonly definition: FieldDefinition;
+}
+interface FieldRemovedDiff extends BaseSchemaDiff {
+    readonly type: "fieldRemoved";
+    readonly tableName: string;
+    readonly fieldName: string;
+    readonly definition: FieldDefinition;
+}
+interface FieldModifiedDiff extends BaseSchemaDiff {
+    readonly type: "fieldModified";
+    readonly tableName: string;
+    readonly fieldName: string;
+    readonly oldDefinition: FieldDefinition;
+    readonly newDefinition: FieldDefinition;
+}
+interface FieldRenamedDiff extends BaseSchemaDiff {
+    readonly type: "fieldRenamed";
+    readonly tableName: string;
+    readonly from: string;
+    readonly to: string;
+}
+interface IndexAddedDiff extends BaseSchemaDiff {
+    readonly type: "indexAdded";
+    readonly tableName: string;
+    readonly index: IndexDefinition;
+}
+interface IndexRemovedDiff extends BaseSchemaDiff {
+    readonly type: "indexRemoved";
+    readonly tableName: string;
+    readonly indexName: string;
+}
+type SchemaDiff = TableAddedDiff | TableRemovedDiff | TableRenamedDiff | FieldAddedDiff | FieldRemovedDiff | FieldModifiedDiff | FieldRenamedDiff | IndexAddedDiff | IndexRemovedDiff;
+interface SchemaComparison {
+    readonly differences: readonly SchemaDiff[];
+    readonly hasChanges: boolean;
+}
+interface MigrationHistoryRecord {
+    readonly id: number;
+    readonly name: string;
+    readonly version: string;
+    readonly appliedAt: Date;
+    readonly executionTime: number;
+    readonly status: MigrationStatus;
+    readonly checksum?: string;
+    readonly error?: string;
+}
+interface MigrationExecutionResult {
+    readonly migration: Migration;
+    readonly status: MigrationStatus;
+    readonly executionTime: number;
+    readonly error?: Error;
+    readonly warnings?: readonly string[];
+}
+interface MigrationFilePlan {
+    readonly migrations: readonly Migration[];
+    readonly target?: string;
+}
+declare class MigrationSystemError extends Error {
+    readonly code: "MIGRATION_ERROR" | "DIFF_ERROR" | "GENERATION_ERROR" | "VALIDATION_ERROR";
+    readonly details?: unknown | undefined;
+    constructor(message: string, code: "MIGRATION_ERROR" | "DIFF_ERROR" | "GENERATION_ERROR" | "VALIDATION_ERROR", details?: unknown | undefined);
+}
+interface SchemaDiffer {
+    compare(oldSchema: Record<string, SchemaDefinition>, newSchema: Record<string, SchemaDefinition>): SchemaComparison;
+    isFieldModified(oldField: FieldDefinition, newField: FieldDefinition): boolean;
+}
+interface MigrationGenerator {
+    generate(differences: readonly SchemaDiff[], metadata: Omit<MigrationMetadata, "timestamp">): Migration;
+    generateOperations(differences: readonly SchemaDiff[]): readonly MigrationOperation[];
+    generateFile(migration: Migration): string;
+}
+interface MigrationRunner {
+    getPending(): Promise<readonly Migration[]>;
+    getApplied(): Promise<readonly MigrationHistoryRecord[]>;
+    runPending(options?: {
+        readonly target?: string;
+        readonly dryRun?: boolean;
+    }): Promise<readonly MigrationExecutionResult[]>;
+    runOne(migration: Migration): Promise<MigrationExecutionResult>;
+    getPlan(options?: {
+        readonly target?: string;
+    }): MigrationFilePlan;
+}
+interface MigrationHistory {
+    initialize(): Promise<void>;
+    record(migration: Migration, executionTime: number, status: MigrationStatus, error?: Error): Promise<void>;
+    getAll(): Promise<readonly MigrationHistoryRecord[]>;
+    getLast(): Promise<MigrationHistoryRecord | undefined>;
+    isApplied(version: string): Promise<boolean>;
+    calculateChecksum(migration: Migration): string;
+    verifyChecksum(migration: Migration, record: MigrationHistoryRecord): boolean;
+}
+
+interface IApiPlugin<TRole extends string = string> extends DatrixPlugin {
+    readonly name: string;
+    readonly version: string;
+    readonly authManager?: IAuthManager | undefined;
+    readonly upload?: IUpload | undefined;
+    readonly user: AuthUser | null;
+    readonly datrix: IDatrix;
+    readonly authDefaultPermission: DefaultPermission<TRole> | undefined;
+    readonly authDefaultRole: TRole | undefined;
+    readonly excludeSchemas: readonly string[];
+    isEnabled(): boolean;
+    isAuthEnabled(): boolean;
+    setUser(user: AuthUser | null): void;
+    getAuthManager(): IAuthManager | undefined;
+    handleRequest(request: Request, datrix: IDatrix): Promise<Response>;
+}
+
+declare const DEFAULT_API_CONFIG: {
+    readonly enabled: true;
+    readonly prefix: "/api";
+    readonly defaultPageSize: 25;
+    readonly maxPageSize: 100;
+    readonly maxPopulateDepth: 5;
+    readonly autoRoutes: true;
+    readonly excludeSchemas: readonly [];
+};
+declare const DEFAULT_API_AUTH_CONFIG: {
+    readonly enabled: true;
+    readonly userSchema: {
+        readonly name: "user";
+        readonly email: "email";
+    };
+    readonly jwt: {
+        readonly expiresIn: "7d";
+        readonly algorithm: "HS256";
+    };
+    readonly session: {
+        readonly store: "memory";
+        readonly maxAge: 86400;
+        readonly checkPeriod: 3600;
+        readonly prefix: "datrix:session:";
+    };
+    readonly password: {
+        readonly iterations: 100000;
+        readonly keyLength: 64;
+        readonly minLength: 8;
+    };
+    readonly endpoints: {
+        readonly login: "/auth/login";
+        readonly register: "/auth/register";
+        readonly logout: "/auth/logout";
+        readonly me: "/auth/me";
+        readonly disableRegister: false;
+    };
+};
+
+type ResponseData<T = unknown> = {
+    data: T;
+    meta: {
+        total: number;
+        page: number;
+        pageSize: number;
+        totalPages: number;
+    };
+};
+
+type PermissionAction = "create" | "read" | "update" | "delete";
+type FieldPermissionAction = "read" | "write";
+interface PermissionContext<TRecord extends DatrixEntry = DatrixEntry> {
+    readonly user: AuthUser | undefined;
+    readonly record?: TRecord;
+    readonly input?: Partial<TRecord>;
+    readonly action: PermissionAction;
+    readonly id?: number | string | null;
+    readonly datrix: unknown;
+}
+type PermissionFn<TRecord extends DatrixEntry = DatrixEntry> = (ctx: PermissionContext<TRecord>) => boolean | Promise<boolean>;
+type PermissionValue<TRoles extends string = string, TRecord extends DatrixEntry = DatrixEntry> = boolean | readonly TRoles[] | PermissionFn<TRecord> | readonly (TRoles | PermissionFn<TRecord>)[];
+interface SchemaPermission<TRoles extends string = string, TRecord extends DatrixEntry = DatrixEntry> {
+    readonly create?: PermissionValue<TRoles, TRecord>;
+    readonly read?: PermissionValue<TRoles, TRecord>;
+    readonly update?: PermissionValue<TRoles, TRecord>;
+    readonly delete?: PermissionValue<TRoles, TRecord>;
+}
+interface FieldPermission<TRoles extends string = string, TRecord extends DatrixEntry = DatrixEntry> {
+    readonly read?: PermissionValue<TRoles, TRecord>;
+    readonly write?: PermissionValue<TRoles, TRecord>;
+}
+interface DefaultPermission<TRoles extends string = string> {
+    readonly create?: PermissionValue<TRoles>;
+    readonly read?: PermissionValue<TRoles>;
+    readonly update?: PermissionValue<TRoles>;
+    readonly delete?: PermissionValue<TRoles>;
+}
+interface PermissionCheckResult {
+    readonly allowed: boolean;
+    readonly reason?: string | undefined;
+}
+interface FieldPermissionCheckResult {
+    readonly allowed: boolean;
+    readonly deniedFields?: readonly string[] | undefined;
+}
+declare function isPermissionFn<TRecord extends DatrixEntry = DatrixEntry>(value: unknown): value is PermissionFn<TRecord>;
+
+declare const RESERVED_FIELDS: readonly ["id", "createdAt", "updatedAt"];
+type ReservedFieldName = (typeof RESERVED_FIELDS)[number];
+
+type FieldType = "string" | "number" | "boolean" | "date" | "json" | "enum" | "array" | "relation" | "file";
+interface BaseFieldDefinition<TRoles extends string = string> {
+    readonly required?: boolean;
+    readonly default?: unknown;
+    readonly description?: string;
+    readonly hidden?: boolean;
+    readonly permission?: FieldPermission<TRoles>;
+}
+interface StringField<TRoles extends string = string> extends BaseFieldDefinition<TRoles> {
+    readonly type: "string";
+    readonly minLength?: number;
+    readonly maxLength?: number;
+    readonly pattern?: RegExp;
+    readonly unique?: boolean;
+    readonly validator?: (value: string) => true | string;
+    readonly errorMessage?: string;
+}
+interface ForeignKeyReference {
+    readonly table: string;
+    readonly column?: string;
+    readonly onDelete?: "cascade" | "setNull" | "restrict" | undefined;
+    readonly onUpdate?: "cascade" | "restrict" | undefined;
+}
+interface NumberField<TRoles extends string = string> extends BaseFieldDefinition<TRoles> {
+    readonly type: "number";
+    readonly min?: number;
+    readonly max?: number;
+    readonly integer?: boolean;
+    readonly unique?: boolean;
+    readonly autoIncrement?: boolean;
+    readonly validator?: (value: number) => true | string;
+    readonly references?: ForeignKeyReference;
+}
+interface BooleanField<TRoles extends string = string> extends BaseFieldDefinition<TRoles> {
+    readonly type: "boolean";
+}
+interface DateField<TRoles extends string = string> extends BaseFieldDefinition<TRoles> {
+    readonly type: "date";
+    readonly min?: Date;
+    readonly max?: Date;
+}
+interface JsonField<TRoles extends string = string> extends BaseFieldDefinition<TRoles> {
+    readonly type: "json";
+    readonly schema?: Record<string, unknown>;
+}
+interface EnumField<T extends readonly string[] = readonly string[], TRoles extends string = string> extends BaseFieldDefinition<TRoles> {
+    readonly type: "enum";
+    readonly values: T;
+}
+interface ArrayField<TRoles extends string = string> extends BaseFieldDefinition<TRoles> {
+    readonly type: "array";
+    readonly items: FieldDefinition<TRoles>;
+    readonly minItems?: number;
+    readonly maxItems?: number;
+    readonly unique?: boolean;
+}
+type RelationKind = "hasOne" | "hasMany" | "belongsTo" | "manyToMany";
+interface FileFieldOptions {
+    readonly allowedTypes?: readonly string[];
+    readonly maxSize?: number;
+}
+interface RelationField<TRoles extends string = string> extends BaseFieldDefinition<TRoles> {
+    readonly type: "relation";
+    readonly model: string;
+    readonly kind: RelationKind;
+    readonly foreignKey?: string;
+    readonly through?: string;
+    readonly onDelete?: "cascade" | "setNull" | "restrict";
+    readonly onUpdate?: "cascade" | "restrict";
+    readonly fileOptions?: FileFieldOptions;
+}
+type RelationIdRef = number | {
+    id: number;
+};
+type RelationIdRefs = RelationIdRef | RelationIdRef[];
+type RelationBelongsTo<T extends DatrixEntry> = RelationIdRef | null | {
+    connect?: RelationIdRef;
+    set?: RelationIdRef;
+    disconnect?: true;
+    create?: Partial<T>;
+    update?: {
+        where: {
+            id: number;
+        };
+        data: Partial<T>;
+    };
+    delete?: RelationIdRef;
+};
+type RelationHasOne<T extends DatrixEntry> = RelationBelongsTo<T>;
+type RelationHasMany<T extends DatrixEntry> = RelationIdRefs | {
+    connect?: RelationIdRefs;
+    disconnect?: RelationIdRefs;
+    set?: RelationIdRefs;
+    create?: Partial<T> | Partial<T>[];
+    update?: {
+        where: {
+            id: number;
+        };
+        data: Partial<T>;
+    } | {
+        where: {
+            id: number;
+        };
+        data: Partial<T>;
+    }[];
+    delete?: RelationIdRefs;
+};
+type RelationManyToMany<T extends DatrixEntry> = RelationHasMany<T>;
+type RelationInput<T extends DatrixEntry> = RelationBelongsTo<T> | RelationHasMany<T>;
+type AnyRelationInput = RelationIdRefs | null | AnyRelationInputObject;
+type AnyRelationInputObject = {
+    connect?: RelationIdRefs;
+    disconnect?: RelationIdRefs | true;
+    set?: RelationIdRefs;
+    delete?: RelationIdRefs;
+    create?: Record<string, unknown> | Record<string, unknown>[];
+    update?: {
+        where: {
+            id: number;
+        };
+        data: Record<string, unknown>;
+    } | {
+        where: {
+            id: number;
+        };
+        data: Record<string, unknown>;
+    }[];
+};
+type NormalizedRelationId = {
+    id: string | number;
+};
+declare function normalizeRelationId(ref: RelationIdRef): NormalizedRelationId;
+declare function normalizeRelationIds(refs: RelationIdRefs): NormalizedRelationId[];
+declare function isRelationIdRef(value: unknown): value is RelationIdRef;
+declare function isRelationIdRefs(value: unknown): value is RelationIdRefs;
+interface FileField<TRoles extends string = string> extends BaseFieldDefinition<TRoles> {
+    readonly type: "file";
+    readonly allowedTypes?: readonly string[];
+    readonly maxSize?: number;
+    readonly multiple?: boolean;
+}
+type FieldDefinition<TRoles extends string = string> = StringField<TRoles> | NumberField<TRoles> | BooleanField<TRoles> | DateField<TRoles> | JsonField<TRoles> | EnumField<readonly string[], TRoles> | ArrayField<TRoles> | RelationField<TRoles> | FileField<TRoles>;
+interface IndexDefinition {
+    readonly name?: string;
+    readonly fields: readonly string[];
+    readonly unique?: boolean;
+    readonly type?: "btree" | "hash" | "gist" | "gin";
+}
+
+interface SchemaDefinition<TRoles extends string = string, TFields extends Record<string, FieldDefinition<TRoles>> = Record<string, FieldDefinition<TRoles>>> {
+    readonly name: string;
+    readonly fields: TFields;
+    readonly indexes?: readonly IndexDefinition[];
+    readonly hooks?: LifecycleHooks;
+    readonly timestamps?: boolean;
+    readonly softDelete?: boolean;
+    readonly tableName?: string;
+    readonly permission?: SchemaPermission<TRoles>;
+    readonly _isJunctionTable?: boolean;
+}
+declare function defineSchema<const T extends SchemaDefinition>(schema: T): T;
+interface ISchemaRegistry {
+    register(schema: SchemaDefinition): SchemaDefinition;
+    get(name: string): SchemaDefinition | undefined;
+    getWithTableName(modelName: string): {
+        schema: SchemaDefinition;
+        tableName: string;
+    } | undefined;
+    getByTableName(tableName: string): {
+        schema: SchemaDefinition;
+        tableName: string;
+    } | undefined;
+    has(name: string): boolean;
+    getAll(): readonly SchemaDefinition[];
+    getNames(): readonly string[];
+    readonly size: number;
+    findModelByTableName(tableName: string | null): string | null;
+    getRelatedSchemas(schemaName: string): readonly string[];
+    isLocked(): boolean;
+    getCachedSelectFields<T extends DatrixEntry>(modelName: string): QuerySelect<T>;
+}
+interface FieldMetadata {
+    readonly name: string;
+    readonly type: FieldType;
+    readonly required: boolean;
+    readonly unique: boolean;
+    readonly hasDefault: boolean;
+    readonly isRelation: boolean;
+    readonly isArray: boolean;
+}
+interface SchemaDefinitionValidationResult {
+    readonly valid: boolean;
+    readonly errors: readonly SchemaValidationError[];
+}
+interface SchemaValidationError {
+    readonly field?: string;
+    readonly message: string;
+    readonly code: string;
+}
+declare function validateSchemaDefinition(schema: SchemaDefinition): SchemaDefinitionValidationResult;
+declare function sortSchemasByDependency(schemas: SchemaDefinition[]): SchemaDefinition[];
+
+interface PluginContext {
+    readonly adapter: DatabaseAdapter;
+    readonly schemas: ISchemaRegistry;
+    readonly config: DatrixConfig;
+}
+interface DatrixPlugin<TOptions = Record<string, unknown>> {
+    readonly name: string;
+    readonly version: string;
+    readonly options: TOptions;
+    init(context: PluginContext): Promise<void>;
+    destroy(): Promise<void>;
+    getSchemas?(): Promise<SchemaDefinition[]>;
+    extendSchemas?(context: SchemaExtensionContext): Promise<SchemaExtension[]>;
+    onSchemaLoad?(schemas: ISchemaRegistry): Promise<void>;
+    onCreateQueryContext?(context: QueryContext): Promise<QueryContext>;
+    onBeforeQuery?<T extends DatrixEntry>(query: QueryObject<T>, context: QueryContext): Promise<QueryObject<T>>;
+    onAfterQuery?<TResult extends DatrixEntry>(result: TResult, context: QueryContext): Promise<TResult>;
+}
+declare class PluginError extends Error {
+    readonly code: string;
+    readonly pluginName: string | undefined;
+    readonly details: unknown | undefined;
+    constructor(message: string, options?: {
+        code?: string;
+        pluginName?: string;
+        details?: unknown;
+    });
+}
+declare function isDatrixPlugin(value: unknown): value is DatrixPlugin;
+type PluginFactory<TOptions = Record<string, unknown>> = (options: TOptions) => DatrixPlugin<TOptions>;
+declare class UploadError extends PluginError {
+    constructor(message: string, details?: unknown);
+}
+declare class PluginRegistry {
+    private readonly plugins;
+    register(plugin: DatrixPlugin): void;
+    get(name: string): DatrixPlugin | undefined;
+    has(name: string): boolean;
+    getAll(): readonly DatrixPlugin[];
+    initAll(context: PluginContext): Promise<void>;
+    destroyAll(): Promise<void>;
+}
+interface SchemaExtension {
+    readonly targetSchema: string;
+    readonly fields?: Record<string, FieldDefinition>;
+    readonly removeFields?: readonly string[];
+    readonly modifyFields?: Record<string, Partial<FieldDefinition>>;
+    readonly indexes?: readonly IndexDefinition[];
+}
+type SchemaModifier = (schema: SchemaDefinition) => {
+    readonly fields?: Record<string, FieldDefinition>;
+    readonly indexes?: readonly IndexDefinition[];
+    readonly removeFields?: readonly string[];
+    readonly modifyFields?: Record<string, Partial<FieldDefinition>>;
+};
+interface SchemaPattern {
+    readonly names?: readonly string[];
+    readonly prefix?: string;
+    readonly suffix?: string;
+    readonly exclude?: readonly string[];
+    readonly custom?: (schema: SchemaDefinition) => boolean;
+}
+interface SchemaExtensionContext {
+    readonly schemas: ReadonlyArray<SchemaDefinition>;
+    extendAll(modifier: SchemaModifier): SchemaExtension[];
+    extendWhere(predicate: (schema: SchemaDefinition) => boolean, modifier: SchemaModifier): SchemaExtension[];
+    extendByPattern(pattern: SchemaPattern, modifier: SchemaModifier): SchemaExtension[];
+}
+
+declare class CLIError extends Error {
+    readonly code: "INVALID_COMMAND" | "MISSING_ARGUMENT" | "FILE_ERROR" | "CONFIG_ERROR" | "EXECUTION_ERROR";
+    readonly details?: unknown | undefined;
+    constructor(message: string, code: "INVALID_COMMAND" | "MISSING_ARGUMENT" | "FILE_ERROR" | "CONFIG_ERROR" | "EXECUTION_ERROR", details?: unknown | undefined);
+}
+interface ParsedArgs {
+    readonly command?: string | undefined;
+    readonly subcommand?: string | undefined;
+    readonly args: readonly string[];
+    readonly options: Record<string, string | boolean>;
+}
+interface BaseCommandOptions {
+    readonly config?: string | undefined;
+    readonly verbose?: boolean | undefined;
+}
+interface MigrateCommandOptions extends BaseCommandOptions {
+    readonly down?: boolean | undefined;
+    readonly to?: string | undefined;
+    readonly dryRun?: boolean | undefined;
+}
+interface GenerateCommandOptions extends BaseCommandOptions {
+    readonly output?: string | undefined;
+}
+interface DevCommandOptions extends BaseCommandOptions {
+    readonly watch?: boolean | undefined;
+}
+
+interface SchemaRegistryConfig {
+    readonly strict: boolean | undefined;
+    readonly allowOverwrite: boolean | undefined;
+    readonly validateRelations: boolean | undefined;
+}
+declare class SchemaRegistry implements ISchemaRegistry {
+    private readonly schemas;
+    private readonly config;
+    private locked;
+    private cache;
+    constructor(config?: SchemaRegistryConfig);
+    private invalidateCache;
+    register(schema: SchemaDefinition): SchemaDefinition;
+    registerMany(schemas: readonly SchemaDefinition[]): void;
+    finalizeRegistry(): void;
+    private sortByDependencies;
+    get(name: string): SchemaDefinition | undefined;
+    getWithTableName(modelName: string): {
+        schema: SchemaDefinition;
+        tableName: string;
+    } | undefined;
+    getByTableName(tableName: string): {
+        schema: SchemaDefinition;
+        tableName: string;
+    } | undefined;
+    has(name: string): boolean;
+    getAll(): readonly SchemaDefinition[];
+    getNames(): readonly string[];
+    get size(): number;
+    findModelByTableName(tableName: string | null): string | null;
+    getSchemasWithRelations(): readonly SchemaDefinition[];
+    getRelatedSchemas(schemaName: string): readonly string[];
+    getReferencingSchemas(schemaName: string): readonly string[];
+    findByFieldType(fieldType: string): readonly SchemaDefinition[];
+    getCachedSelectFields<T extends DatrixEntry>(modelName: string): QuerySelect<T>;
+    validateRelations(): void;
+    clear(): void;
+    remove(name: string): boolean;
+    lock(): void;
+    unlock(): void;
+    isLocked(): boolean;
+    private transformFileFields;
+    private processRelations;
+    private createJunctionTable;
+    private getJunctionTableName;
+    private pluralize;
+    toJSON(): Record<string, SchemaDefinition>;
+    fromJSON(data: Record<string, SchemaDefinition>): void;
+}
+
+declare class Dispatcher {
+    private readonly registry;
+    private readonly datrix;
+    constructor(registry: PluginRegistry, datrix: Datrix);
+    buildQueryContext(action: QueryAction): Promise<QueryContext>;
+    dispatchSchemaLoad(schemas: SchemaRegistry): Promise<void>;
+    executeQuery<TResult extends DatrixEntry, R extends DatrixEntry = DatrixEntry>(action: QueryAction, schema: SchemaDefinition, query: QueryObject<TResult>, executor: (query: QueryObject<TResult>) => Promise<R>): Promise<R>;
+    dispatchBeforeQuery<TResult extends DatrixEntry = DatrixRecord>(query: QueryObject<TResult>, schema: SchemaDefinition, context: QueryContext): Promise<QueryObject<TResult>>;
+    dispatchAfterQuery<TResult extends DatrixEntry>(result: TResult, schema: SchemaDefinition, context: QueryContext): Promise<TResult>;
+    private dispatchSchemaBeforeHook;
+    private dispatchSchemaAfterHook;
+}
+
+declare class CrudOperations implements IRawCrud {
+    private readonly schemas;
+    readonly getAdapter: () => DatabaseAdapter;
+    private readonly getDispatcher;
+    private readonly executor;
+    constructor(schemas: ISchemaRegistry, getAdapter: () => DatabaseAdapter, getDispatcher?: (() => Dispatcher) | null);
+    findOne<T extends DatrixEntry = DatrixEntry>(model: string, where: WhereClause<T>, options?: RawCrudOptions<T>): Promise<T | null>;
+    findById<T extends DatrixEntry = DatrixRecord>(model: string, id: number, options?: RawCrudOptions<T>): Promise<T | null>;
+    findMany<T extends DatrixEntry = DatrixRecord>(model: string, options?: RawFindManyOptions<T>): Promise<T[]>;
+    count<T extends DatrixEntry = DatrixRecord>(model: string, where?: WhereClause<T>): Promise<number>;
+    create<T extends DatrixEntry = DatrixRecord, TInput extends FallbackInput = FallbackInput>(model: string, data: TInput, options?: RawCrudOptions<T>): Promise<T>;
+    createMany<T extends DatrixEntry = DatrixRecord, TInput extends FallbackInput = FallbackInput>(model: string, data: TInput[], options?: RawCrudOptions<T>): Promise<T[]>;
+    update<T extends DatrixEntry = DatrixRecord, TInput extends FallbackInput = FallbackInput>(model: string, id: number, data: TInput, options?: RawCrudOptions<T>): Promise<T>;
+    updateMany<T extends DatrixEntry = DatrixRecord, TInput extends FallbackInput = FallbackInput>(model: string, where: WhereClause<T>, data: TInput, options?: RawCrudOptions<T>): Promise<T[]>;
+    delete<T extends DatrixEntry = DatrixRecord>(model: string, id: number, options?: RawCrudOptions<T>): Promise<T>;
+    deleteMany<T extends DatrixEntry = DatrixRecord>(model: string, where: WhereClause<T>, options?: RawCrudOptions<T>): Promise<T[]>;
+}
+
+type AmbiguousChangeType = "column_rename_or_replace" | "table_rename_or_replace" | "fk_column_drop" | "junction_table_drop" | "junction_table_rename_or_replace" | "relation_upgrade_single_to_many" | "relation_downgrade_many_to_single" | "fk_model_change" | "relation_direction_flip";
+type AmbiguousActionType = "rename" | "drop_and_add" | "confirm_drop" | "migrate_to_junction" | "migrate_first" | "fresh_start" | "keep_column" | "drop_and_recreate";
+interface AmbiguousChange {
+    readonly id: string;
+    readonly tableName: string;
+    readonly type: AmbiguousChangeType;
+    readonly removedName: string;
+    readonly addedName: string;
+    readonly removedDefinition?: FieldDefinition;
+    readonly addedDefinition?: FieldDefinition;
+    readonly possibleActions: readonly AmbiguousAction[];
+    readonly warning?: string;
+    readonly affectedRows?: number;
+    resolved: boolean;
+    resolvedAction?: AmbiguousAction;
+}
+interface AmbiguousAction {
+    readonly type: AmbiguousActionType;
+    readonly description: string;
+}
+interface MigrationPlan {
+    readonly tablesToCreate: readonly SchemaDefinition[];
+    readonly tablesToDrop: readonly string[];
+    readonly tablesToAlter: readonly {
+        readonly tableName: string;
+        readonly changes: readonly SchemaDiff[];
+    }[];
+    readonly operations: readonly MigrationOperation[];
+    readonly hasChanges: boolean;
+}
+declare class MigrationSession {
+    private readonly datrix;
+    private readonly adapter;
+    private readonly differ;
+    private readonly generator;
+    private readonly history;
+    private currentSchemas;
+    private databaseSchemas;
+    private differences;
+    private _ambiguous;
+    private initialized;
+    constructor(datrix: IDatrix);
+    initialize(): Promise<void>;
+    private detectAmbiguousChanges;
+    private detectRelationTypeChanges;
+    private detectJunctionTableDrops;
+    private detectJunctionTableRenames;
+    private detectFkColumnChanges;
+    private detectColumnRenames;
+    private detectTableRenames;
+    private detectFkModelChanges;
+    private detectRelationDirectionFlips;
+    private looksLikeJunctionTable;
+    private isJunctionTableFor;
+    private couldBeJunctionRename;
+    private singularize;
+    private pluralize;
+    private couldBeRename;
+    private couldBeTableRename;
+    get tablesToCreate(): readonly SchemaDefinition[];
+    get tablesToDrop(): readonly string[];
+    get tablesToAlter(): readonly {
+        tableName: string;
+        changes: readonly SchemaDiff[];
+    }[];
+    get ambiguous(): readonly AmbiguousChange[];
+    hasUnresolvedAmbiguous(): boolean;
+    resolveAmbiguous(id: string, action: AmbiguousActionType): void;
+    private applyResolution;
+    private applyColumnRename;
+    private applyTableRename;
+    hasChanges(): boolean;
+    getPlan(): MigrationPlan;
+    apply(): Promise<readonly MigrationExecutionResult[]>;
+    private injectDataTransferOperations;
+    preview(): Promise<readonly MigrationOperation[]>;
+}
+declare function createMigrationSession(datrix: IDatrix): Promise<MigrationSession>;
+
+interface DatrixInitOptions {
+    readonly skipConnection?: boolean;
+    readonly skipPlugins?: boolean;
+    readonly skipSchemas?: boolean;
+}
+type ConfigFactory = () => DatrixConfig;
+declare class Datrix implements IDatrix {
+    private config;
+    private adapter;
+    private pluginRegistry;
+    private dispatcher;
+    private _schemas;
+    private initialized;
+    private _crud;
+    private _rawCrud;
+    initializeWithConfig(config: DatrixConfig, options?: DatrixInitOptions): Promise<void>;
+    shutdown(): Promise<void>;
+    getConfig(): DatrixConfig;
+    getAdapter<T extends DatabaseAdapter = DatabaseAdapter>(): T;
+    getPlugins(): readonly DatrixPlugin[];
+    getPlugin<T extends DatrixPlugin = DatrixPlugin>(name: string): T | null;
+    hasPlugin(name: string): boolean;
+    getDispatcher(): Dispatcher;
+    getSchemas(): SchemaRegistry;
+    getMigrationConfig(): Required<MigrationConfig>;
+    getDevConfig(): Required<DevConfig>;
+    isInitialized(): boolean;
+    beginMigrate(): Promise<MigrationSession>;
+    get crud(): CrudOperations;
+    get raw(): CrudOperations;
+    findOne<T extends DatrixEntry = DatrixRecord>(model: string, where: WhereClause<T>, options?: RawCrudOptions<T>): Promise<T | null>;
+    findById<T extends DatrixEntry = DatrixRecord>(model: string, id: number, options?: RawCrudOptions<T>): Promise<T | null>;
+    findMany<T extends DatrixEntry = DatrixRecord>(model: string, options?: RawFindManyOptions<T>): Promise<T[]>;
+    count<T extends DatrixEntry = DatrixRecord>(model: string, where?: WhereClause<T>): Promise<number>;
+    create<T extends DatrixEntry = DatrixRecord, TInput extends FallbackInput = FallbackInput>(model: string, data: TInput, options?: RawCrudOptions<T>): Promise<T>;
+    createMany<T extends DatrixEntry = DatrixRecord, TInput extends FallbackInput = FallbackInput>(model: string, data: TInput[], options?: RawCrudOptions<T>): Promise<T[]>;
+    update<T extends DatrixEntry = DatrixRecord, TInput extends FallbackInput = FallbackInput>(model: string, id: number, data: TInput, options?: RawCrudOptions<T>): Promise<T>;
+    updateMany<T extends DatrixEntry = DatrixRecord, TInput extends FallbackInput = FallbackInput>(model: string, where: WhereClause<T>, data: TInput, options?: RawCrudOptions<T>): Promise<T[]>;
+    delete<T extends DatrixEntry = DatrixRecord>(model: string, id: number, options?: RawCrudOptions<T>): Promise<T>;
+    deleteMany<T extends DatrixEntry = DatrixRecord>(model: string, where: WhereClause<T>, options?: RawCrudOptions<T>): Promise<T[]>;
+    get schema(): SchemaRegistry;
+    getSchema(name: string): SchemaDefinition<string, Record<string, FieldDefinition<string>>> | undefined;
+    getAllSchemas(): readonly SchemaDefinition<string, Record<string, FieldDefinition<string>>>[];
+    hasSchema(name: string): boolean;
+    reset(): void;
+    private ensureInitialized;
+    private applySchemaExtensions;
+}
+declare function defineConfig(factory: ConfigFactory): () => Promise<Datrix>;
+
+type AuthStrategy = "jwt" | "session" | "password" | "permission";
+type AuthErrorCode = "AUTH_INVALID_CREDENTIALS" | "AUTH_USER_NOT_FOUND" | "AUTH_USER_EXISTS" | "AUTH_WEAK_PASSWORD" | "AUTH_TOKEN_EXPIRED" | "AUTH_TOKEN_INVALID" | "AUTH_SESSION_NOT_FOUND" | "AUTH_SESSION_EXPIRED" | "AUTH_SESSION_INVALID" | "AUTH_UNAUTHORIZED" | "AUTH_FORBIDDEN" | "AUTH_CONFIG_INVALID" | "JWT_SIGN_ERROR" | "JWT_VERIFY_ERROR" | "JWT_DECODE_ERROR" | "JWT_EXPIRED" | "JWT_INVALID_FORMAT" | "JWT_INVALID_HEADER" | "JWT_INVALID_PAYLOAD" | "JWT_INVALID_SIGNATURE" | "JWT_INVALID_IAT" | "JWT_INVALID_ISSUER" | "JWT_INVALID_AUDIENCE" | "SESSION_CREATE_ERROR" | "SESSION_DELETE_ERROR" | "SESSION_NOT_CONFIGURED" | "PASSWORD_HASH_ERROR" | "PASSWORD_VERIFY_ERROR" | "PASSWORD_TOO_SHORT" | "PASSWORD_TOO_LONG" | "PERMISSION_DENIED";
+interface AuthErrorContext {
+    readonly strategy?: AuthStrategy | undefined;
+    readonly userId?: string | undefined;
+    readonly role?: string | undefined;
+    readonly sessionId?: string | undefined;
+    readonly action?: string | undefined;
+    readonly resource?: string | undefined;
+    readonly field?: string | undefined;
+    readonly exp?: number | undefined;
+    readonly iat?: number | undefined;
+    readonly now?: number | undefined;
+    readonly minLength?: number | undefined;
+    readonly maxLength?: number | undefined;
+    readonly receivedType?: string | undefined;
+    readonly expectedType?: string | undefined;
+    readonly [key: string]: unknown;
+}
+interface DatrixAuthErrorOptions {
+    readonly code: AuthErrorCode;
+    readonly strategy?: AuthStrategy;
+    readonly context?: AuthErrorContext | undefined;
+    readonly cause?: Error | undefined;
+    readonly suggestion?: string | undefined;
+    readonly expected?: string | undefined;
+    readonly received?: unknown | undefined;
+}
+interface SerializedDatrixAuthError extends SerializedDatrixError {
+    readonly strategy?: AuthStrategy;
+}
+declare class DatrixAuthError extends DatrixError<AuthErrorContext> {
+    readonly strategy?: AuthStrategy | undefined;
+    constructor(message: string, options: DatrixAuthErrorOptions);
+    toJSON(): SerializedDatrixAuthError;
+    toDetailedMessage(): string;
+}
+
+type ConfigErrorCode = "CONFIG_NOT_FOUND" | "CONFIG_INVALID_TYPE" | "CONFIG_REQUIRED_FIELD" | "CONFIG_INVALID_VALUE" | "CONFIG_EMPTY_VALUE" | "CONFIG_VALIDATION_FAILED" | "CONFIG_MULTIPLE_ERRORS";
+interface ConfigErrorContext {
+    readonly field?: string;
+    readonly validOptions?: readonly string[];
+    readonly receivedType?: string;
+    readonly expectedType?: string;
+    readonly index?: number;
+    readonly configPath?: string;
+    readonly [key: string]: unknown;
+}
+interface DatrixConfigErrorOptions {
+    readonly code: ConfigErrorCode;
+    readonly field?: string | undefined;
+    readonly context?: ConfigErrorContext | undefined;
+    readonly cause?: Error | undefined;
+    readonly suggestion?: string | undefined;
+    readonly expected?: string | undefined;
+    readonly received?: unknown | undefined;
+}
+interface SerializedDatrixConfigError extends SerializedDatrixError {
+    readonly field?: string;
+}
+declare class DatrixConfigError extends DatrixError<ConfigErrorContext> {
+    readonly field?: string | undefined;
+    constructor(message: string, options: DatrixConfigErrorOptions);
+    toJSON(): SerializedDatrixConfigError;
+    toDetailedMessage(): string;
+}
+declare class DatrixConfigValidationError extends DatrixConfigError {
+    readonly errors: readonly string[];
+    constructor(errors: readonly string[], suggestion?: string);
+    toDetailedMessage(): string;
+}
+
+type CrudOperation = "findOne" | "findById" | "findMany" | "count" | "create" | "update" | "updateMany" | "delete" | "deleteMany";
+type CrudErrorCode = "QUERY_EXECUTION_FAILED" | "SCHEMA_NOT_FOUND" | "RECORD_NOT_FOUND" | "INVALID_POPULATE_VALUE" | "RESERVED_FIELD_WRITE" | "NOT_IMPLEMENTED" | "QUERY_FAILED";
+interface CrudErrorContext {
+    readonly model?: string;
+    readonly query?: Record<string, unknown>;
+    readonly recordId?: string | number;
+    readonly where?: Record<string, unknown>;
+    readonly adapterError?: string;
+    readonly [key: string]: unknown;
+}
+interface DatrixCrudErrorOptions {
+    readonly code: CrudErrorCode;
+    readonly operation: CrudOperation;
+    readonly model: string;
+    readonly context?: CrudErrorContext | undefined;
+    readonly cause?: Error | undefined;
+    readonly suggestion?: string | undefined;
+    readonly expected?: string | undefined;
+    readonly received?: unknown | undefined;
+}
+interface SerializedDatrixCrudError extends SerializedDatrixError {
+    readonly operation: CrudOperation;
+    readonly model: string;
+}
+declare class DatrixCrudError extends DatrixError<CrudErrorContext> {
+    readonly operation: CrudOperation;
+    readonly model: string;
+    constructor(message: string, options: DatrixCrudErrorOptions);
+    toJSON(): SerializedDatrixCrudError;
+    toDetailedMessage(): string;
+}
+
+type QueryBuilderComponent = "builder" | "where" | "select" | "populate" | "data" | "pagination";
+type QueryBuilderErrorCode = "INVALID_QUERY_TYPE" | "MISSING_TABLE" | "INVALID_FIELD" | "INVALID_OPERATOR" | "INVALID_VALUE" | "MAX_DEPTH_EXCEEDED" | "EMPTY_CLAUSE" | "DUPLICATE_FIELD" | "COERCION_FAILED" | "DELETE_WITHOUT_WHERE" | "MISSING_DATA" | "RELATION_IN_SELECT" | "SCHEMA_NOT_FOUND" | "UNKNOWN_FIELD";
+interface QueryBuilderErrorContext {
+    readonly field?: string | undefined;
+    readonly operator?: string | undefined;
+    readonly value?: unknown | undefined;
+    readonly availableFields?: readonly string[] | undefined;
+    readonly validOperators?: readonly string[] | undefined;
+    readonly depth?: number | undefined;
+    readonly maxDepth?: number | undefined;
+    readonly [key: string]: unknown;
+}
+interface DatrixQueryBuilderErrorOptions {
+    readonly code: QueryBuilderErrorCode;
+    readonly component: QueryBuilderComponent;
+    readonly field?: string | undefined;
+    readonly context?: QueryBuilderErrorContext | undefined;
+    readonly cause?: Error | undefined;
+    readonly suggestion?: string | undefined;
+    readonly expected?: string | undefined;
+    readonly received?: unknown | undefined;
+}
+interface SerializedDatrixQueryBuilderError extends SerializedDatrixError {
+    readonly component: QueryBuilderComponent;
+    readonly field?: string;
+}
+declare class DatrixQueryBuilderError extends DatrixError<QueryBuilderErrorContext> {
+    readonly component: QueryBuilderComponent;
+    readonly field?: string | undefined;
+    constructor(message: string, options?: DatrixQueryBuilderErrorOptions | string);
+    toJSON(): SerializedDatrixQueryBuilderError;
+    toDetailedMessage(): string;
+}
+
+type ValidationErrorCode = "REQUIRED" | "TYPE_MISMATCH" | "MIN_LENGTH" | "MAX_LENGTH" | "MIN_VALUE" | "MAX_VALUE" | "MIN_ITEMS" | "MAX_ITEMS" | "PATTERN" | "UNIQUE" | "INVALID_ENUM" | "INVALID_FORMAT" | "INVALID_DATE" | "CUSTOM" | "UNKNOWN";
+interface ValidationError {
+    readonly field: string;
+    readonly message: string;
+    readonly code: ValidationErrorCode;
+    readonly value?: unknown;
+    readonly expected?: unknown;
+}
+
+interface DatrixValidationErrorOptions extends Partial<DatrixErrorOptions> {
+    readonly model: string;
+    readonly errors: readonly ValidationError[];
+}
+interface SerializedDatrixValidationError extends SerializedDatrixError {
+    readonly model: string;
+    readonly errors: readonly ValidationError[];
+}
+declare class DatrixValidationError extends DatrixError {
+    readonly model: string;
+    readonly errors: readonly ValidationError[];
+    constructor(message: string, options: DatrixValidationErrorOptions);
+    toJSON(): SerializedDatrixValidationError;
+    toDetailedMessage(): string;
+}
+
+declare function validateQueryObject<T extends DatrixEntry>(query: unknown): void;
+
+declare abstract class BasePlugin<TOptions = Record<string, unknown>> implements DatrixPlugin<TOptions> {
+    abstract readonly name: string;
+    abstract readonly version: string;
+    readonly options: TOptions;
+    protected context: PluginContext | undefined;
+    constructor(options: TOptions);
+    abstract init(context: PluginContext): Promise<void>;
+    abstract destroy(): Promise<void>;
+    getSchemas(): Promise<SchemaDefinition[]>;
+    extendSchemas(_context: SchemaExtensionContext): Promise<SchemaExtension[]>;
+    onSchemaLoad(_schemas: ISchemaRegistry): Promise<void>;
+    onBeforeQuery<T extends DatrixEntry>(query: QueryObject<T>, _context: QueryContext): Promise<QueryObject<T>>;
+    onAfterQuery<TResult extends DatrixEntry>(result: TResult, _context: QueryContext): Promise<TResult>;
+    onCreateQueryContext(context: QueryContext): Promise<QueryContext>;
+    protected validateOptions(validator: (options: unknown) => options is TOptions, errorMessage: string): TOptions;
+    protected isInitialized(): this is this & {
+        context: PluginContext;
+    };
+    protected getContext(): PluginContext;
+    protected createError(message: string, code: string, details?: unknown): PluginError;
+}
+
+declare const DEFAULT_MIGRATION_MODEL = "_datrix_migration";
+declare function getMigrationSchema(modelName?: string): {
+    readonly name: string;
+    readonly fields: {
+        readonly name: {
+            readonly type: "string";
+            readonly required: true;
+            readonly maxLength: 255;
+            readonly description: "Migration name";
+        };
+        readonly version: {
+            readonly type: "string";
+            readonly required: true;
+            readonly unique: true;
+            readonly maxLength: 255;
+            readonly description: "Migration version (timestamp-based)";
+        };
+        readonly executionTime: {
+            readonly type: "number";
+            readonly required: true;
+            readonly min: 0;
+            readonly description: "Execution time in milliseconds";
+        };
+        readonly status: {
+            readonly type: "enum";
+            readonly required: true;
+            readonly values: readonly ["pending", "completed", "failed", "rolled_back"];
+            readonly description: "Migration execution status";
+        };
+        readonly checksum: {
+            readonly type: "string";
+            readonly maxLength: 64;
+            readonly description: "SHA-256 checksum of migration content";
+        };
+        readonly error: {
+            readonly type: "string";
+            readonly description: "Error message if migration failed";
+        };
+        readonly appliedAt: {
+            readonly type: "date";
+            readonly required: true;
+            readonly description: "When the migration was applied";
+        };
+    };
+    readonly indexes: readonly [{
+        readonly fields: readonly ["version"];
+        readonly unique: true;
+    }, {
+        readonly fields: readonly ["status"];
+    }, {
+        readonly fields: readonly ["appliedAt"];
+    }];
+    readonly permission: {
+        readonly create: false;
+        readonly read: false;
+        readonly update: false;
+        readonly delete: false;
+    };
+};
+declare function getDatrixMetaSchema(): {
+    readonly name: "_datrix";
+    readonly tableName: "_datrix";
+    readonly fields: {
+        readonly key: {
+            readonly type: "string";
+            readonly required: true;
+            readonly unique: true;
+            readonly maxLength: 255;
+            readonly description: "Table name";
+        };
+        readonly value: {
+            readonly type: "string";
+            readonly required: true;
+            readonly description: "Datrix SchemaDefinition as JSON string";
+        };
+    };
+    readonly permission: {
+        readonly create: false;
+        readonly read: false;
+        readonly update: false;
+        readonly delete: false;
+    };
+};
+
+export { ALL_WHERE_OPERATORS, ARRAY_OPERATORS, type AdapterErrorCode, type AdapterErrorContext, type AdapterName, type AdapterOperation, type AlterOperation, type AlterTableOperation, type AmbiguousAction, type AmbiguousActionType, type AmbiguousChange, type AmbiguousChangeType, type AnyRelationInput, type AnyRelationInputObject, type ArrayField, type AuthContext, type AuthErrorCode, type AuthErrorContext, type AuthStrategy, type AuthUser, type AuthenticatedUser, type BaseCommandOptions, type BaseErrorContext, type BaseMigrationOperation, BasePlugin, type BaseSchemaDiff, type BooleanField, CLIError, COMPARISON_OPERATORS, CONTROL_CHARS_PATTERN, type ComparisonOperators, type ConfigErrorCode, type ConfigErrorContext, type ConfigFactory, type ConfigFileExport, type ConnectionState, type CreateIndexOperation, type CreateTableOperation, type CrudErrorCode, type CrudErrorContext, type CrudOperation, DEFAULT_API_AUTH_CONFIG, DEFAULT_API_CONFIG, DEFAULT_DEV_CONFIG, DEFAULT_MIGRATION_CONFIG, DEFAULT_MIGRATION_MODEL, type DataTransferOperation, type DatabaseAdapter, type DateField, Datrix, DatrixAdapterError, type DatrixAdapterErrorOptions, DatrixAuthError, type DatrixAuthErrorOptions, type DatrixConfig, DatrixConfigError, type DatrixConfigErrorOptions, DatrixConfigValidationError, DatrixCrudError, type DatrixCrudErrorOptions, type DatrixEntry, DatrixError, type DatrixErrorOptions, type DatrixInitOptions, type DatrixPlugin, DatrixQueryBuilderError, type DatrixQueryBuilderErrorOptions, type DatrixRecord, DatrixValidationError, type DatrixValidationErrorOptions, type DefaultPermission, type DevCommandOptions, type DevConfig, type DropIndexOperation, type DropTableOperation, type EnumField, type ErrorLocation, type ExportMeta, type ExportWriter, FIELD_NAME_PATTERN, FORJA_META_KEY_PREFIX, FORJA_META_MODEL, type FallbackInput, type FallbackOrderByItem, type FallbackScalar, type FallbackValue, type FallbackWhereClause, type FieldAddedDiff, type FieldDefinition, type FieldInvalidReason, type FieldMetadata, type FieldModifiedDiff, type FieldPermission, type FieldPermissionAction, type FieldPermissionCheckResult, type FieldRemovedDiff, type FieldRenamedDiff, type FieldType, type FieldValidationResult, type FieldsErrorContext, type FileField, type FileFieldOptions, type ForeignKeyReference, type GenerateCommandOptions, type IApiPlugin, type IAuthManager, type IDatrix, type IRawCrud, type ISchemaRegistry, type IUpload, type ImportReader, type IndexAddedDiff, type IndexDefinition, type IndexRemovedDiff, type JsonField, LOGICAL_OPERATORS, type LifecycleHooks, type LoadConfigOptions, type LocalProviderOptions, type LogicalOperators, type LoginResult, MAX_ARRAY_INDEX, MAX_FIELD_NAME_LENGTH, MAX_LOGICAL_NESTING_DEPTH, MAX_WHERE_VALUE_LENGTH, type MediaEntry, type MediaVariant, type MediaVariants, type MigrateCommandOptions, type Migration, type MigrationConfig, type MigrationContext, type MigrationExecutionResult, type MigrationFilePlan, type MigrationGenerator, type MigrationHistory, type MigrationHistoryRecord, type MigrationMetadata, type MigrationOperation, type MigrationOperationType, type MigrationPlan, type MigrationRunner, MigrationSession, type MigrationStatus, MigrationSystemError, NULL_OPERATORS, type NormalizedNestedData, type NormalizedRelationId, type NormalizedRelationOperations, type NormalizedRelationUpdate, type NumberField, OPERATOR_VALUE_TYPES, type OperatorValueType, type OrderByClause, type OrderByItem, type OrderDirection, type PaginationErrorContext, type PaginationParams, type ParameterStyle, type ParsedArgs, type ParsedPagination, type ParsedQuery, type ParsedSort, ParserError, type ParserErrorCode, type ParserErrorContext, type ParserErrorOptions, type ParserOptions, type ParserType, type PermissionAction, type PermissionCheckResult, type PermissionContext, type PermissionFn, type PermissionValue, type PluginContext, PluginError, type PluginFactory, PluginRegistry, type PopulateClause, type PopulateErrorContext, type PopulateOptions, type QueryAction, type QueryBuilderComponent, type QueryBuilderErrorCode, type QueryBuilderErrorContext, type QueryContext, type QueryCountObject, type QueryDeleteObject, type QueryInsertObject, type QueryMetadata, type QueryObject, type QueryObjectForType, type QueryOrderBy, type QueryPopulate, type QueryPopulateOptions, type QueryPrimitive, type QueryRelations, type QueryResult, type QueryRunner, type QuerySelect, type QuerySelectObject, type QueryTranslator, type QueryType, type QueryUpdateObject, RESERVED_FIELDS, RESERVED_FIELD_NAMES, type RawCrudOptions, type RawFindManyOptions, type RawQueryParams, type RawSQLOperation, type RelationBelongsTo, type RelationField, type RelationHasMany, type RelationHasOne, type RelationIdRef, type RelationIdRefs, type RelationInput, type RelationKind, type RelationManyToMany, type RenameTableOperation, type ReservedFieldName, type ResponseData, type S3ProviderOptions, STRING_OPERATORS, type ScalarValue, type SchemaComparison, type SchemaDefinition, type SchemaDefinitionValidationResult, type SchemaDiff, type SchemaDiffType, type SchemaDiffer, type SchemaExtension, type SchemaExtensionContext, type SchemaModifier, type SchemaOperations, type SchemaPattern, type SchemaPermission, type SchemaValidationError, type SelectClause, type SerializedDatrixAdapterError, type SerializedDatrixAuthError, type SerializedDatrixConfigError, type SerializedDatrixCrudError, type SerializedDatrixError, type SerializedDatrixQueryBuilderError, type SerializedDatrixValidationError, type SerializedParserError, type SortErrorContext, type SortParam, type SqlDialect, type StorageProvider, type StringField, type TableAddedDiff, type TableRemovedDiff, type TableRenamedDiff, type Transaction, type UploadConfig, UploadError, type UploadFile, type UploadResult, WHERE_OPERATORS, type WhereClause, type WhereErrorContext, type WhereOperator, buildErrorLocation, createMigrationSession, defineConfig, defineSchema, generateUniqueFilename, getDatrixMetaSchema, getFileExtension, getMigrationSchema, getOperatorValueType, hasDefaultExport, isDatabaseAdapter, isDatrixConfig, isDatrixPlugin, isLogicalOperator, isPermissionFn, isRelationIdRef, isRelationIdRefs, isStorageProvider, isValidFieldName, isValidWhereOperator, isWhereOperator, normalizeRelationId, normalizeRelationIds, requiresArrayValue, requiresConditions, sanitizeFilename, sortSchemasByDependency, throwConnectionError, throwFileNotFound, throwFileReadError, throwFileWriteError, throwForeignKeyConstraint, throwIntrospectionError, throwInvalidPopulateOptions, throwInvalidRelationType, throwInvalidRelationWhereSyntax, throwInvalidWhereField, throwJoinBuildError, throwJsonAggregationError, throwJunctionTableNotFound, throwLateralJoinError, throwLockError, throwLockTimeout, throwMaxDepthExceeded, throwMetaFieldAlreadyExists, throwMetaFieldNotFound, throwMigrationError, throwModelNotFound, throwNotConnected, throwPopulateQueryError, throwQueryError, throwQueryMissingData, throwRawQueryNotSupported, throwRelationNotFound, throwResultProcessingError, throwSchemaNotFound, throwTargetModelNotFound, throwTransactionAlreadyCommitted, throwTransactionAlreadyRolledBack, throwTransactionError, throwTransactionSavepointNotSupported, throwUniqueConstraintField, throwUniqueConstraintIndex, truncateSqlForError, validateFieldName, validateQueryObject, validateSchemaDefinition };