/**
 * Represents a signal-based computation.
 */
export interface SignalLike<out T> {
    /**
     * Gets the current value of the signal with tracking by default.
     */
    (): T;
}
/**
 * Represents a value that tracks changes over time.
 */
export interface Signal<out T> extends SignalLike<T> {
    /** @ignore */
    _effects: Set<Effect>;
    /**
     * Accesses the current value of the signal without tracking.
     */
    peek(): T;
}
export interface SignalOptions<T> extends SetSignalOptions {
    /**
     * A custom equality function to compare the new value with the old value.
     */
    equals?: (a: T, b: T) => boolean;
}
export interface SetSignalOptions {
    /**
     * Whether to force the update of the signal even if the new value has the
     * same reference.
     */
    force?: boolean;
    /**
     * Whether to suppress the update of the signal's effects.
     */
    silent?: boolean;
}
/**
 * Can be used to update a signal with a new value.
 */
export interface SignalSetter<in T, out U = T> {
    (update: (value: U) => T, opts?: SetSignalOptions): void;
    (value: T extends Function ? never : T, opts?: SetSignalOptions): void;
}
export interface SubscopeOptions {
    details?: object;
}
interface Effect {
    _scope: Scope;
    _pure: boolean;
    _clean?: Cleanup;
    _deps: Set<Signal<unknown>>;
    _run(): void;
}
/**
 * Represents the cleanup function of an effect.
 */
export type Cleanup = (() => void) | void | undefined | null;
export interface Scope<out T = {}> {
    readonly _parent?: Scope;
    _effects: Set<Effect>;
    _subscopes: Set<Scope>;
    _details: T;
    _run<T>(fn: () => T): T;
    _cleanup(): void;
}
/** @ignore */
export declare const useScope: <T = {}>() => Scope<T>;
/**
 * Creates a new signal with the given value.
 * @returns A tuple with the signal and its setter.
 */
export declare const useSignal: (<T>(value: T, opts?: SignalOptions<T>) => readonly [Signal<T>, SignalSetter<T>]) & (<T>(value?: T, opts?: SignalOptions<T | undefined>) => readonly [Signal<T | undefined>, SignalSetter<T | undefined>]);
/**
 * Runs the given function in a batch.
 *
 * @param fn Any calls to signal setters inside the function will be batched
 * and updated at the same time.
 */
export declare const useBatch: <T>(fn: () => T) => T;
export declare const flushBatch: () => void;
/**
 * Creates an effect which will rerun when any accessed signal changes.
 *
 * @param fn The function to run; it can return a cleanup function.
 */
export declare const useEffect: (fn: () => Cleanup, deps?: SignalLike<unknown>[]) => void;
/**
 * Creates a memoized signal.
 *
 * @param fn The computation function.
 */
export declare const useMemo: <T>(fn: () => T, opts?: SignalOptions<T>) => Signal<T>;
/**
 * Executes a function inside a subscope which can be manually destroyed.
 *
 * @param fn The function to run in the subscope.
 * @returns A function to manually destroy the subscope.
 */
export declare const useSubscope: <T>(fn: () => T, opts?: SubscopeOptions) => [T, () => void];
/**
 * Provide write capabilities to a signal.
 */
export interface RefSignal<in out T> extends Signal<T>, RefSignalSetter<T> {
    /**
     * Sets the value of the signal.
     */
    set: SignalSetter<T>;
}
/**
 * A contravariant variant of {@link RefSignal}.
 */
export interface RefSignalSetter<in T> {
    /**
     * Sets the value of the signal.
     */
    set: SignalSetter<T, unknown>;
}
/**
 * Creates a new signal with write capabilities.
 */
export declare const useRef: (<T>(value: T, opts?: SignalOptions<T>) => RefSignal<T>) & (<T>(value?: T, opts?: SignalOptions<T | undefined>) => RefSignal<T | undefined>);
/**
 * Represents a value that can be a signal or a constant value.
 *
 * Note that functions are not allowed as constant values.
 */
export type MaybeSignal<T> = SignalLike<T> | (T extends Function ? never : T);
/**
 * @namespace
 */
export declare const MaybeSignal: {
    /**
     * Transforms the given {@link MaybeSignal} into a {@link Signal}.
     */
    upgrade: <T>(signal: MaybeSignal<T>) => SignalLike<T>;
    /**
     * Gets the value of the given {@link MaybeSignal}.
     */
    get: <T>(signal: MaybeSignal<T>) => T;
    /**
     * Accesses the value of the given {@link MaybeSignal} without tracking.
     */
    peek<T>(signal: MaybeSignal<T>): T;
};
export {};