import type { LitElement, ReactiveController } from "lit";
/**
 * Groups multiple signal updates into a single transaction.
 * Effects will only run once the outermost batch completes.
 */
export declare function batch(fn: () => void): void;
type Job = () => void;
type Unsubscribe = () => void;
interface Debuggable {
    _debugParent?: Watcher;
}
interface Watcher extends Debuggable {
    track(signal: Observable<unknown>): void;
}
declare abstract class Observable<T> {
    #private;
    name?: string;
    constructor(initial: T, name?: string);
    protected _get(): T;
    protected _set(next: T): boolean;
    subscribe(fn: Job, weak?: boolean): Unsubscribe;
    _notify(): void;
    get id(): number;
    get previousValue(): T | undefined;
    toString(): string;
}
export declare class Signal<T> extends Observable<T> {
    #private;
    constructor(initial: T, name?: string);
    static get activeConsumer(): Watcher;
    static push(consumer: Watcher): void;
    static pop(): void;
    get(): T;
    set(value: T): void;
    get value(): T;
    set value(value: T);
    update(fn: (current: T) => T): void;
}
export declare class Computed<T> extends Observable<T> implements Watcher {
    #private;
    _debugParent: Watcher | undefined;
    constructor(fn: () => T, name?: string, options?: {
        weak?: boolean;
    });
    track(signal: Observable<unknown>): void;
    dispose(): void;
    get(): T;
    get value(): T;
    set value(value: T);
    subscribe(fn: Job, weak?: boolean): Unsubscribe;
}
export declare function effect(fn: () => (void | (() => void)), name?: string): () => void;
export declare class SignalWatcher implements Watcher, ReactiveController {
    #private;
    _debugParent: Watcher | undefined;
    constructor(host: LitElement);
    track(signal: Observable<unknown>): void;
    hostUpdate(): void;
    hostDisconnected(): void;
    toString(): string;
}
export {};
//# sourceMappingURL=avosignals.d.ts.map