interface Nested<Ret = unknown, Args extends any[] = any[]> {
    (key: string, ...args: Args): Ret;
    has(key: string): boolean;
    map: Map<string, Ret>;
}
type ExtractArgs<T extends object> = T[keyof T] extends (...args: infer A) => any ? A : any[];
interface DurableState<T extends object, R = unknown, Args extends unknown[] = ExtractArgs<T>> {
    <K = keyof T>(key?: K, ...args: Args): R;
    (target?: T, ext?: T[keyof T], ...args: Args): R;
}
type MutableState<T extends object, Args extends unknown[] = ExtractArgs<T>> = T & {
    <K extends keyof T>(key?: K, fun?: T[K]): MutableState<T, Args>;
    (target?: T, ext?: any): MutableState<T, Args>;
};

type EventState<T extends object, Args extends unknown[] = ExtractArgs<T>> = T & {
    (key?: keyof T, fun?: T[keyof T]): EventState<T, Args>;
    (target?: Partial<T>): EventState<T, Args>;
};
type NestedFun<Ret, Args extends any[] = any[]> = Fun<[key: string, ...args: Args], Ret>;
type DurableFun<T extends object, Args extends unknown[] = ExtractArgs<T> & any> = Fun<[key: string, ...args: Args]>;
type EventFun<T extends object, Args extends unknown[] = ExtractArgs<T>> = Fun<[...args: Args], EventState<T>>;
type Fun<Args extends unknown[] = unknown[], Ret extends unknown = unknown> = (...args: Args) => Ret;
type OverloadedArgs<T extends (...args: any[]) => unknown> = T extends {
    (...args: infer A1): any;
    (...args: infer A2): any;
} ? A1 | A2 : Parameters<T>;
type DurableArgs<T extends object> = OverloadedArgs<DurableState<T>>;
type MutableArgs<T extends object> = OverloadedArgs<MutableState<T>>;
type EventArgs<T extends object> = OverloadedArgs<DurableState<{
    [key in keyof T]?: [EventFun<T>];
}>>;
type RefEvent<T extends object, Target = unknown> = EventState<T & {
    ref: (target: Target) => void;
    mount: (target: Target) => void;
    clean: (target: Target) => void;
    target: Target;
}>;

declare function nested<T, Args extends any[] = any[]>(init: NestedFun<T, Args>): Nested<T, Args>;
declare const durable: <T extends object, Ret = unknown>(fun: DurableFun<T>, ret?: Ret) => DurableState<T, Ret extends undefined ? (arg: T, ...args: unknown[]) => Ret | /*elided*/ any : Ret>;
declare const mutable: <T extends object>(...args: MutableArgs<T> | []) => MutableState<T>;
declare function event<T extends object>(...args: EventArgs<T> | []): EventState<T>;

declare const useOnce: <T>(fun: () => T) => T;
declare const useMutable: <T extends object>(...args: MutableArgs<T>) => MutableState<T, ExtractArgs<T>>;
declare const useEvent: <T extends object>(...args: MutableArgs<T>) => EventState<object>;
declare const useRefEvent: <T extends object>(...args: MutableArgs<T>) => RefEvent<T>;

export { type DurableArgs, type DurableFun, type DurableState, type EventArgs, type EventFun, type EventState, type ExtractArgs, type Fun, type MutableArgs, type MutableState, type Nested, type NestedFun, type OverloadedArgs, type RefEvent, useEvent as default, durable, event, mutable, nested, useEvent, useMutable, useOnce, useRefEvent };