import type { Effect, Stream } from 'effect';
import type { ChangeNotice, DecodedEntity, DecodedSingleEntity } from '../../../core/index.js';
import type { AnyEntityESchema, AnyUnkeyedESchema } from '../../../eschema/index.js';
import type { DatabaseError } from '../error/index.js';
import type { EncodedItem, EncodedKey, StdTableService, TransactCheck, TransactPut } from '../contract/index.js';
import type { AccessPatternDefinition, AccessPatternMap, GlobalSecondaryIndexMap, IndexComponent, KeyedEntityDefinition, LocalSecondaryIndexMap, PatternFor, SingleEntityDefinition } from '../definition/index.js';
export type TableEffect<A, Name extends string> = Effect.Effect<A, DatabaseError, StdTableService<Name>>;
export type EntityValue<S extends AnyEntityESchema> = S['Type'];
export type EntityKey<S extends AnyEntityESchema, Pk extends readonly string[]> = Pick<EntityValue<S>, Extract<Pk[number] | S['idField'], keyof EntityValue<S>>>;
export type InsertValue<S extends AnyEntityESchema> = EntityValue<S>;
export type SingleUpdateInput<S extends AnyUnkeyedESchema> = Partial<S['Type']> | ((current: S['Type']) => Partial<S['Type']>);
export type UpdateValue<S extends AnyEntityESchema> = Partial<EntityValue<S>>;
export type EntityInvariant<T> = (current: T) => boolean;
export type UpdateFn<S extends AnyEntityESchema> = (current: EntityValue<S>) => UpdateValue<S>;
export type UpdateInput<S extends AnyEntityESchema> = UpdateValue<S> | UpdateFn<S>;
/**
 * `check` and `lastWriteWins` are mutually exclusive: an invariant is only
 * meaningful while the `_u` condition still holds the value it judged.
 */
export type WriteOptions<T> = {
    readonly check?: undefined;
    readonly lastWriteWins?: boolean;
} | {
    readonly check: EntityInvariant<T>;
    readonly lastWriteWins?: false;
};
interface TransactTarget<Name extends string> {
    readonly tableName: Name;
    readonly entityName: string;
    readonly key: EncodedKey;
    readonly target: string;
    readonly readsCurrent: boolean;
}
export interface TransactOp<Name extends string = string, T extends object = object> extends TransactTarget<Name> {
    readonly operationKind: 'insertOp' | 'updateOp' | 'deleteOp' | 'restoreOp' | 'singleUpdateOp';
    readonly apply: (current: EncodedItem | null, version: string) => Effect.Effect<{
        readonly write: TransactPut;
        readonly entity: DecodedEntity<T> | DecodedSingleEntity<T>;
    }, DatabaseError>;
}
export interface CheckOp<Name extends string = string> extends TransactTarget<Name> {
    readonly operationKind: 'checkOp';
    readonly apply: (current: EncodedItem | null, version: string) => Effect.Effect<{
        readonly write: TransactCheck;
        readonly entity: null;
    }, DatabaseError>;
}
export type AnyTransactOp<Name extends string = string, T extends object = object> = TransactOp<Name, T> | CheckOp<Name>;
export type SortCondition<Sk> = {
    readonly '=': Sk;
} | {
    readonly '<': Sk | null;
} | {
    readonly '<=': Sk | null;
} | {
    readonly '>': Sk | null;
} | {
    readonly '>=': Sk | null;
} | {
    readonly between: readonly [Sk, Sk];
} | {
    readonly beginsWith: Sk;
};
export interface QueryOptions<T = unknown> {
    readonly limit?: number;
    readonly excludeDeleted?: boolean;
    readonly after?: DecodedEntity<T>;
}
export interface QueryPage<T> {
    readonly items: readonly T[];
    readonly hasMore: boolean;
}
export interface KeyedEntity<Name extends string, S extends AnyEntityESchema, Pk extends readonly string[], Patterns extends AccessPatternMap> extends KeyedEntityDefinition<Name, S, Pk, readonly [S['idField']], Patterns> {
    get(key: EntityKey<S, Pk>, options?: {
        readonly excludeDeleted?: boolean;
    }): TableEffect<DecodedEntity<EntityValue<S>> | null, Name>;
    insert(value: InsertValue<S>): TableEffect<DecodedEntity<EntityValue<S>>, Name>;
    insertOp(value: InsertValue<S>): TableEffect<TransactOp<Name, EntityValue<S>>, Name>;
    getAndUpdate(key: EntityKey<S, Pk>, update: UpdateInput<S>, options?: WriteOptions<EntityValue<S>> & {
        readonly retries?: number;
    }): TableEffect<DecodedEntity<EntityValue<S>>, Name>;
    getAndUpdateOp(key: EntityKey<S, Pk>, update: UpdateInput<S>, options?: WriteOptions<EntityValue<S>>): TableEffect<TransactOp<Name, EntityValue<S>>, Name>;
    getAndCheckOp(key: EntityKey<S, Pk>, check: EntityInvariant<EntityValue<S>>): TableEffect<CheckOp<Name>, Name>;
    delete(key: EntityKey<S, Pk>, options?: WriteOptions<EntityValue<S>>): TableEffect<DecodedEntity<EntityValue<S>>, Name>;
    deleteOp(key: EntityKey<S, Pk>, options?: WriteOptions<EntityValue<S>>): TableEffect<TransactOp<Name, EntityValue<S>>, Name>;
    restore(key: EntityKey<S, Pk>, options?: WriteOptions<EntityValue<S>>): TableEffect<DecodedEntity<EntityValue<S>>, Name>;
    restoreOp(key: EntityKey<S, Pk>, options?: WriteOptions<EntityValue<S>>): TableEffect<TransactOp<Name, EntityValue<S>>, Name>;
    unchangedOp(entity: DecodedEntity<EntityValue<S>>): TableEffect<CheckOp<Name>, Name>;
    existsOp(key: EntityKey<S, Pk>): TableEffect<CheckOp<Name>, Name>;
    notExistsOp(key: EntityKey<S, Pk>): TableEffect<CheckOp<Name>, Name>;
    hardDelete(key: EntityKey<S, Pk>, confirmation: 'I KNOW WHAT I AM DOING'): TableEffect<DecodedEntity<EntityValue<S>>, Name>;
    dangerouslyRemoveAllItems(confirmation: 'I KNOW WHAT I AM DOING'): TableEffect<{
        readonly itemsDeleted: number;
    }, Name>;
    query<Pattern extends keyof Patterns & string>(pattern: Pattern, input: {
        readonly pk: Record<Patterns[Pattern]['pk'][number], string>;
    } & SortCondition<Record<Patterns[Pattern]['sk'][number], string>>, options?: QueryOptions<EntityValue<S>>): TableEffect<QueryPage<DecodedEntity<EntityValue<S>>>, Name>;
    subscribe(filter?: Partial<EntityValue<S>>): Stream.Stream<ChangeNotice<EntityValue<S>>>;
}
export interface SingleEntity<Name extends string, S extends AnyUnkeyedESchema> extends SingleEntityDefinition<Name, S> {
    get(): TableEffect<DecodedSingleEntity<S['Type']>, Name>;
    put(value: S['Type']): TableEffect<DecodedSingleEntity<S['Type']>, Name>;
    getAndUpdate(update: SingleUpdateInput<S>, options?: WriteOptions<S['Type']> & {
        readonly retries?: number;
    }): TableEffect<DecodedSingleEntity<S['Type']>, Name>;
    getAndUpdateOp(update: SingleUpdateInput<S>, options?: WriteOptions<S['Type']>): TableEffect<TransactOp<Name, S['Type']>, Name>;
    unchangedOp(entity: DecodedSingleEntity<S['Type']>): TableEffect<CheckOp<Name>, Name>;
    reset(): TableEffect<DecodedSingleEntity<S['Type']>, Name>;
    subscribe(filter?: Partial<S['Type']>): Stream.Stream<ChangeNotice<S['Type']>>;
}
export interface KeyedBuilderStart<Name extends string, S extends AnyEntityESchema, Lsis extends LocalSecondaryIndexMap = LocalSecondaryIndexMap, Gsis extends GlobalSecondaryIndexMap = GlobalSecondaryIndexMap> {
    primary<const Pk extends readonly Exclude<IndexComponent<S>, '_u'>[] = []>(derivation?: {
        readonly pk: Pk;
    }): KeyedBuilder<Name, S, Lsis, Gsis, Pk, Record<'primary', AccessPatternDefinition<undefined, 'primary', Pk, readonly [S['idField']]>>>;
}
export interface KeyedBuilder<Name extends string, S extends AnyEntityESchema, Lsis extends LocalSecondaryIndexMap, Gsis extends GlobalSecondaryIndexMap, Pk extends readonly string[], Patterns extends AccessPatternMap> {
    index<const Slot extends keyof (Lsis & Gsis) & string, const Pattern extends string, const D extends (Slot extends keyof Lsis ? {
        readonly sk: readonly IndexComponent<S>[];
        readonly pk?: never;
    } : {
        readonly pk: readonly IndexComponent<S>[];
        readonly sk?: readonly IndexComponent<S>[];
    })>(slot: Slot, pattern: Pattern, derivation: D): KeyedBuilder<Name, S, Lsis, Gsis, Pk, Patterns & Record<Pattern, PatternFor<Slot, S, Lsis, Pk, D>>>;
    build(): KeyedEntity<Name, S, Pk, Patterns>;
}
export interface SingleBuilder<Name extends string, S extends AnyUnkeyedESchema> {
    default(value: S['Type']): SingleEntity<Name, S>;
}
export { makeKeyedEntity } from './keyed.js';
export { makeSingleEntity } from './single.js';
export { broadcast, changesOrEmpty, dbError, failReason, subscribe, } from './effects.js';
//# sourceMappingURL=entity.d.ts.map