import { Tracer, TracerMeta } from './trace.js';
import { ReactiveValue, Equals, ReactiveOptions } from '../types.js';
import { SignalScope } from './contexts.js';
import { Edge } from './edge.js';
import { Callback } from './callback.js';
/**
 * This file contains computed signal base types and struct definitions.
 *
 * Computed signals are monomorphic to make them more efficient, but this also
 * means that multiple fields differ based on the type of the signal. Defining
 * them using this pattern rather than a class allows us to switch on the `type`
 * field to get strong typing in branches everywhere else.
 *
 * "Methods" for this struct are defined in other files for better organization.
 */
export type SignalId = number;
export declare const enum ReactiveFnState {
    Clean = 0,
    Pending = 1,
    Dirty = 2,
    MaybeDirty = 3,
    PendingDirty = 4
}
export declare const enum ReactiveFnFlags {
    State = 7,
    isRelay = 8,
    isListener = 16,
    isActive = 32,
    isLazy = 64
}
interface ListenerMeta {
    updatedAt: number;
    current: Map<() => void, () => void>;
    cachedBoundAdd: (listener: () => void) => () => void;
}
/**
 * Shared definition for derived signals to reduce memory usage.
 * Contains configuration that's common across all instances of a reactive function.
 */
export interface ReactiveDefinition<T, Args extends unknown[]> extends ReactiveOptions<T, Args> {
    compute: (...args: Args) => T;
    equals: Equals<T>;
    isRelay: boolean;
    tracer: Tracer | undefined;
}
/**
 * Unified way to create a reactive definition (protects shaping)
 */
export declare function createReactiveDefinition<T, Args extends unknown[]>(id: string | undefined, desc: string | undefined, compute: (...args: Args) => T, equals: Equals<T> | false | undefined, isRelay: boolean, paramKey: ((...args: Args) => string | number) | undefined, tracer: Tracer | undefined): ReactiveDefinition<T, Args>;
export declare class ReactiveSignal<T, Args extends unknown[]> {
    private flags;
    scope: SignalScope | undefined;
    id: number;
    subs: Map<WeakRef<ReactiveSignal<any, any>>, Edge>;
    deps: Map<ReactiveSignal<any, any>, Edge>;
    ref: WeakRef<ReactiveSignal<T, Args>>;
    dirtyHead: Edge | undefined;
    updatedCount: number;
    computedCount: number;
    watchCount: number;
    key: SignalId | undefined;
    args: Args;
    callbacks: Callback[] | undefined;
    _listeners: ListenerMeta | null;
    _value: ReactiveValue<T> | undefined;
    tracerMeta?: TracerMeta;
    desc: string | undefined;
    def: ReactiveDefinition<T, Args>;
    constructor(def: ReactiveDefinition<T, Args>, args: Args, key?: SignalId, scope?: SignalScope);
    get _state(): ReactiveFnState;
    set _state(state: ReactiveFnState);
    get _isListener(): boolean;
    get _isActive(): boolean;
    set _isActive(isActive: boolean);
    get _isLazy(): boolean;
    set _isLazy(isLazy: boolean);
    get listeners(): {
        updatedAt: number;
        current: Map<any, any>;
        cachedBoundAdd: (listener: () => void, opts?: {
            skipInitial?: boolean;
        }) => () => void;
    };
    get value(): ReactiveValue<T>;
    addListener(listener: () => void, opts?: {
        skipInitial?: boolean;
    }): () => void;
    addListenerLazy(watch?: boolean): (listener: () => void, opts?: {
        skipInitial?: boolean;
    }) => () => void;
}
export declare const runListeners: (signal: ReactiveSignal<any, any>) => void;
export declare const isRelay: (signal: ReactiveSignal<any, any>) => boolean;
export declare function createReactiveSignal<T, Args extends unknown[]>(def: ReactiveDefinition<T, Args>, args?: Args, key?: SignalId, scope?: SignalScope): ReactiveSignal<T, Args>;
export {};
//# sourceMappingURL=reactive.d.ts.map