import type { Effect, Stream } from 'effect';
import type { AnyEntityESchema, AnyUnkeyedESchema } from '../../../eschema/index.js';
import type { ChangeNotice, DecodedEntity, DecodedSingleEntity } from '../../../core/index.js';
import type { SnapshotIncompatible } from '../../../snapshot/index.js';
import type { DatabaseError } from '../error/index.js';
import type { EncodedItem, StdTableService } from '../contract/index.js';
import { type GlobalSecondaryIndex, type GlobalSecondaryIndexMap, type LocalSecondaryIndex, type LocalSecondaryIndexMap, type PrimaryIndex, type TableDefinition as DefinitionTableDefinition } from '../definition/index.js';
import type { AnyTransactOp, KeyedBuilderStart, SingleBuilder, TableEffect, TransactOp } from '../entity/index.js';
export interface ScanOptions {
    readonly parallelism?: number;
}
export interface DriftResult {
    readonly drifted: boolean;
    readonly currentForm: EncodedItem;
}
type TableStream<A, Name extends string> = Stream.Stream<A, DatabaseError, StdTableService<Name>>;
export interface StdTable<Name extends string = string, Primary extends PrimaryIndex = PrimaryIndex, Lsis extends LocalSecondaryIndexMap = LocalSecondaryIndexMap, Gsis extends GlobalSecondaryIndexMap = GlobalSecondaryIndexMap> {
    readonly logicalName: Name;
    readonly primary: Primary;
    readonly localSecondaryIndexes: Lsis;
    readonly globalSecondaryIndexes: Gsis;
    readonly registeredEntities: DefinitionTableDefinition<Name>['registeredEntities'];
    snapshot(): ReturnType<DefinitionTableDefinition<Name>['snapshot']>;
    entity<S extends AnyEntityESchema>(schema: S): KeyedBuilderStart<Name, S, Lsis, Gsis>;
    singleEntity<S extends AnyUnkeyedESchema>(schema: S): SingleBuilder<Name, S>;
    transact<const Ops extends readonly AnyTransactOp<Name>[]>(ops: Ops): TableEffect<{
        readonly [K in keyof Ops]: Ops[K] extends {
            readonly operationKind: 'checkOp';
        } ? null : Ops[K] extends TransactOp<Name, infer T> ? DecodedEntity<T> | DecodedSingleEntity<T> : never;
    }, Name>;
    dangerouslyRemoveAllItems(confirmation: 'I KNOW WHAT I AM DOING'): TableEffect<{
        readonly itemsDeleted: number;
    }, Name>;
    subscribe(): Stream.Stream<ChangeNotice>;
    scan(options?: ScanOptions): TableStream<EncodedItem, Name>;
    drift(item: EncodedItem): TableEffect<DriftResult, Name>;
    reindex(currentForm: EncodedItem): TableEffect<void, Name>;
    verifySnapshot(): Effect.Effect<void, DatabaseError | SnapshotIncompatible, StdTableService<Name>>;
}
export interface TableBuilder<Name extends string> {
    readonly logicalName: Name;
    primary<Pk extends string, Sk extends string>(pk: Pk, sk: Sk): TopologyBuilder<Name, PrimaryIndex<Pk, Sk>, {}, {}>;
}
export interface TopologyBuilder<Name extends string, Primary extends PrimaryIndex, Lsis extends LocalSecondaryIndexMap, Gsis extends GlobalSecondaryIndexMap> {
    lsi<Slot extends string, Sk extends string>(name: Slot, sk: Sk): TopologyBuilder<Name, Primary, Lsis & Record<Slot, LocalSecondaryIndex<Slot, Primary['pk'], Sk>>, Gsis>;
    gsi<Slot extends string, Pk extends string, Sk extends string>(name: Slot, pk: Pk, sk: Sk): TopologyBuilder<Name, Primary, Lsis, Gsis & Record<Slot, GlobalSecondaryIndex<Slot, Pk, Sk>>>;
    build(): StdTable<Name, Primary, Lsis, Gsis>;
}
export declare const StdTable: {
    make<const Name extends string>(name: Name): TableBuilder<Name>;
};
export {};
//# sourceMappingURL=table.d.ts.map