import { Observable } from 'rxjs';
import type { Labelled, Payload, Meta, Event, EventBus } from '../events';
export interface Factory<P extends Payload = Payload, M extends Meta = Meta> extends Labelled {
    (payload: P, meta?: M): Event<P, M>;
    is: <S extends Payload, A extends S, T extends Meta = Meta, B extends T = T>(event: Event<S, T>) => event is Event<A, B>;
    registered?: boolean;
}
export declare type ErrorLabelledEvent<T extends Event> = Pick<Event, 'label'> & {
    error: any;
    caught: Observable<T>;
};
export declare type EventWithHandler = {
    filter: string | ((event: Event) => boolean);
    handler?: (event: Event) => void | Observable<Event> | Promise<void> | Promise<Observable<Event>>;
    skip?: number;
    take?: number;
    throws?: boolean;
    timeout?: number;
};
export declare const DEFAULT_EVENT_TIMEOUT = 3000;
export declare const TEST_THROW_ERROR_LABEL = "test-error-label";
/**
 * Helper function to simplify concatenation of events within a `ReplaySubject`. It takes
 * an array of enriched events where an event has a mandatory `filter` filtering function and
 * optional `skip` parameter to reach the exact event among similar ones.
 * Also events carry a `handler` which does post-processing when the event is caught.
 * If an observable is returned than the handler
 * pipes it into the ReplaySubject. This allows to simulate action-reaction on events
 * @param eventBus the `ReplaySubject` used to pipe events
 * @param events `EventWithHandler`-type events enriched with a handler
 * @returns a `Promise` which resolves when all events have been reached and handled,
 * on error it rejects
 * @see {@link EventWithHandler}
 */
export declare function actOnEvents(eventBus: EventBus, events: Array<EventWithHandler>, eventTimeout?: number, throwLabel?: string): Promise<void[]>;
export declare function completeAndCount(eventBus: EventBus): Promise<number>;