import type { FetchResult, SchemaQuery } from './query/types/index.js';
import { CollectionNameFromModels, type Models, type RecordType, type SetType } from './schema/index.js';
import { DBChanges, CollectionName, KVStoreTransaction, EntityStore, KVStoreOrTransaction, DBEntity, ApplyChangesOptions } from './types.js';
import { DBSchema } from './db.js';
import { DBSession } from './session.js';
import { TypeConverters } from './schema/converters.js';
import { ReadModel, UpdatePayload, WriteModel } from './types/db.js';
export interface DBTransactionOptions<M extends Models<M> = Models> {
    entityStore: EntityStore;
    schema: DBSchema<M> | undefined;
    kvTx: KVStoreTransaction;
    systemVars: Record<string, any>;
    session: DBSession | undefined;
    typeConverters: TypeConverters | undefined;
    skipRules: boolean;
}
export declare class DBTransaction<M extends Models<M> = Models> {
    private readonly kvTx;
    private readonly entityStore;
    readonly changes: DBChanges;
    private readonly schema;
    private readonly systemVars;
    private readonly session;
    private readonly typeConverters;
    private readonly skipRules;
    constructor(options: DBTransactionOptions<M>);
    fetch<Q extends SchemaQuery<M>>(query: Q): Promise<FetchResult<M, Q, 'many'>>;
    fetchOne<Q extends SchemaQuery<M>>(query: Q): Promise<FetchResult<M, Q, 'one'>>;
    fetchById<CN extends CollectionNameFromModels<M>>(collectionName: CN, id: string): Promise<FetchResult<M, {
        collectionName: CN;
    }, 'one'>>;
    insert<CN extends CollectionNameFromModels<M>>(collectionName: CN, data: WriteModel<M, CN>): Promise<ReadModel<M, CN>>;
    update<CN extends CollectionNameFromModels<M>>(collectionName: CN, id: string, update: UpdatePayload<M, CN>): Promise<void>;
    delete<CN extends CollectionNameFromModels<M>>(collectionName: CN, id: string): Promise<void>;
    private getOrCreateCollectionChanges;
}
export declare class EntityStoreWithChanges implements EntityStore {
    readonly changes: DBChanges;
    baseStore: EntityStore;
    constructor(baseStore: EntityStore, changes?: DBChanges);
    applyChanges(tx: KVStoreTransaction, changes: DBChanges, options: ApplyChangesOptions): Promise<DBChanges>;
    getEntity(storage: KVStoreOrTransaction, collection: string, id: string): Promise<DBEntity | undefined>;
    getEntitiesInCollection(storage: KVStoreOrTransaction, collection: CollectionName): AsyncIterable<DBEntity>;
    getCollectionStats(storage: KVStoreOrTransaction, knownCollections?: CollectionName[]): Promise<Map<string, number>>;
}
export declare function createUpdateProxyAndTrackChanges(entity: any, changes: any, type: RecordType<any> | undefined): any;
export declare function createSetProxy<T>(set: Set<T>, changes: Record<string, boolean>, type: SetType<any> | undefined): Set<T>;