import { Future } from "./future.js";
import { UnregFn } from "./lru-map-set.js";
import { Result } from "./result.js";
import { Option } from "./option.js";
import { KeyedIf, KeyedNg, KeyedNgItem, KeyedNgItemWithoutValue, KeyedNgOptions } from "./keyed-ng.js";
interface ResolveSeqItem<C, T, R> {
    readonly future: Future<T>;
    readonly fn: (c: C) => R;
    readonly id?: number;
}
export declare class ResolveSeq<T, CTX extends NonNullable<object> = object> {
    readonly ctx?: CTX;
    readonly _seqFutures: ResolveSeqItem<CTX, T, unknown>[];
    constructor(ctx?: CTX);
    reset(): void;
    readonly _flushWaiting: Future<void>[];
    flush(): Promise<void>;
    _step(item?: ResolveSeqItem<CTX, T, Promise<T> | T>): Promise<void>;
    add<R extends Promise<T> | T>(fn: (c: CTX) => R, id?: number): R;
}
type ResolveState = "initial" | "processed" | "waiting" | "processing";
export type ResultOnce<R> = R extends Promise<unknown> ? Promise<Awaited<R>> : R;
export interface OnceActionArg<R, CTX> {
    readonly ctx: CTX;
    readonly self: ResolveOnceIf<R, CTX>;
}
export interface ResolveOnceIf<R, CTX> {
    get ready(): boolean;
    get value(): R | undefined;
    get error(): Error | undefined;
    get state(): ResolveState;
    setResetAfter(ms?: number): void;
    once<RET extends R | Promise<R>>(fn: (arg: OnceActionArg<R, CTX>) => RET): ResultOnce<RET>;
    reset<RET extends R | Promise<R>>(fn?: (arg: OnceActionArg<R, CTX>) => RET): ResultOnce<RET>;
    setProcessed(state: StateInstance): void;
}
export interface SyncOrAsyncIf<T> {
    get value(): T | undefined;
    get error(): Error | undefined;
    get queueLength(): number;
    resolve<RET extends T | Promise<T>>(fn: () => RET): ResultOnce<RET>;
}
export type SyncOrAsync<T> = Option<SyncOrAsyncIf<T>>;
export declare class SyncResolveOnce<T, CTX> implements SyncOrAsyncIf<T> {
    #private;
    readonly queueLength = 0;
    constructor(rOnce: ResolveOnce<T, CTX>, state: StateInstance);
    get value(): T | undefined;
    get error(): Error | undefined;
    get ready(): boolean;
    resolve<RET extends T | Promise<T>>(fn: () => RET): ResultOnce<RET>;
}
export declare class AsyncResolveOnce<T, CTX> implements SyncOrAsyncIf<T> {
    #private;
    constructor(rOnce: ResolveOnceIf<T, CTX>, state: StateInstance, prev: SyncOrAsync<T>);
    get queueLength(): number;
    get value(): T | undefined;
    get error(): Error | undefined;
    resolve<RET extends T | Promise<T>>(fn: () => RET): ResultOnce<RET>;
}
export interface ResolveOnceOpts {
    readonly resetAfter?: number;
    readonly skipUnref?: boolean;
}
declare class StateInstance {
    #private;
    readonly id: number;
    getResolveState(): ResolveState;
    isInitial(): boolean;
    isProcessed(): boolean;
    setProcessed(): void;
    isProcessing(): boolean;
    setProcessing(): void;
    isWaiting(): boolean;
    setWaiting(): void;
    equals(other: StateInstance): boolean;
}
export declare class ResolveOnce<T, CTX = void> implements ResolveOnceIf<T, CTX> {
    #private;
    resetAfterTimer?: ReturnType<typeof setTimeout>;
    readonly _onceArg: OnceActionArg<T, CTX>;
    constructor(ctx?: CTX, opts?: ResolveOnceOpts);
    get state(): ResolveState;
    setProcessed(state: StateInstance): void;
    get ready(): boolean;
    get value(): T | undefined;
    get queueLength(): number;
    get error(): Error | undefined;
    once<RET extends T | Promise<T>>(fn: (arg: OnceActionArg<T, CTX>) => RET): ResultOnce<RET>;
    reset<RET extends T | Promise<T>>(fn?: (arg: OnceActionArg<T, CTX>) => RET): ResultOnce<RET>;
    setResetAfter(ms?: number): void;
}
export interface KeyItem<K, V> {
    readonly key: K;
    readonly value: Result<V>;
}
export type AddKeyedParam<K, V, CTX extends NonNullable<object>> = Omit<KeyedNgOptions<K, V, CTX>, "createValue">;
export type WithKey<X extends NonNullable<object>, K> = X & {
    readonly key: K;
};
export interface KeyedResolveOnceItem<K, T, CTX extends NonNullable<object>> {
    readonly key: K;
    readonly value: Result<T>;
    readonly item: KeyedNgItem<K, ResolveOnce<T, KeyedNgItemWithoutValue<K, CTX>>, CTX>;
}
export declare class KeyedResolvOnce<T, K = string, CTX extends NonNullable<object> = object> implements Omit<KeyedIf<KeyedNgItem<K, ResolveOnce<T, KeyedNgItemWithoutValue<K, CTX>>, CTX>, ResolveOnce<T, KeyedNgItemWithoutValue<K, CTX>>, K, CTX>, "entries" | "forEach" | "onSet" | "onDelete" | "values" | "setParam"> {
    readonly _keyed: KeyedNg<K, ResolveOnce<T, KeyedNgItemWithoutValue<K, CTX>>, CTX>;
    constructor(kp?: Partial<AddKeyedParam<K, T, CTX>>);
    keys(): K[];
    values(): KeyedResolveOnceItem<K, T, CTX>[];
    onSet(fn: (key: K, value: ResolveOnce<T, KeyedNgItemWithoutValue<K, CTX>>) => void): UnregFn;
    onDelete(fn: (key: K, value: ResolveOnce<T, KeyedNgItemWithoutValue<K, CTX>>) => void): UnregFn;
    setParam(params: Partial<AddKeyedParam<K, ResolveOnce<T, CTX>, CTX>>): void;
    asyncGet(key: () => Promise<K>): Promise<ResolveOnce<T, KeyedNgItemWithoutValue<K, CTX>>>;
    get(key: K | (() => K), ctx?: CTX): ResolveOnce<T, KeyedNgItemWithoutValue<K, CTX>>;
    getItem(key: K, ctx?: CTX): KeyedNgItem<K, ResolveOnce<T, KeyedNgItemWithoutValue<K, CTX>>, CTX>;
    has(key: K | (() => K)): boolean;
    delete(key: K): void;
    unget(key: K): void;
    reset(): void;
    forEach(fn: (ki: KeyItem<K, T>, idx: number) => void): void;
    entries(): Iterable<KeyItem<K, T>>;
}
export declare class KeyedResolvSeq<VALUEType extends NonNullable<unknown>, KEYType = string, CTX extends NonNullable<object> = object> extends KeyedNg<KEYType, ResolveSeq<VALUEType, KeyedNgItemWithoutValue<KEYType, CTX>>, CTX> {
    constructor(kp?: Partial<Omit<KeyedNgOptions<KEYType, VALUEType, CTX>, "createValue">>);
}
export declare function Lazy<Args extends readonly unknown[], Return>(fn: (...args: Args) => Return, opts?: ResolveOnceOpts): (...args: Args) => Return;
export {};
//# sourceMappingURL=resolve-once.d.ts.map