ts-prorm-orm 1.1.0 → 1.2.0

package/dist/index.d.ts

@@ -0,0 +1,711 @@
+/**
+ * Main entry point for the TypeScript ORM
+ * Exports all public APIs: Prorm, DataTypes, Model, Transaction, Operators
+ */
+export { Prorm, QueryTypes, QueryOptions, SyncOptions } from './prorm';
+export { MapTransform, FilterTransform, BatchTransform, StreamIterator, MapTransformOptions, FilterTransformOptions, BatchTransformOptions, StreamIteratorOptions, } from './streams';
+export { ConnectionManager, createConnectionManager, NamedConnectionOptions } from './connection-manager';
+export { DataTypes, AbstractDataType } from './models/data-types';
+export { CreationOptional, NonAttribute, ForeignKey, InferAttributes, InferCreationAttributes, PartialBy, RequiredBy, ModelStatic, ModelOptions, } from './models/typescript-types';
+export { Model } from './models';
+export { Table, Attribute, Column, AllowNull, PrimaryKey, AutoIncrement, NotNull, Default, Unique, Comment, getModelMetadata, getAttributeMetadata, getModelAttributes, clearMetadata, HasOneOptions, HasManyOptions, BelongsToOptions, BelongsToManyOptions, HasOne, HasMany, BelongsTo, BelongsToMany, } from './models/decorators';
+export * from './compliance';
+export * from './extensions';
+export declare const STRING: ((...args: any[]) => import("./models").STRING) & {
+    toSql: () => string;
+    equals: (other: any) => boolean;
+    serialize: (value: unknown) => unknown;
+    key: string;
+};
+export declare const VARCHAR: ((...args: any[]) => import("./models").VARCHAR) & {
+    toSql: () => string;
+    equals: (other: any) => boolean;
+    serialize: (value: unknown) => unknown;
+    key: string;
+};
+export declare const CHAR: ((...args: any[]) => import("./models").CHAR) & {
+    toSql: () => string;
+    equals: (other: any) => boolean;
+    serialize: (value: unknown) => unknown;
+    key: string;
+};
+export declare const TEXT: ((...args: any[]) => import("./models").TEXT) & {
+    toSql: () => string;
+    equals: (other: any) => boolean;
+    serialize: (value: unknown) => unknown;
+    key: string;
+};
+export declare const INTEGER: ((...args: any[]) => import("./models").INTEGER) & {
+    toSql: () => string;
+    equals: (other: any) => boolean;
+    serialize: (value: unknown) => unknown;
+    key: string;
+};
+export declare const BIGINT: ((...args: any[]) => import("./models").BIGINT) & {
+    toSql: () => string;
+    equals: (other: any) => boolean;
+    serialize: (value: unknown) => unknown;
+    key: string;
+};
+export declare const FLOAT: ((...args: any[]) => import("./models").FLOAT) & {
+    toSql: () => string;
+    equals: (other: any) => boolean;
+    serialize: (value: unknown) => unknown;
+    key: string;
+};
+export declare const DOUBLE: ((...args: any[]) => import("./models").DOUBLE) & {
+    toSql: () => string;
+    equals: (other: any) => boolean;
+    serialize: (value: unknown) => unknown;
+    key: string;
+};
+export declare const DECIMAL: ((...args: any[]) => import("./models").DECIMAL) & {
+    toSql: () => string;
+    equals: (other: any) => boolean;
+    serialize: (value: unknown) => unknown;
+    key: string;
+};
+export declare const BOOLEAN: ((...args: any[]) => import("./models").BOOLEAN) & {
+    toSql: () => string;
+    equals: (other: any) => boolean;
+    serialize: (value: unknown) => unknown;
+    key: string;
+};
+export declare const DATE: ((...args: any[]) => import("./models").DATE) & {
+    toSql: () => string;
+    equals: (other: any) => boolean;
+    serialize: (value: unknown) => unknown;
+    key: string;
+};
+export declare const DATEONLY: ((...args: any[]) => import("./models").DATEONLY) & {
+    toSql: () => string;
+    equals: (other: any) => boolean;
+    serialize: (value: unknown) => unknown;
+    key: string;
+};
+export declare const NOW: ((...args: any[]) => import("./models").NOW) & {
+    toSql: () => string;
+    equals: (other: any) => boolean;
+    serialize: (value: unknown) => unknown;
+    key: string;
+};
+export declare const TIME: ((...args: any[]) => import("./models").TIME) & {
+    toSql: () => string;
+    equals: (other: any) => boolean;
+    serialize: (value: unknown) => unknown;
+    key: string;
+};
+export declare const UUID: ((...args: any[]) => import("./models").UUID) & {
+    toSql: () => string;
+    equals: (other: any) => boolean;
+    serialize: (value: unknown) => unknown;
+    key: string;
+};
+export declare const UUIDV4: ((...args: any[]) => import("./models").UUIDV4) & {
+    toSql: () => string;
+    equals: (other: any) => boolean;
+    serialize: (value: unknown) => unknown;
+    key: string;
+};
+export declare const JSON: ((...args: any[]) => import("./models").JSON) & {
+    toSql: () => string;
+    equals: (other: any) => boolean;
+    serialize: (value: unknown) => unknown;
+    key: string;
+};
+export declare const JSONB: ((...args: any[]) => import("./models").JSONB) & {
+    toSql: () => string;
+    equals: (other: any) => boolean;
+    serialize: (value: unknown) => unknown;
+    key: string;
+};
+export declare const BLOB: ((...args: any[]) => import("./models").BLOB) & {
+    toSql: () => string;
+    equals: (other: any) => boolean;
+    serialize: (value: unknown) => unknown;
+    key: string;
+};
+export declare const BINARY: ((...args: any[]) => import("./models").BINARY) & {
+    toSql: () => string;
+    equals: (other: any) => boolean;
+    serialize: (value: unknown) => unknown;
+    key: string;
+};
+export declare const VARBINARY: ((...args: any[]) => import("./models").VARBINARY) & {
+    toSql: () => string;
+    equals: (other: any) => boolean;
+    serialize: (value: unknown) => unknown;
+    key: string;
+};
+export declare const ENUM: ((...args: any[]) => import("./models").ENUM) & {
+    toSql: () => string;
+    equals: (other: any) => boolean;
+    serialize: (value: unknown) => unknown;
+    key: string;
+};
+export declare const ARRAY: ((...args: any[]) => import("./models").ARRAY) & {
+    toSql: () => string;
+    equals: (other: any) => boolean;
+    serialize: (value: unknown) => unknown;
+    key: string;
+};
+export declare const GEOMETRY: ((...args: any[]) => import("./models").GEOMETRY) & {
+    toSql: () => string;
+    equals: (other: any) => boolean;
+    serialize: (value: unknown) => unknown;
+    key: string;
+};
+export declare const GEOGRAPHY: ((...args: any[]) => import("./models").GEOGRAPHY) & {
+    toSql: () => string;
+    equals: (other: any) => boolean;
+    serialize: (value: unknown) => unknown;
+    key: string;
+};
+export { Op } from './models/operators';
+export type { Operator } from './models/operators';
+export { Op as Operators, Operators as OpAliases, getOperatorString, operatorToWhereKey, where, and, or, not, eq, ne, gt, gte, lt, lte, like, notLike, iLike, notILike, startsWith, notStartsWith, endsWith, notEndsWith, substring, notSubstring, match, regexp, notRegexp, iRegexp, notIRegexp, in as in, inOp, notIn, between, notBetween, isNull, isNotNull, contains, overlap, asc, desc, random, isOrderExpression, } from './operators';
+export type { OperatorSymbol, WhereConditionOptions, OrderExpression } from './operators';
+export * from './operators/index';
+export { Transaction } from './types';
+export * from './types';
+export { ReplicaManager } from './replica-manager';
+export type { ReplicaStatus, ReplicaConnectionConfig, LagDetectionConfig, ReplicationOptions, RoutingStrategy, } from './replica-manager';
+export { Dialect, BaseDialect, DialectRegistry } from './dialects/dialect';
+export { BaseGraphDialect, Neo4jGraphDialect, GremlinGraphDialect, DgraphGraphDialect, GRAPH_DIALECTS, registerGraphDialects, } from './graph';
+export type { DialectOptions, ColumnDefinition, TableOptions, DropTableOptions, TableDescription, IndexOptions, BuildOptions, InsertOptions, UpdateOptions as DialectUpdateOptions, DeleteOptions, SelectOptions, CTEOption, CreateExtensionOptions, DropExtensionOptions, ExtensionInfo, } from './dialects/dialect';
+export { SQLiteDialect } from './dialects/sqlite';
+export { OracleDialect, createOracleDialect } from './dialects/oracle';
+export { MSSQLDialect, createMSSQLDialect } from './dialects/mssql';
+export { ConnectionPool, DatabaseConnectionPool, PooledConnection, createPool, PoolEvents, PoolEventType, } from './connection-pool';
+export type { PoolConfig, PoolConnectionOptions } from './connection-pool';
+export { ScopeManager } from './models/scopes';
+export { ModelManager } from './models/model-manager';
+export { camelToSnake, snakeToCamel, camelToKebab, kebabToCamel, camelize, snakeCase, pluralize, singularize, cloneDeep, merge, pick, omit, generateUUID, generateShortUUID, isValidUUID, formatValues, formatValue, escapeString, escapeId, formatWhere, isEmpty, coalesce, truncate, pad, escapeLike, addTicks, removeTicks, toDefaultValue, formatDefaultValue, spliceStr, } from './utils';
+export { upperCase, lowerCase, capitalize, capitalizeWords, trim, ltrim, rtrim, trimStart, trimEnd, padStart, padEnd, truncate as truncateStr, } from './utils/string';
+export { regex, stringUtils } from './utils/string';
+export { CreateQueryInterface, createQueryInterface } from './query-interface';
+export type { QueryInterfaceOptions, TableColumnDefinition, IndexFieldDefinition, ConstraintDefinition, BulkOperationOptions, QueryInterface, } from './query-interface';
+export * from './migrations';
+export * from './schema';
+export { Logger, LogLevel, LogLevelStrings, createLogger, createSilentLogger, getDefaultLogger, setDefaultLogger, } from './logging';
+export type { LoggerOptions, LogEntry, LoggerEvents } from './logging';
+export { PrormError, ConnectionError, DatabaseError, ValidationError, UniqueConstraintError, ForeignKeyConstraintError, ExclusionConstraintError, TimeoutError, ResourceLockedError, BulkRecordError, AssociationError, EmptyResultError, ErrorCodes, isPrormError, isValidationError, isConnectionError, isConstraintError, isEmptyResultError, } from './errors';
+export * from './errors/utils';
+export * from './utils/index';
+import * as Utils from './utils/index';
+export declare const utils: typeof Utils;
+export { CLI, model, generateModels, configure as configureCLI, getOutputDir, setOutputDir, listModels, removeModel as removeGeneratedModel, } from './cli';
+export { ModelDiagram, ERDiagram, generateModelDiagram, generateERDiagram, generateModelDiagramFromFile, generateERDiagramFromFile, } from './diagrams';
+export type { ModelDiagramOptions, FieldDefinition, AssociationDefinition, ERDiagramOptions, } from './diagrams';
+export * from './query-optimizers';
+export { ForeignDataManager, KNOWN_FDWS, buildOptionsClause } from './foreign-data';
+export type { ForeignServerOptions, AlterForeignServerOptions, UserMappingOptions, ForeignTableOptions, ForeignTableColumnDef, ImportForeignSchemaOptions, ServerInfo, } from './foreign-data';
+export * from './external-fields';
+export * from './decorators';
+export { Database } from './decorators/collate';
+export { Database as DatabaseSecurityDecorator } from './compliance/security-decorator';
+export { UserManager, PRIVILEGE_LEVELS } from './user-management';
+export type { PrivilegeType, PrivilegeScope, CreateUserOptions, AlterUserOptions, GrantOptions, RevokeOptions, RoleOptions, UserInfo, PrivilegeInfo, } from './user-management';
+export { SQLiteAdvanced, createSQLiteAdvanced } from './sqlite-advanced';
+export type { TriggerTiming, TriggerEvent, FTS5Tokenizer, GeneratedStorageType, ConflictAlgorithm, } from './sqlite-advanced';
+export { SQL, MYSQL, MARIADB, POSTGRES, SQLITE, getConstantsForDialect, IsolationLevelEnum, IsolationLevelValue, } from './sql-constants';
+export type { SQLConstants, MySQLConstants, PostgresConstants, SQLiteConstants, IsolationLevel, ForeignKeyChecks, UniqueKeyChecks, Autocommit, Cache, SqlMode, PragmaSettings, ConstraintDeferral, SearchPath, } from './sql-constants';
+export * from './nosql';
+export { count, countDistinct, avg, min, max, stringAgg, arrayAgg, CaseBuilder, SimpleCaseBuilder, caseWhen, caseOf, dateTrunc, dateAdd, dateSub, dateDiff, currentDate, currentTimestamp, fullTextMatch, fullTextRank, jsonExtract, jsonKeys, jsonTypeOf, round, ceil, floor, power, sqrt, abs, sign, mod, greatest, least, concat, upper, lower, length, replace, lpad, rpad, split, WindowFunctionBuilder, rowNumber, rank, denseRank, percentRank, cumeDist, ntile, lag, lead, firstValue, lastValue, nthValue, sumOver, avgOver, countOver, minOver, maxOver, windowFn, NullsOrder, } from './query-builders/functions';
+export { random as sqlRandom, truncate as sqlTruncate, substring as sqlSubstring, trim as sqlTrim, ltrim as sqlLtrim, rtrim as sqlRtrim, jsonContains as sqlJsonContains, jsonHasKey as sqlJsonHasKey, formatDate as sqlFormatDate, now as sqlNow, repeat as sqlRepeat, reverse as sqlReverse, sum as sqlSum, } from './query-builders/functions';
+import { Prorm } from './prorm';
+import { Transaction } from './types';
+declare const ORM: {
+    Prorm: typeof Prorm;
+    DataTypes: {
+        STRING: ((...args: any[]) => import("./models").STRING) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        VARCHAR: ((...args: any[]) => import("./models").VARCHAR) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        CHAR: ((...args: any[]) => import("./models").CHAR) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        TEXT: ((...args: any[]) => import("./models").TEXT) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        TINYTEXT: ((...args: any[]) => import("./models").TINYTEXT) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        MEDIUMTEXT: ((...args: any[]) => import("./models").MEDIUMTEXT) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        LONGTEXT: ((...args: any[]) => import("./models").LONGTEXT) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        INTEGER: ((...args: any[]) => import("./models").INTEGER) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        TINYINT: ((...args: any[]) => import("./models").TINYINT) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        SMALLINT: ((...args: any[]) => import("./models").SMALLINT) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        MEDIUMINT: ((...args: any[]) => import("./models").MEDIUMINT) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        BIGINT: ((...args: any[]) => import("./models").BIGINT) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        FLOAT: ((...args: any[]) => import("./models").FLOAT) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        DOUBLE: ((...args: any[]) => import("./models").DOUBLE) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        DECIMAL: ((...args: any[]) => import("./models").DECIMAL) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        REAL: ((...args: any[]) => import("./models").REAL) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        BOOLEAN: ((...args: any[]) => import("./models").BOOLEAN) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        DATE: ((...args: any[]) => import("./models").DATE) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        DATEONLY: ((...args: any[]) => import("./models").DATEONLY) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        DATETIME: ((...args: any[]) => import("./models").DATETIME) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        TIMESTAMP: ((...args: any[]) => import("./models").TIMESTAMP) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        NOW: ((...args: any[]) => import("./models").NOW) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        TIME: ((...args: any[]) => import("./models").TIME) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        UUID: ((...args: any[]) => import("./models").UUID) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        UUIDV1: ((...args: any[]) => import("./models").UUIDV1) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        UUIDV4: ((...args: any[]) => import("./models").UUIDV4) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        JSON: ((...args: any[]) => import("./models").JSON) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        JSONB: ((...args: any[]) => import("./models").JSONB) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        HSTORE: ((...args: any[]) => import("./models").HSTORE) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        RANGE: ((...args: any[]) => import("./models").RANGE) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        INET: ((...args: any[]) => import("./models").INET) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        INET6: ((...args: any[]) => import("./models").INET) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        CIDR: ((...args: any[]) => import("./models").CIDR) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        MACADDR: ((...args: any[]) => import("./models").MACADDR) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        BLOB: ((...args: any[]) => import("./models").BLOB) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        TINYBLOB: ((...args: any[]) => import("./models").TINYBLOB) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        MEDIUMBLOB: ((...args: any[]) => import("./models").MEDIUMBLOB) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        LONGBLOB: ((...args: any[]) => import("./models").LONGBLOB) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        BINARY: ((...args: any[]) => import("./models").BINARY) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        VARBINARY: ((...args: any[]) => import("./models").VARBINARY) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        ENUM: ((...args: any[]) => import("./models").ENUM) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        ARRAY: ((...args: any[]) => import("./models").ARRAY) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        LIST: ((...args: any[]) => import("./models").LIST) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        STRUCT: ((...args: any[]) => import("./models").STRUCT) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        MAP: ((...args: any[]) => import("./models").MAP) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        UNION: ((...args: any[]) => import("./models").DUCKDB_UNION) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        GEOMETRY: ((...args: any[]) => import("./models").GEOMETRY) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        GEOGRAPHY: ((...args: any[]) => import("./models").GEOGRAPHY) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        POINT: ((...args: any[]) => import("./models").POINT) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        LINESTRING: ((...args: any[]) => import("./models").LINESTRING) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        POLYGON: ((...args: any[]) => import("./models").POLYGON) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        MULTIPOINT: ((...args: any[]) => import("./models").MULTIPOINT) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        MULTILINESTRING: ((...args: any[]) => import("./models").MULTILINESTRING) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        MULTIPOLYGON: ((...args: any[]) => import("./models").MULTIPOLYGON) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        GEOMETRYCOLLECTION: ((...args: any[]) => import("./models").GEOMETRYCOLLECTION) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        SET: ((...args: any[]) => import("./models").SET) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        JSONCOLUMN: ((...args: any[]) => import("./models").JSONColumn) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        VIRTUAL: ((...args: any[]) => import("./models").VIRTUAL) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        VIRTUALSTRING: ((...args: any[]) => import("./models").VIRTUALSTRING) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+        ALGORITHM: ((...args: any[]) => import("./models").ALGORITHM) & {
+            toSql: () => string;
+            equals: (other: any) => boolean;
+            serialize: (value: unknown) => unknown;
+            key: string;
+        };
+    };
+    Op: {
+        readonly and: symbol;
+        readonly or: symbol;
+        readonly not: symbol;
+        readonly eq: symbol;
+        readonly is: symbol;
+        readonly ne: symbol;
+        readonly gt: symbol;
+        readonly gte: symbol;
+        readonly lt: symbol;
+        readonly lte: symbol;
+        readonly like: symbol;
+        readonly notLike: symbol;
+        readonly iLike: symbol;
+        readonly notILike: symbol;
+        readonly startsWith: symbol;
+        readonly notStartsWith: symbol;
+        readonly endsWith: symbol;
+        readonly notEndsWith: symbol;
+        readonly substring: symbol;
+        readonly notSubstring: symbol;
+        readonly col: symbol;
+        readonly in: symbol;
+        readonly notIn: symbol;
+        readonly between: symbol;
+        readonly notBetween: symbol;
+        readonly isNull: symbol;
+        readonly isNotNull: symbol;
+        readonly exists: symbol;
+        readonly notExists: symbol;
+        readonly regexp: symbol;
+        readonly notRegexp: symbol;
+        readonly iRegexp: symbol;
+        readonly notIRegexp: symbol;
+        readonly any: symbol;
+        readonly all: symbol;
+        readonly containsKey: symbol;
+        readonly containsKeyPath: symbol;
+        readonly containsPath: symbol;
+        readonly strictLeft: symbol;
+        readonly strictRight: symbol;
+        readonly noExtendRight: symbol;
+        readonly noExtendLeft: symbol;
+        readonly adj: symbol;
+        readonly notAdj: symbol;
+        readonly arrayContains: symbol;
+        readonly arrayContainedBy: symbol;
+        readonly arrayOverlaps: symbol;
+        readonly arrayAny: symbol;
+        readonly arrayAll: symbol;
+        readonly contains: symbol;
+        readonly containedBy: symbol;
+        readonly keyExists: symbol;
+        readonly overlap: symbol;
+        readonly match: symbol;
+        readonly $json: symbol;
+        readonly jsonPath: symbol;
+        readonly jsonContains: symbol;
+        readonly jsonHasKey: symbol;
+        readonly jsonbExtract: symbol;
+        readonly jsonbExtractText: symbol;
+        readonly jsonbExtractPath: symbol;
+        readonly jsonbExtractPathText: symbol;
+        readonly jsonConcat: symbol;
+        readonly jsonDelete: symbol;
+        readonly jsonDeletePath: symbol;
+        readonly jsonPathExists: symbol;
+        readonly jsonPathQuery: symbol;
+        readonly jsonTypeOf: symbol;
+        readonly json: (path: string) => symbol;
+        readonly key: (pathOrOptions: string | {
+            path: string;
+            value?: any;
+        }) => Record<string, any>;
+        readonly literal: (value: string) => import("./operators").LiteralValue;
+        readonly cast: (value: any, type: string) => import("./operators").CastExpression;
+        readonly extract: (field: any, part: import("./operators").ExtractPart) => import("./operators").ExtractExpression;
+        readonly conv: (value: any, from: string | null | undefined, to: string) => import("./operators").ConvExpression;
+        readonly where: (column: {
+            $col: string;
+        } | string, operator: any, value?: any) => {
+            $where: {
+                $col: string;
+                [key: string]: any;
+            };
+        } | Record<string, any>;
+        readonly asc: (field: string) => import("./operators").OrderExpression;
+        readonly desc: (field: string) => import("./operators").OrderExpression;
+        readonly random: () => import("./operators").OrderExpression;
+        readonly isNotNullPredicate: (value: any) => boolean;
+        readonly matchAgainst: (columns: string | string[], options?: {
+            mode?: "natural" | "boolean";
+        }) => {
+            $match: {
+                columns: string[];
+                mode: "natural" | "boolean";
+            };
+        };
+        readonly matchFulltext: (columns: string | string[]) => {
+            $match: {
+                columns: string[];
+                mode: "natural";
+            };
+        };
+        readonly toTsvector: (column: string, config?: string) => {
+            $tsvector: {
+                column: string;
+                config: string;
+            };
+        };
+        readonly toTsquery: (query: string, config?: string) => {
+            $tsquery: {
+                query: string;
+                config: string;
+            };
+        };
+        readonly stDistance: symbol;
+        readonly stWithin: symbol;
+        readonly stContains: symbol;
+        readonly stIntersects: symbol;
+        readonly stDWithin: symbol;
+        readonly stCrosses: symbol;
+        readonly stOverlaps: symbol;
+        readonly stTouches: symbol;
+        readonly stEquals: symbol;
+        readonly stIsValid: symbol;
+    };
+    Transaction: typeof Transaction;
+};
+export default ORM;