import _for from './for.js';
import _if from './if.js';
import _switch from './switch.js';
import type { ObservableOptions, Observable } from '../types.js';
declare function $<T>(): Observable<T | undefined>;
declare function $<T>(value: undefined, options?: ObservableOptions<T | undefined>): Observable<T | undefined>;
declare function $<T extends boolean>(value: boolean, options?: ObservableOptions<T>): Observable<T>;
declare function $<T extends number>(value: number, options?: ObservableOptions<T>): Observable<T>;
declare function $<T extends string>(value: string, options?: ObservableOptions<T>): Observable<T>;
declare function $<T>(value: T, options?: ObservableOptions<T>): Observable<T>;
declare namespace $ {
    export var batch: <T>(fn: import("../types.js").BatchFunction<T>, stack?: import("./debugger.js").Stack) => Promise<Awaited<T>>;
    export var boolean: (value: import("../types.js").FunctionMaybe<unknown>) => import("../types.js").FunctionMaybe<boolean>;
    export var cleanup: (fn: import("../types.js").Callable<import("../types.js").CleanupFunction>) => void;
    export var context: typeof import("./context.js").default;
    export var disposed: (stack?: import("./debugger.js").Stack) => import("../types.js").ObservableReadonly<boolean>;
    export var effect: (fn: import("../types.js").EffectFunction, options?: import("../types.js").EffectOptions) => import("../types.js").DisposeFunction;
    var _a: typeof _for;
    export var get: typeof import("./get.js").default;
    var _b: typeof _if;
    export var isBatching: () => boolean;
    export var isObservable: <T = unknown>(value: unknown) => value is Observable<T> | import("../types.js").ObservableReadonly<T>;
    export var isStore: (value: unknown) => boolean;
    export var memo: <T>(fn: import("../types.js").MemoFunction<T>, options?: import("../types.js").MemoOptions<T | undefined>) => import("../types.js").ObservableReadonly<T>;
    export var observable: typeof import("./observable.js").default;
    export var owner: () => import("../types.js").Owner;
    export var readonly: <T>(observable: Observable<T> | import("../types.js").ObservableReadonly<T>, stack?: import("./debugger.js").Stack) => import("../types.js").ObservableReadonly<T>;
    export var resolve: typeof import("./resolve.js").default;
    export var root: <T>(fn: import("../types.js").WrappedDisposableFunction<T>) => T;
    export var selector: <T>(source: () => T) => import("../types.js").SelectorFunction<T>;
    export var store: {
        <T>(value: T, options?: import("../types.js").StoreOptions): T;
        on(target: import("../types.js").ArrayMaybe<{
            [x: string]: any;
            [x: number]: any;
            [x: symbol]: any;
        } | (() => void)>, listener: import("../types.js").CallbackFunction): import("../types.js").DisposeFunction;
        _onRoots<K extends string | number | symbol, V extends unknown>(target: Record<K, V>, listener: (roots: V[]) => void): import("../types.js").DisposeFunction;
        reconcile: <T extends any[] | Record<string | number | symbol, any>>(prev: T, next: T) => T;
        untrack<T>(value: T): T;
        unwrap<T>(value: T): T;
    };
    export var suspended: (stack?: import("./debugger.js").Stack) => import("../types.js").ObservableReadonly<boolean>;
    export var suspense: <T>(when: import("../types.js").FunctionMaybe<unknown>, fn: import("../types.js").SuspenseFunction<T>, stack?: import("./debugger.js").Stack) => T;
    var _c: typeof _switch;
    export var ternary: <T, F>(when: import("../types.js").FunctionMaybe<unknown>, valueTrue: T, valueFalse: F) => import("../types.js").ObservableReadonly<import("../types.js").Resolved<T | F>>;
    export var tick: (stack?: import("./debugger.js").Stack) => void;
    export var tryCatch: <T, F>(value: T, fn: import("../types.js").TryCatchFunction<F>) => import("../types.js").ObservableReadonly<import("../types.js").Resolved<T | F>>;
    export var untrack: typeof import("./untrack.js").default;
    export var untracked: typeof import("./untracked.js").default;
    var _d: () => (<T>(fn: import("../types.js").WithFunction<T>, stack?: import("./debugger.js").Stack) => T);
    export { _a as for, _b as if, _c as switch, _d as with };
}
export default $;