import type { ReactiveControllerHost } from 'lit';
import { RefObject } from 'preact';
import { Context, Props } from 'js-widgets';
declare type ContextType<C extends Context<any>> = C extends Context<infer T> ? T : never;
export { afterMount, consume, create, createMemo, createTicker, effect, getRefresher, mutable, optimizeUpdates, preset, stateFn, stateObj, stateObj as state, stateRef, stateVal, stateVal as atom, interval, handleMethods, handlePromise, withDefaults };
declare type Getter<T> = () => T;
declare type Updater<T, U = T> = Exclude<U, Function> | ((value: T) => U);
declare type Setter<T> = (updater: Updater<T>) => void;
declare type StateObjSetter<T extends Record<string, any>> = {
    (updater: Updater<T, Partial<T>>): void;
} & {
    [K in keyof T]: (updater: Updater<T[K]>) => void;
};
declare function withDefaults<P extends Props, D extends Partial<P>>(props: P, defaults: D | (() => D)): P & D;
declare function preset<P extends Props, D extends Partial<P>>(props: P, defaults: D | (() => D)): asserts props is P & D;
declare function optimizeUpdates(pred?: () => boolean): void;
declare function getRefresher(): (force?: boolean) => void;
declare function stateVal<T>(value: T): [Getter<T>, Setter<T>];
declare function stateObj<T extends Record<string, any>>(values: T): [T, StateObjSetter<T>];
declare function stateFn<T>(initialValue: T): {
    (): T;
    (updater: Updater<T>): void;
};
declare function stateRef<T>(initialValue: T): {
    current: T;
    set(value: T): void;
    map(mapper: (value: T) => T): void;
};
declare function mutable<T extends Record<string, any>>(initialState: T): T;
declare function createMemo<T, A extends any[], G extends () => A>(getValue: (...args: ReturnType<G>) => T, getDeps: G): {
    readonly value: T;
};
declare function afterMount(action: () => void | (() => void)): void;
declare function effect(action: () => void | undefined | null | (() => void), getDeps?: null | (() => any[])): void;
declare function consume<T>(context: Context<T>): () => T;
declare function consume<T extends Record<string, Context<any>>>(contexts: T): {
    [K in keyof T]: ContextType<T[K]>;
};
declare function handleMethods<M extends Record<string, Function>>(getMethodsRef: () => RefObject<M> | undefined, methods: M): void;
declare function interval(callbackOrRef: (() => void) | {
    current: () => void;
}, delayOrGetDelay: number | (() => number)): void;
declare type PromiseRes<T> = {
    result: null;
    error: null;
    state: 'pending';
} | {
    result: T;
    error: null;
    state: 'resolved';
} | {
    result: null;
    error: Error;
    state: 'rejected';
};
declare function handlePromise<T>(getPromise: () => Promise<T>, getDeps?: () => any[]): PromiseRes<T>;
declare function createTicker(): () => Date;
declare function createTicker<T>(mapper: (time: Date) => T): () => T;
declare type ControllerClass<T, A extends any[]> = {
    new (host: ReactiveControllerHost, ...args: A): T;
};
declare function create<C extends ControllerClass<any, A>, A extends any[]>(controllerClass: C, ...args: A): InstanceType<C>;