linkgress-orm 0.0.1

package/dist/entity/db-context.d.ts

@@ -0,0 +1,665 @@
+import { DatabaseClient, QueryResult } from '../database/database-client.interface';
+import { TableBuilder, TableSchema, InferTableType } from '../schema/table-builder';
+import { UnwrapDbColumns, InsertData, ExtractDbColumns } from './db-column';
+import { DbEntity, EntityConstructor } from './entity-base';
+import { DbModelConfig } from './model-config';
+import { Condition, SqlFragment } from '../query/conditions';
+import { ResolveCollectionResults, SelectQueryBuilder, QueryBuilder } from '../query/query-builder';
+import { InferRowType } from '../schema/row-type';
+import { DbSchemaManager } from '../migration/db-schema-manager';
+import { DbSequence, SequenceConfig } from '../schema/sequence-builder';
+/**
+ * Collection aggregation strategy type
+ */
+export type CollectionStrategyType = 'jsonb' | 'temptable';
+/**
+ * Query execution options
+ */
+export interface QueryOptions {
+    /** Enable SQL query logging */
+    logQueries?: boolean;
+    /** Custom logger function (defaults to console.log) */
+    logger?: (message: string) => void;
+    /** Log query execution time */
+    logExecutionTime?: boolean;
+    /** Log query parameters */
+    logParameters?: boolean;
+    /** Collection aggregation strategy (default: 'jsonb') */
+    collectionStrategy?: CollectionStrategyType;
+}
+/**
+ * @deprecated Use QueryOptions instead
+ */
+export type LoggingOptions = QueryOptions;
+/**
+ * Query executor with optional logging
+ */
+export declare class QueryExecutor {
+    private client;
+    private options;
+    constructor(client: DatabaseClient, options?: QueryOptions);
+    query(sql: string, params?: any[]): Promise<QueryResult>;
+    /**
+     * Execute a multi-statement query using the simple protocol (no parameters)
+     * Only available for clients that support it (e.g., PostgresClient)
+     */
+    querySimple(sql: string): Promise<QueryResult>;
+    /**
+     * Execute a multi-statement query and return ALL result sets
+     * Only available for PostgresClient
+     */
+    querySimpleMulti(sql: string): Promise<QueryResult[]>;
+}
+/**
+ * Conflict target for upsert operations
+ */
+export interface ConflictTarget {
+    columns?: string[];
+    constraint?: string;
+}
+/**
+ * Insert configuration for bulk operations
+ */
+export interface InsertConfig {
+    /**
+     * Size of insert chunk. If not provided, auto-detected based on max PG query parameters limit
+     */
+    chunkSize?: number;
+    /**
+     * Use OVERRIDING SYSTEM VALUE to allow inserting into identity/serial columns
+     */
+    overridingSystemValue?: boolean;
+}
+/**
+ * Upsert configuration
+ */
+export interface UpsertConfig {
+    /**
+     * Size of insert chunk for bulk upserts
+     */
+    chunkSize?: number;
+    /**
+     * Primary key columns for conflict detection. If not specified, table's primary keys are used
+     */
+    primaryKey?: string | string[];
+    /**
+     * Use OVERRIDING SYSTEM VALUE (auto-detected if not specified)
+     */
+    overridingSystemValue?: boolean;
+    /**
+     * WHERE clause for the conflict target
+     */
+    targetWhere?: string;
+    /**
+     * WHERE clause for the UPDATE SET
+     */
+    setWhere?: string;
+    /**
+     * Reference item to detect columns. If not specified, first value from array is used
+     */
+    referenceItem?: any;
+    /**
+     * List of column names that should be updated on conflict. If not specified, all non-PK columns are updated
+     */
+    updateColumns?: string[];
+    /**
+     * Filter function to determine if column should be updated on conflict
+     */
+    updateColumnFilter?: (columnName: string) => boolean;
+}
+/**
+ * Insert builder for upsert operations
+ */
+export declare class InsertBuilder<TSchema extends TableSchema> {
+    private schema;
+    private client;
+    private executor?;
+    private dataArray;
+    private conflictTarget?;
+    private conflictAction;
+    private updateColumns?;
+    private updateColumnFilter?;
+    private targetWhereClause?;
+    private setWhereClause?;
+    private overridingSystemValue;
+    constructor(schema: TSchema, client: DatabaseClient, executor?: QueryExecutor | undefined);
+    /**
+     * Get qualified table name with schema prefix if specified
+     */
+    private getQualifiedTableName;
+    /**
+     * Set the values to insert (single row or multiple rows)
+     */
+    values(data: Partial<InferTableType<TSchema>> | Partial<InferTableType<TSchema>>[]): this;
+    /**
+     * Specify conflict target (columns or constraint name)
+     */
+    onConflict(target?: ConflictTarget | string[]): this;
+    /**
+     * Do nothing on conflict
+     */
+    doNothing(): this;
+    /**
+     * Update on conflict (upsert)
+     */
+    doUpdate(options?: {
+        set?: Partial<InferTableType<TSchema>>;
+        where?: string;
+        updateColumns?: string[];
+        updateColumnFilter?: (columnName: string) => boolean;
+    }): this;
+    /**
+     * Set target WHERE clause for ON CONFLICT
+     */
+    targetWhere(where: string): this;
+    /**
+     * Enable OVERRIDING SYSTEM VALUE
+     */
+    setOverridingSystemValue(value?: boolean): this;
+    /**
+     * Execute the insert/upsert
+     */
+    execute(): Promise<InferTableType<TSchema>[]>;
+}
+/**
+ * Table accessor with query methods
+ */
+export declare class TableAccessor<TBuilder extends TableBuilder<any>> {
+    private tableBuilder;
+    private client;
+    private schemaRegistry;
+    private executor?;
+    private collectionStrategy?;
+    private schema;
+    constructor(tableBuilder: TBuilder, client: DatabaseClient, schemaRegistry: Map<string, TableSchema>, executor?: QueryExecutor | undefined, collectionStrategy?: CollectionStrategyType | undefined);
+    /**
+     * Configure query options for the current query chain
+     * Returns a new TableAccessor instance with the specified options
+     *
+     * @example
+     * ```typescript
+     * const results = await db.users
+     *   .withQueryOptions({ logQueries: true, collectionStrategy: 'temptable' })
+     *   .select(u => ({ id: u.id, name: u.username }))
+     *   .toList();
+     * ```
+     */
+    withQueryOptions(options: QueryOptions): TableAccessor<TBuilder>;
+    /**
+     * Start a select query with automatic type inference
+     */
+    select<TSelection>(selector: (row: InferRowType<TBuilder>) => TSelection): SelectQueryBuilder<TSelection>;
+    /**
+     * Add WHERE condition before select
+     */
+    where(condition: (row: InferRowType<TBuilder>) => Condition): QueryBuilder<TableSchema, InferRowType<TBuilder>>;
+    /**
+     * Left join with another table and selector
+     */
+    leftJoin<TRight, TSelection>(rightTable: {
+        _getSchema: () => TableSchema;
+    } | import('../query/subquery').Subquery<TRight, 'table'>, condition: (left: InferRowType<TBuilder>, right: TRight) => Condition, selector: (left: InferRowType<TBuilder>, right: TRight) => TSelection, alias?: string): SelectQueryBuilder<TSelection>;
+    /**
+     * Inner join with another table or subquery and selector
+     */
+    innerJoin<TRight, TSelection>(rightTable: {
+        _getSchema: () => TableSchema;
+    } | import('../query/subquery').Subquery<TRight, 'table'>, condition: (left: InferRowType<TBuilder>, right: TRight) => Condition, selector: (left: InferRowType<TBuilder>, right: TRight) => TSelection, alias?: string): SelectQueryBuilder<TSelection>;
+    /**
+     * Get table schema (internal use for joins)
+     */
+    _getSchema(): TableSchema;
+    /**
+     * Get table schema
+     */
+    getSchema(): TableSchema;
+    /**
+     * Get table name
+     */
+    getTableName(): string;
+    /**
+     * Get qualified table name with schema prefix if specified
+     */
+    private getQualifiedTableName;
+    /**
+     * Insert a row
+     */
+    insert(data: Partial<InferTableType<TableSchema>>): Promise<InferTableType<TableSchema>>;
+    /**
+     * Bulk insert with advanced configuration
+     */
+    insertBulk(value: Partial<InferTableType<TableSchema>> | Partial<InferTableType<TableSchema>>[], insertConfig?: InsertConfig): Promise<InferTableType<TableSchema>[]>;
+    /**
+     * Insert a single chunk (internal method)
+     */
+    private insertBulkSingle;
+    /**
+     * Upsert with advanced configuration
+     */
+    upsertBulk(values: Partial<InferTableType<TableSchema>>[], config?: UpsertConfig): Promise<InferTableType<TableSchema>[]>;
+    /**
+     * Upsert a single chunk (internal method)
+     */
+    private upsertBulkSingle;
+    /**
+     * Bulk insert multiple rows (simple version, kept for compatibility)
+     */
+    insertMany(dataArray: Partial<InferTableType<TableSchema>>[]): Promise<InferTableType<TableSchema>[]>;
+    /**
+     * Insert with conflict resolution (upsert)
+     */
+    onConflictDoNothing(): InsertBuilder<TableSchema>;
+    /**
+     * Insert with conflict resolution (upsert) - start building the upsert query
+     */
+    values(data: Partial<InferTableType<TableSchema>> | Partial<InferTableType<TableSchema>>[]): InsertBuilder<TableSchema>;
+    /**
+     * Update rows
+     */
+    update(id: any, data: Partial<InferTableType<TableSchema>>): Promise<InferTableType<TableSchema> | null>;
+    /**
+     * Delete a row by id
+     */
+    delete(id: any): Promise<boolean>;
+}
+/**
+ * Schema definition for DataContext
+ */
+export type ContextSchema = {
+    [tableName: string]: TableBuilder<any>;
+};
+/**
+ * Infer table accessor types from schema with proper relation types
+ */
+export type InferContextSchema<T extends ContextSchema> = {
+    [K in keyof T]: T[K] extends TableBuilder<any> ? TableAccessor<T[K]> : never;
+};
+/**
+ * DataContext - main entry point for database operations
+ */
+export declare class DataContext<TSchema extends ContextSchema = any> {
+    protected client: DatabaseClient;
+    private schemaRegistry;
+    private tableAccessors;
+    private executor?;
+    private queryOptions?;
+    constructor(client: DatabaseClient, schema: TSchema, queryOptions?: QueryOptions);
+    /**
+     * Initialize schema and create table accessors
+     */
+    private initializeSchema;
+    /**
+     * Get table accessor by name
+     */
+    getTable<K extends keyof TSchema>(name: K): InferContextSchema<TSchema>[K];
+    /**
+     * Execute raw SQL
+     */
+    query(sql: string, params?: any[]): Promise<any>;
+    /**
+     * Execute in transaction
+     */
+    transaction<TResult>(fn: (ctx: this) => Promise<TResult>): Promise<TResult>;
+    /**
+     * Get schema manager for create/drop operations and automatic migrations
+     */
+    getSchemaManager(): DbSchemaManager;
+    /**
+     * Close database connection
+     */
+    dispose(): Promise<void>;
+}
+/**
+ * Typed upsert configuration for entities
+ */
+export type EntityUpsertConfig<TEntity extends DbEntity> = {
+    /**
+     * Size of insert chunk for bulk upserts
+     */
+    chunkSize?: number;
+    /**
+     * Primary key columns for conflict detection. If not specified, table's primary keys are used
+     * Can be specified as property names (strings) or using lambda selectors
+     */
+    primaryKey?: keyof ExtractDbColumns<TEntity> | (keyof ExtractDbColumns<TEntity>)[] | ((entity: TEntity) => any);
+    /**
+     * Use OVERRIDING SYSTEM VALUE (auto-detected if not specified)
+     */
+    overridingSystemValue?: boolean;
+    /**
+     * WHERE clause for the conflict target
+     */
+    targetWhere?: string;
+    /**
+     * WHERE clause for the UPDATE SET
+     */
+    setWhere?: string;
+    /**
+     * Reference item to detect columns. If not specified, first value from array is used
+     */
+    referenceItem?: any;
+    /**
+     * List of columns that should be updated on conflict. Can be property names or lambda selectors
+     */
+    updateColumns?: (keyof ExtractDbColumns<TEntity>)[] | ((entity: TEntity) => Partial<ExtractDbColumns<TEntity>>);
+    /**
+     * Filter function to determine if column should be updated on conflict
+     */
+    updateColumnFilter?: (columnName: string) => boolean;
+};
+/**
+ * Type helper to build entity query type with navigation support
+ */
+export type EntityQuery<TEntity extends DbEntity> = {
+    [K in keyof TEntity]: TEntity[K] extends (infer U)[] | undefined ? U extends DbEntity ? EntityCollectionQuery<U> : TEntity[K] : TEntity[K] extends DbEntity | undefined ? EntityQuery<NonNullable<TEntity[K]>> : TEntity[K];
+};
+/**
+ * Collection query builder type for navigation collections
+ */
+export interface EntityCollectionQuery<TEntity extends DbEntity> {
+    select<TSelection>(selector: (item: EntityQuery<TEntity>) => TSelection): EntityCollectionQueryWithSelect<TEntity, TSelection>;
+    selectDistinct<TSelection>(selector: (item: EntityQuery<TEntity>) => TSelection): EntityCollectionQueryWithSelect<TEntity, TSelection>;
+    where(condition: (item: EntityQuery<TEntity>) => any): this;
+    orderBy(selector: (item: EntityQuery<TEntity>) => any): this;
+    orderBy(selector: (item: EntityQuery<TEntity>) => any[]): this;
+    orderBy(selector: (item: EntityQuery<TEntity>) => Array<[any, 'ASC' | 'DESC']>): this;
+    limit(count: number): this;
+    offset(count: number): this;
+    min<TSelection>(selector: (item: EntityQuery<TEntity>) => TSelection): SqlFragment<number | null>;
+    max<TSelection>(selector: (item: EntityQuery<TEntity>) => TSelection): SqlFragment<number | null>;
+    sum<TSelection>(selector: (item: EntityQuery<TEntity>) => TSelection): SqlFragment<number | null>;
+    count(): SqlFragment<number>;
+    toNumberList(asName?: string): number[];
+    toStringList(asName?: string): string[];
+    toList(asName: string): TEntity[];
+}
+export interface EntityCollectionQueryWithSelect<TEntity extends DbEntity, TSelection> {
+    where(condition: (item: EntityQuery<TEntity>) => any): this;
+    orderBy(selector: (item: TSelection) => any): this;
+    orderBy(selector: (item: TSelection) => any[]): this;
+    orderBy(selector: (item: TSelection) => Array<[any, 'ASC' | 'DESC']>): this;
+    limit(count: number): this;
+    offset(count: number): this;
+    min(): Promise<TSelection | null>;
+    max(): Promise<TSelection | null>;
+    sum(): Promise<TSelection | null>;
+    count(): Promise<number>;
+    toNumberList(asName?: string): number[];
+    toStringList(asName?: string): string[];
+    toList(asName: string): TSelection[];
+}
+/**
+ * Strongly-typed query builder for entities
+ * Results automatically unwrap DbColumn<T> to T
+ */
+export interface EntitySelectQueryBuilder<TEntity extends DbEntity, TSelection> {
+    select<TNewSelection>(selector: (entity: TSelection extends DbEntity ? EntityQuery<TSelection> : TSelection) => TNewSelection): EntitySelectQueryBuilder<TEntity, TNewSelection>;
+    selectDistinct<TNewSelection>(selector: (entity: TSelection extends DbEntity ? EntityQuery<TSelection> : TSelection) => TNewSelection): EntitySelectQueryBuilder<TEntity, TNewSelection>;
+    where(condition: (entity: TSelection extends DbEntity ? EntityQuery<TSelection> : TSelection) => any): EntitySelectQueryBuilder<TEntity, TSelection>;
+    orderBy(selector: (row: TSelection) => any): EntitySelectQueryBuilder<TEntity, TSelection>;
+    orderBy(selector: (row: TSelection) => any[]): EntitySelectQueryBuilder<TEntity, TSelection>;
+    orderBy(selector: (row: TSelection) => Array<[any, 'ASC' | 'DESC']>): EntitySelectQueryBuilder<TEntity, TSelection>;
+    limit(count: number): EntitySelectQueryBuilder<TEntity, TSelection>;
+    offset(count: number): EntitySelectQueryBuilder<TEntity, TSelection>;
+    count(): Promise<number>;
+    first(): Promise<ResolveCollectionResults<TSelection>>;
+    firstOrDefault(): Promise<ResolveCollectionResults<TSelection> | null>;
+    firstOrThrow(): Promise<ResolveCollectionResults<TSelection>>;
+    leftJoin<TRight extends DbEntity | Record<string, any>, TNewSelection>(rightTable: DbEntityTable<TRight extends DbEntity ? TRight : never> | import('../query/subquery').Subquery<TRight, 'table'> | import('../query/cte-builder').DbCte<TRight>, condition: (left: TSelection extends DbEntity ? EntityQuery<TSelection> : TSelection, right: TRight extends DbEntity ? (EntityQuery<TRight> | TRight) : TRight) => Condition, selector: (left: TSelection extends DbEntity ? EntityQuery<TSelection> : TSelection, right: TRight extends DbEntity ? (EntityQuery<TRight> | TRight) : TRight) => TNewSelection, alias?: string): EntitySelectQueryBuilder<TEntity, TNewSelection>;
+    innerJoin<TRight extends DbEntity | Record<string, any>, TNewSelection>(rightTable: DbEntityTable<TRight extends DbEntity ? TRight : never> | import('../query/subquery').Subquery<TRight, 'table'> | import('../query/cte-builder').DbCte<TRight>, condition: (left: TSelection extends DbEntity ? EntityQuery<TSelection> : TSelection, right: TRight extends DbEntity ? (EntityQuery<TRight> | TRight) : TRight) => Condition, selector: (left: TSelection extends DbEntity ? EntityQuery<TSelection> : TSelection, right: TRight extends DbEntity ? (EntityQuery<TRight> | TRight) : TRight) => TNewSelection, alias?: string): EntitySelectQueryBuilder<TEntity, TNewSelection>;
+    groupBy<TGroupingKey>(selector: (entity: TSelection extends DbEntity ? EntityQuery<TSelection> : TSelection) => TGroupingKey): import('../query/grouped-query').GroupedQueryBuilder<TSelection extends DbEntity ? EntityQuery<TSelection> : TSelection, TGroupingKey>;
+    min<TResult = TSelection>(selector?: (entity: TSelection extends DbEntity ? EntityQuery<TSelection> : TSelection) => TResult): Promise<TResult | null>;
+    max<TResult = TSelection>(selector?: (entity: TSelection extends DbEntity ? EntityQuery<TSelection> : TSelection) => TResult): Promise<TResult | null>;
+    sum<TResult = TSelection>(selector?: (entity: TSelection extends DbEntity ? EntityQuery<TSelection> : TSelection) => TResult): Promise<TResult | null>;
+    count(): Promise<number>;
+    asSubquery<TMode extends 'scalar' | 'array' | 'table' = 'table'>(mode?: TMode): import('../query/subquery').Subquery<TMode extends 'scalar' ? UnwrapDbColumns<TSelection> : TMode extends 'array' ? UnwrapDbColumns<TSelection>[] : UnwrapDbColumns<TSelection>, TMode>;
+    with(...ctes: import('../query/cte-builder').DbCte<any>[]): this;
+    update(data: Partial<InsertData<TEntity>>): Promise<UnwrapDbColumns<TEntity>[]>;
+    delete(): Promise<void>;
+    toList(): Promise<ResolveCollectionResults<TSelection>[]>;
+    first(): Promise<ResolveCollectionResults<TSelection>>;
+    firstOrDefault(): Promise<ResolveCollectionResults<TSelection> | null>;
+}
+/**
+ * DbEntity insert builder for upsert operations with proper typing
+ */
+export declare class EntityInsertBuilder<TEntity extends DbEntity> {
+    private builder;
+    constructor(builder: InsertBuilder<TableSchema>);
+    /**
+     * Specify conflict target (columns or constraint name)
+     */
+    onConflict(target?: ConflictTarget | string[]): this;
+    /**
+     * Do nothing on conflict
+     */
+    doNothing(): this;
+    /**
+     * Update on conflict (upsert)
+     */
+    doUpdate(options?: {
+        set?: InsertData<TEntity>;
+        where?: string;
+    }): this;
+    /**
+     * Execute the insert/upsert
+     */
+    execute(): Promise<UnwrapDbColumns<TEntity>[]>;
+}
+/**
+ * Table accessor with entity typing
+ */
+export declare class DbEntityTable<TEntity extends DbEntity> {
+    private context;
+    private tableName;
+    private tableBuilder;
+    constructor(context: DataContext, tableName: string, tableBuilder: TableBuilder<any>);
+    /**
+     * Get the table schema for this entity
+     * @internal
+     */
+    _getSchema(): TableSchema;
+    /**
+     * Get the database client
+     * @internal
+     */
+    _getClient(): DatabaseClient;
+    /**
+     * Get the query executor for logging
+     * @internal
+     */
+    _getExecutor(): any;
+    /**
+     * Get the collection strategy
+     * @internal
+     */
+    _getCollectionStrategy(): CollectionStrategyType | undefined;
+    /**
+     * Get qualified table name with schema prefix if specified
+     * @internal
+     */
+    private _getQualifiedTableName;
+    /**
+     * Configure query options for the current query chain
+     * Returns a new DbEntityTable instance with a modified context that has the specified options
+     *
+     * @example
+     * ```typescript
+     * const results = await db.users
+     *   .withQueryOptions({ logQueries: true, collectionStrategy: 'temptable' })
+     *   .select(u => ({ id: u.id, name: u.username }))
+     *   .toList();
+     * ```
+     */
+    withQueryOptions(options: QueryOptions): DbEntityTable<TEntity>;
+    /**
+     * Select all records - returns full entities with unwrapped DbColumns
+     */
+    toList(): Promise<UnwrapDbColumns<TEntity>[]>;
+    /**
+     * Count all records
+     */
+    count(): Promise<number>;
+    /**
+     * Order by field(s)
+     */
+    orderBy(selector: (row: TEntity) => any): EntitySelectQueryBuilder<TEntity, TEntity>;
+    orderBy(selector: (row: TEntity) => any[]): EntitySelectQueryBuilder<TEntity, TEntity>;
+    orderBy(selector: (row: TEntity) => Array<[any, 'ASC' | 'DESC']>): EntitySelectQueryBuilder<TEntity, TEntity>;
+    /**
+     * Limit results
+     */
+    limit(count: number): EntitySelectQueryBuilder<TEntity, TEntity>;
+    /**
+     * Offset results
+     */
+    offset(count: number): EntitySelectQueryBuilder<TEntity, TEntity>;
+    /**
+     * Select query
+     */
+    select<TSelection>(selector: (entity: EntityQuery<TEntity>) => TSelection): EntitySelectQueryBuilder<TEntity, TSelection>;
+    /**
+     * Select distinct
+     */
+    selectDistinct<TSelection>(selector: (entity: EntityQuery<TEntity>) => TSelection): EntitySelectQueryBuilder<TEntity, TSelection>;
+    /**
+     * Where query - returns all columns by default
+     */
+    where(condition: (entity: EntityQuery<TEntity>) => any): EntitySelectQueryBuilder<TEntity, TEntity>;
+    /**
+     * Left join with another table or subquery and selector
+     */
+    leftJoin<TRight extends DbEntity, TSelection>(rightTable: DbEntityTable<TRight> | import('../query/subquery').Subquery<TRight, 'table'>, condition: (left: EntityQuery<TEntity>, right: EntityQuery<TRight> | TRight) => Condition, selector: (left: EntityQuery<TEntity>, right: EntityQuery<TRight> | TRight) => TSelection, alias?: string): EntitySelectQueryBuilder<TEntity, TSelection>;
+    /**
+     * Inner join with another table or subquery and selector
+     */
+    innerJoin<TRight extends DbEntity, TSelection>(rightTable: DbEntityTable<TRight> | import('../query/subquery').Subquery<TRight, 'table'>, condition: (left: EntityQuery<TEntity>, right: EntityQuery<TRight> | TRight) => Condition, selector: (left: EntityQuery<TEntity>, right: EntityQuery<TRight> | TRight) => TSelection, alias?: string): EntitySelectQueryBuilder<TEntity, TSelection>;
+    /**
+     * Insert - accepts only DbColumn properties (excludes navigation properties)
+     */
+    insert(data: InsertData<TEntity>): Promise<UnwrapDbColumns<TEntity>>;
+    /**
+     * Insert multiple records
+     */
+    insertMany(data: InsertData<TEntity>[]): Promise<UnwrapDbColumns<TEntity>[]>;
+    /**
+     * Upsert (insert or update on conflict)
+     */
+    upsert(data: InsertData<TEntity>[], config?: EntityUpsertConfig<TEntity>): Promise<UnwrapDbColumns<TEntity>[]>;
+    /**
+     * Bulk insert with advanced configuration
+     * Supports automatic chunking for large datasets
+     */
+    insertBulk(value: InsertData<TEntity> | InsertData<TEntity>[], insertConfig?: InsertConfig): Promise<UnwrapDbColumns<TEntity>[]>;
+    /**
+     * Upsert with advanced configuration
+     * Auto-detects primary keys and supports chunking
+     */
+    upsertBulk(values: InsertData<TEntity>[], config?: EntityUpsertConfig<TEntity>): Promise<UnwrapDbColumns<TEntity>[]>;
+    /**
+     * Map database column names back to property names
+     */
+    private mapResultToEntity;
+    /**
+     * Map array of database results to entities
+     */
+    private mapResultsToEntities;
+    /**
+     * Extract property names from lambda selector
+     */
+    private extractPropertyNames;
+    /**
+     * Start building an upsert query with values
+     */
+    values(data: InsertData<TEntity> | InsertData<TEntity>[]): EntityInsertBuilder<TEntity>;
+    /**
+     * Update records matching condition
+     * Usage: db.users.update({ age: 30 }, u => eq(u.id, 1))
+     */
+    update(data: Partial<InsertData<TEntity>>, condition: (entity: EntityQuery<TEntity>) => Condition): Promise<UnwrapDbColumns<TEntity>[]>;
+    /**
+     * Delete records matching condition
+     * Usage: db.users.delete(u => eq(u.id, 1))
+     */
+    delete(condition: (entity: EntityQuery<TEntity>) => Condition): Promise<void>;
+    /**
+     * Create a mock entity for type inference in lambdas
+     */
+    private createMockEntity;
+}
+/**
+ * Base database context with entity-first approach
+ */
+export declare abstract class DatabaseContext extends DataContext {
+    private modelConfig;
+    private entityTables;
+    private sequenceRegistry;
+    private sequenceInstances;
+    constructor(client: DatabaseClient, queryOptions?: QueryOptions);
+    /**
+     * Override this method to configure your entities
+     */
+    protected abstract setupModel(modelConfig: DbModelConfig): void;
+    /**
+     * Optional: Override this method to register sequences.
+     * This is called during construction to ensure sequences are registered before schema creation.
+     *
+     * @example
+     * ```typescript
+     * protected setupSequences(): void {
+     *   // Access sequence getters to register them
+     *   this.mySeq;
+     *   this.anotherSeq;
+     * }
+     * ```
+     */
+    protected setupSequences?(): void;
+    /**
+     * Hook called after database migrations/schema creation are complete.
+     * Override this method to execute custom SQL scripts that are outside the scope of the ORM.
+     *
+     * @example
+     * ```typescript
+     * protected async onMigrationComplete(client: DatabaseClient): Promise<void> {
+     *   // Create custom functions, views, triggers, etc.
+     *   await client.query(`
+     *     CREATE OR REPLACE FUNCTION custom_function()
+     *     RETURNS void AS $$
+     *     BEGIN
+     *       -- Custom logic here
+     *     END;
+     *     $$ LANGUAGE plpgsql;
+     *   `);
+     * }
+     * ```
+     *
+     * @param client - Database client for executing custom SQL
+     */
+    protected onMigrationComplete(client: DatabaseClient): Promise<void>;
+    /**
+     * Register a sequence in the schema
+     * @param config - Sequence configuration
+     */
+    protected registerSequence(config: SequenceConfig): void;
+    /**
+     * Get a sequence instance for interacting with the database
+     * @param config - Sequence configuration
+     * @returns DbSequence instance with nextValue() and resync() methods
+     */
+    protected sequence(config: SequenceConfig): DbSequence;
+    /**
+     * Get all registered sequences
+     * @internal
+     */
+    getSequenceRegistry(): Map<string, SequenceConfig>;
+    /**
+     * Get schema manager for create/drop operations with post-migration hook support
+     */
+    getSchemaManager(): DbSchemaManager;
+    /**
+     * Get strongly-typed table accessor for an entity
+     * @internal - Use property accessors on derived class instead
+     */
+    protected table<TEntity extends DbEntity>(entityClass: EntityConstructor<TEntity>): DbEntityTable<TEntity>;
+}
+//# sourceMappingURL=db-context.d.ts.map