export type WriteonlyEventAction<T = void> = {
    emit(value: T): void;
};
export declare class EventAction<T = unknown> implements WriteonlyEventAction<T> {
    private readonly combine?;
    private readonly neutral?;
    private latestTime;
    private readonly subscriptionListeners;
    private readonly readers;
    constructor(combine?: ((...values: Array<T>) => T) | undefined, neutral?: T | undefined);
    emit(value: T): void;
    subscribe(callback: (value: T) => void, options?: {
        once?: true;
        signal?: AbortSignal;
    }): void;
    waitFor(signal?: AbortSignal): Promise<T>;
    getLatestTime(): number;
    createReader(abortSignal: AbortSignal): {
        update(): void;
        get(): T;
    };
    mapFrom<S>(fn: (value: S) => T, abortSignal?: AbortSignal): EventAction<S>;
    filterFrom(fn: (value: T) => boolean, abortSignal?: AbortSignal): EventAction<T>;
}
export type StateActionWriter<T> = {
    write(value: T): void;
};
/**
 * StateAction keeps the latest state per writer and merges them on read.
 * Values persist until the writer is disposed (abortSignal aborts).
 */
export declare class StateAction<T = unknown> {
    private readonly mergeWriters?;
    private readonly neutral?;
    private readonly absoluteActions;
    constructor(mergeWriters?: ((...values: Array<T>) => T) | undefined, neutral?: T | undefined);
    createWriter(abortSignal: AbortSignal): StateActionWriter<T>;
    get(): T;
    mapFrom<S>(fn: (value: S) => T): StateAction<S>;
}