import type { EntityKey, ExpandProperty } from './typings.js';
import type { Transaction } from './connections/Connection.js';
import type { LogContext } from './logging/Logger.js';
/** Controls when the `EntityManager` flushes pending changes to the database. */
export declare enum FlushMode {
    /** The `EntityManager` delays the flush until the current Transaction is committed. */
    COMMIT = "commit",
    /** This is the default mode, and it flushes the `EntityManager` only if necessary. */
    AUTO = "auto",
    /** Flushes the `EntityManager` before every query. */
    ALWAYS = "always"
}
/** Controls how populate hints are resolved when using `FindOptions.populateWhere`. */
export declare enum PopulateHint {
    /** Infer population hints from the `where` condition. */
    INFER = "infer",
    /** Apply population hints to all relations. */
    ALL = "all"
}
/** Special tokens used as populate path values in `FindOptions.populate`. */
export declare enum PopulatePath {
    /** Infer which relations to populate based on fields accessed in the `where` or `orderBy` clause. */
    INFER = "$infer",
    /** Populate all relations. */
    ALL = "*"
}
/** Logical grouping operators for combining query conditions. */
export declare enum GroupOperator {
    /** Logical AND — all conditions must match. */
    $and = "and",
    /** Logical OR — at least one condition must match. */
    $or = "or"
}
/** Comparison and filtering operators used in query conditions. */
export declare enum QueryOperator {
    /** Equal. */
    $eq = "=",
    /** Included in the given list. */
    $in = "in",
    /** Not included in the given list. */
    $nin = "not in",
    /** Greater than. */
    $gt = ">",
    /** Greater than or equal to. */
    $gte = ">=",
    /** Less than. */
    $lt = "<",
    /** Less than or equal to. */
    $lte = "<=",
    /** Not equal. */
    $ne = "!=",
    /** Negation wrapper. */
    $not = "not",
    /** SQL LIKE pattern matching. */
    $like = "like",
    /** Regular expression matching. */
    $re = "regexp",
    /** Full-text search. */
    $fulltext = "fulltext",
    /** Checks that the value is not null (i.e., exists). */
    $exists = "not null",
    /** Case-insensitive LIKE (PostgreSQL only). */
    $ilike = "ilike",// postgres only
    /** Array overlap operator (PostgreSQL only). */
    $overlap = "&&",// postgres only
    /** Array/JSON contains operator (PostgreSQL only). */
    $contains = "@>",// postgres only
    /** Array/JSON contained-by operator (PostgreSQL only). */
    $contained = "<@",// postgres only
    /** No element in the collection matches (SQL only). */
    $none = "none",// collection operators, sql only
    /** At least one element in the collection matches (SQL only). */
    $some = "some",// collection operators, sql only
    /** Every element in the collection matches (SQL only). */
    $every = "every",// collection operators, sql only
    /** Matches collections by their size (SQL only). */
    $size = "size",// collection operators, sql only
    /** JSON object has the given key (PostgreSQL only). */
    $hasKey = "?",// postgres only, json
    /** JSON object has all of the given keys (PostgreSQL only). */
    $hasKeys = "?&",// postgres only, json
    /** JSON object has at least one of the given keys (PostgreSQL only). */
    $hasSomeKeys = "?|",// postgres only, json
    /** Matches an element inside a JSON array (SQL only). */
    $elemMatch = "elemMatch"
}
export declare const ARRAY_OPERATORS: string[];
export declare const JSON_KEY_OPERATORS: string[];
/** Sort direction for query results. Both upper- and lower-case variants are accepted. */
export declare enum QueryOrder {
    /** Ascending order. */
    ASC = "ASC",
    /** Ascending order with nulls sorted last. */
    ASC_NULLS_LAST = "ASC NULLS LAST",
    /** Ascending order with nulls sorted first. */
    ASC_NULLS_FIRST = "ASC NULLS FIRST",
    /** Descending order. */
    DESC = "DESC",
    /** Descending order with nulls sorted last. */
    DESC_NULLS_LAST = "DESC NULLS LAST",
    /** Descending order with nulls sorted first. */
    DESC_NULLS_FIRST = "DESC NULLS FIRST",
    /** Ascending order (lower-case variant). */
    asc = "asc",
    /** Ascending order with nulls sorted last (lower-case variant). */
    asc_nulls_last = "asc nulls last",
    /** Ascending order with nulls sorted first (lower-case variant). */
    asc_nulls_first = "asc nulls first",
    /** Descending order (lower-case variant). */
    desc = "desc",
    /** Descending order with nulls sorted last (lower-case variant). */
    desc_nulls_last = "desc nulls last",
    /** Descending order with nulls sorted first (lower-case variant). */
    desc_nulls_first = "desc nulls first"
}
/** Numeric sort direction, compatible with MongoDB-style ordering. */
export declare enum QueryOrderNumeric {
    /** Ascending order. */
    ASC = 1,
    /** Descending order. */
    DESC = -1
}
export type QueryOrderKeysFlat = QueryOrder | QueryOrderNumeric | `${QueryOrder}`;
export type QueryOrderKeys<T> = QueryOrderKeysFlat | QueryOrderMap<T>;
export type QueryOrderMap<T> = {
    [K in EntityKey<T>]?: QueryOrderKeys<ExpandProperty<T[K]>>;
};
export interface FlatQueryOrderMap {
    [x: string]: QueryOrderKeysFlat;
}
/** Flags that modify query builder behavior. */
export declare enum QueryFlag {
    /** Add a DISTINCT clause to the SELECT statement. */
    DISTINCT = "DISTINCT",
    /** Enable result pagination via a sub-query for the primary keys. */
    PAGINATE = "PAGINATE",
    /** Disable the automatic pagination sub-query. */
    DISABLE_PAGINATE = "DISABLE_PAGINATE",
    /** Wrap UPDATE statements in a sub-query. */
    UPDATE_SUB_QUERY = "UPDATE_SUB_QUERY",
    /** Wrap DELETE statements in a sub-query. */
    DELETE_SUB_QUERY = "DELETE_SUB_QUERY",
    /** Convert values through custom type mappings when reading results. */
    CONVERT_CUSTOM_TYPES = "CONVERT_CUSTOM_TYPES",
    /** Include lazy formula properties in the SELECT clause. */
    INCLUDE_LAZY_FORMULAS = "INCLUDE_LAZY_FORMULAS",
    /** Automatically join the owning side of one-to-one relations. */
    AUTO_JOIN_ONE_TO_ONE_OWNER = "AUTO_JOIN_ONE_TO_ONE_OWNER",
    /** Infer the populate hint from the query fields. */
    INFER_POPULATE = "INFER_POPULATE",
    /** Prevent nested conditions from being promoted to INNER JOINs. */
    DISABLE_NESTED_INNER_JOIN = "DISABLE_NESTED_INNER_JOIN",
    /** Enable IDENTITY_INSERT for explicit PK values (MSSQL only). */
    IDENTITY_INSERT = "IDENTITY_INSERT",// mssql only
    /** Use an OUTPUT...INTO temp table for returning rows (MSSQL only). */
    OUTPUT_TABLE = "OUTPUT_TABLE"
}
export declare const SCALAR_TYPES: Set<string>;
/** Describes the kind of relationship a property represents. */
export declare enum ReferenceKind {
    /** A plain scalar property (not a relation). */
    SCALAR = "scalar",
    /** A one-to-one relation. */
    ONE_TO_ONE = "1:1",
    /** A one-to-many relation (inverse side of a many-to-one). */
    ONE_TO_MANY = "1:m",
    /** A many-to-one relation (owning side). */
    MANY_TO_ONE = "m:1",
    /** A many-to-many relation. */
    MANY_TO_MANY = "m:n",
    /** An embedded entity (inline object stored within the parent). */
    EMBEDDED = "embedded"
}
/** Cascade operations that propagate from a parent entity to its relations. */
export declare enum Cascade {
    /** Cascade persist — new related entities are automatically persisted. */
    PERSIST = "persist",
    /** Cascade merge — detached related entities are merged into the identity map. */
    MERGE = "merge",
    /** Cascade remove — removing the parent also removes related entities. */
    REMOVE = "remove",
    /** Enable all cascade operations (persist, merge, remove). */
    ALL = "all",
    /** @internal */
    SCHEDULE_ORPHAN_REMOVAL = "schedule_orphan_removal",
    /** @internal */
    CANCEL_ORPHAN_REMOVAL = "cancel_orphan_removal"
}
/** Strategy used to load related entities when populating. */
export declare enum LoadStrategy {
    /** Load relations with a separate SELECT ... WHERE pk IN (...) query. */
    SELECT_IN = "select-in",
    /** Load relations via SQL JOINs in a single query. */
    JOINED = "joined",
    /** Use joined strategy for to-one relations and select-in for to-many. */
    BALANCED = "balanced"
}
/** Controls which relation types use the dataloader for batched loading. */
export declare enum DataloaderType {
    /** Dataloader is disabled. */
    NONE = 0,
    /** Use the dataloader for Reference (to-one) relations only. */
    REFERENCE = 1,
    /** Use the dataloader for Collection (to-many) relations only. */
    COLLECTION = 2,
    /** Use the dataloader for both Reference and Collection relations. */
    ALL = 3
}
/** Locking strategy for concurrency control. */
export declare enum LockMode {
    /** No locking. */
    NONE = 0,
    /** Optimistic locking via a version column. */
    OPTIMISTIC = 1,
    /** Pessimistic shared lock (FOR SHARE). */
    PESSIMISTIC_READ = 2,
    /** Pessimistic exclusive lock (FOR UPDATE). */
    PESSIMISTIC_WRITE = 3,
    /** Pessimistic exclusive lock that skips already-locked rows (FOR UPDATE SKIP LOCKED). */
    PESSIMISTIC_PARTIAL_WRITE = 4,
    /** Pessimistic exclusive lock that fails immediately if the row is locked (FOR UPDATE NOWAIT). */
    PESSIMISTIC_WRITE_OR_FAIL = 5,
    /** Pessimistic shared lock that skips already-locked rows (FOR SHARE SKIP LOCKED). */
    PESSIMISTIC_PARTIAL_READ = 6,
    /** Pessimistic shared lock that fails immediately if the row is locked (FOR SHARE NOWAIT). */
    PESSIMISTIC_READ_OR_FAIL = 7
}
/** Transaction isolation levels as defined by the SQL standard (plus vendor extensions). */
export declare enum IsolationLevel {
    /** Allows dirty reads, non-repeatable reads, and phantom reads. */
    READ_UNCOMMITTED = "read uncommitted",
    /** Prevents dirty reads; non-repeatable and phantom reads are still possible. */
    READ_COMMITTED = "read committed",
    /** Snapshot isolation — each transaction sees a consistent snapshot of the database (MSSQL). */
    SNAPSHOT = "snapshot",
    /** Prevents dirty and non-repeatable reads; phantom reads are still possible. */
    REPEATABLE_READ = "repeatable read",
    /** Full isolation — transactions are executed as if they were run sequentially. */
    SERIALIZABLE = "serializable"
}
/** Lifecycle and transaction events emitted by the ORM. */
export declare enum EventType {
    /** Fired when an entity instance is created (via constructor or `em.create`). */
    onInit = "onInit",
    /** Fired after an entity is loaded from the database. */
    onLoad = "onLoad",
    /** Fired before a new entity is inserted into the database. */
    beforeCreate = "beforeCreate",
    /** Fired after a new entity has been inserted into the database. */
    afterCreate = "afterCreate",
    /** Fired before an existing entity is updated in the database. */
    beforeUpdate = "beforeUpdate",
    /** Fired after an existing entity has been updated in the database. */
    afterUpdate = "afterUpdate",
    /** Fired before an upsert operation. */
    beforeUpsert = "beforeUpsert",
    /** Fired after an upsert operation. */
    afterUpsert = "afterUpsert",
    /** Fired before an entity is deleted from the database. */
    beforeDelete = "beforeDelete",
    /** Fired after an entity has been deleted from the database. */
    afterDelete = "afterDelete",
    /** Fired at the very beginning of `em.flush()`, before change detection. */
    beforeFlush = "beforeFlush",
    /** Fired during `em.flush()` after change detection but before database writes. */
    onFlush = "onFlush",
    /** Fired after `em.flush()` has completed all database writes. */
    afterFlush = "afterFlush",
    /** Fired before a new database transaction is started. */
    beforeTransactionStart = "beforeTransactionStart",
    /** Fired after a new database transaction has been started. */
    afterTransactionStart = "afterTransactionStart",
    /** Fired before a database transaction is committed. */
    beforeTransactionCommit = "beforeTransactionCommit",
    /** Fired after a database transaction has been committed. */
    afterTransactionCommit = "afterTransactionCommit",
    /** Fired before a database transaction is rolled back. */
    beforeTransactionRollback = "beforeTransactionRollback",
    /** Fired after a database transaction has been rolled back. */
    afterTransactionRollback = "afterTransactionRollback"
}
export declare const EventTypeMap: Record<EventType, number>;
export type TransactionEventType = EventType.beforeTransactionStart | EventType.afterTransactionStart | EventType.beforeTransactionCommit | EventType.afterTransactionCommit | EventType.beforeTransactionRollback | EventType.afterTransactionRollback;
/** Controls how a transactional operation interacts with an existing transaction. */
export declare enum TransactionPropagation {
    /** Join the current transaction or create a new one if none exists. */
    REQUIRED = "required",
    /** Always create a new transaction, suspending the current one if it exists. */
    REQUIRES_NEW = "requires_new",
    /** Create a nested savepoint within the current transaction, or a new transaction if none exists. */
    NESTED = "nested",
    /** Execute non-transactionally, suspending the current transaction if one exists. */
    NOT_SUPPORTED = "not_supported",
    /** Join the current transaction if one exists, otherwise execute non-transactionally. */
    SUPPORTS = "supports",
    /** Join the current transaction; throw if no transaction is active. */
    MANDATORY = "mandatory",
    /** Execute non-transactionally; throw if a transaction is active. */
    NEVER = "never"
}
export interface TransactionOptions {
    ctx?: Transaction;
    propagation?: TransactionPropagation | `${TransactionPropagation}`;
    isolationLevel?: IsolationLevel | `${IsolationLevel}`;
    readOnly?: boolean;
    clear?: boolean;
    flushMode?: FlushMode | `${FlushMode}`;
    ignoreNestedTransactions?: boolean;
    loggerContext?: LogContext;
}
export declare abstract class PlainObject {
}
/** Constraint deferral mode for database constraints (e.g., foreign keys, unique). */
export declare enum DeferMode {
    /** The constraint is checked immediately by default, but can be deferred within a transaction. */
    INITIALLY_IMMEDIATE = "immediate",
    /** The constraint is deferred until the transaction is committed. */
    INITIALLY_DEFERRED = "deferred"
}
/** With `absolute` the prefix is set at the root of the entity (regardless of the nesting level) */
export type EmbeddedPrefixMode = 'absolute' | 'relative';