import { FinalizableEventHandlerRef } from './weak-event-finalization';
import { EventInvocationOpts, IEventSource, ITypedEvent, TypedEventHandler } from '../typed-event-interfaces';
/**
 * An event who's handlers are weakly referenced
 *
 * @description Handlers attached to this event are weakly referenced and as such may be garbage collected
 * if the handler goes out of scope. This prevents certain types of event-related memory leaks.
 *
 * For information regarding this pattern, please visit:
 * * https://v8.dev/features/weak-references
 * * https://docs.microsoft.com/en-us/dotnet/desktop/wpf/advanced/weak-event-patterns
 *
 * @export
 * @class WeakEvent
 * @implements {IEventSource<TSender, TArgs>}
 * @param {TSender} sender The event's source (usually the particular instance raising the event)
 * as should be provided to the event handlers
 * @param {TArgs} args The arguments to provide to the handlers
 */
export declare class WeakEvent<TSender, TArgs> implements IEventSource<TSender, TArgs> {
    private _handlers;
    private _refHolder;
    private _handlerFinalizedEvent;
    /**
     * An event that is raised after a handler has been reclaimed by GC and had its
     * finalizer run
     *
     * @description One possible use for this event is as as diagnostic tool to determine whether event handler leaks
     * exist
     *
     * @type {ITypedEvent<this, FinalizableEventHandlerRef<TSender, TArgs>>}
     * @memberof WeakEvent
     */
    handlerFinalizedEvent: ITypedEvent<this, FinalizableEventHandlerRef<TSender, TArgs>>;
    constructor();
    invoke(sender: TSender, args: TArgs, options?: EventInvocationOpts): void;
    invokeAsync(sender: TSender, args: TArgs, options?: EventInvocationOpts): Promise<void>;
    private sequentialInvokeAsync;
    private parallelInvokeAsync;
    attach(handler: TypedEventHandler<TSender, TArgs>): void;
    detach(handler: TypedEventHandler<TSender, TArgs>): void;
    private onHandlerFinalizer;
    private tryRemoveHandlerRef;
    private releaseHandler;
}