//#region src/mini-signals-types.d.ts

// Same as node's EventMap
type EventMap<T> = Record<keyof T, any[]>;
type MiniSignalMap<T extends EventMap<any>> = { [K in keyof T]: MiniSignal<T[K], any> };
type EventKey<T extends EventMap<any> | MiniSignalMap<any>> = keyof T;
type EventHandler<T extends any[]> = (...args: T) => Promise<unknown> | unknown;
interface MiniSignalBinding<T, S$1> {
  [key: symbol]: symbol;
  __brand?: S$1;
  __type?: T;
}
//#endregion
//#region src/mini-signals.d.ts
interface MiniSignalNode<T extends any[]> {
  fn: EventHandler<T>;
  next?: MiniSignalNode<T>;
  prev?: MiniSignalNode<T>;
}
/**
* @document __docs__/mini-signal.md
*/
declare class MiniSignal<T extends any[] = any[], S$1 = never> {
  /**
  * A Symbol that is used to guarantee the uniqueness of the MiniSignal instance.
  */
  private readonly _symbol;
  private _refMap;
  private _head?;
  private _tail?;
  private _dispatching;
  /**
  * Check if there are any listeners attached.
  */
  hasListeners(): boolean;
  /**
  * Register a new listener.
  */
  add(fn: EventHandler<T>): MiniSignalBinding<T, S$1>;
  /**
  * Dispatches a signal to all registered listeners.
  */
  dispatch(...args: T): boolean;
  /**
  * Dispatches listeners serially, waiting for each to complete if they return a Promise.
  * Returns a Promise that resolves to true if listeners were called, false otherwise.
  */
  dispatchSerial(...args: T): Promise<boolean>;
  /**
  * Dispatches listeners in parallel, waiting for all to complete if they return Promises.
  * Returns a Promise that resolves to true if listeners were called, false otherwise.
  */
  dispatchParallel(...args: T): Promise<boolean>;
  /**
  * Remove binding object.
  */
  detach(sym: MiniSignalBinding<T, S$1>): this;
  /**
  * Detach all listeners.
  */
  detachAll(): this;
  private _destroyNode;
  private _disconnectNode;
  private _addNode;
  private _createBinding;
}
//#endregion
//#region src/mini-signals-emitter.d.ts
type SignalMap<T> = T extends EventMap<any> ? MiniSignalMap<T> : T extends MiniSignalMap<any> ? T : never;
type Listener<T> = T extends any[] ? EventHandler<T> : T extends MiniSignal<infer U, any> ? EventHandler<U> : never;
type Args<T> = T extends any[] ? T : T extends MiniSignal<infer U, any> ? U : never;
type _B<S$1, K$1> = [S$1] extends [never] ? K$1 : S$1;
type Brand<T, K$1> = T extends any[] ? K$1 : T extends MiniSignal<any, infer S> ? _B<S, K$1> : never;
type Signal<T, K$1> = MiniSignal<Args<T>, Brand<T, K$1>>;
type Binding<T, K$1> = MiniSignalBinding<Args<T>, Brand<T, K$1>>;
/**
* @document __docs__/mini-signal-emitter.md
*/
declare class MiniSignalEmitter<T extends EventMap<any> | MiniSignalMap<EventMap<any>> = any> {
  protected readonly signals: SignalMap<T>;
  constructor(signals: SignalMap<T>);
  protected getSignal<K$1 extends EventKey<T>>(event: K$1): Signal<T[K$1], K$1>;
  /**
  * Register a listener for a specific event
  */
  on<K$1 extends EventKey<T>>(event: K$1, handler: Listener<T[K$1]>): Binding<T[K$1], K$1>;
  /**
  * Register a one-time listener for a specific event
  */
  once<K$1 extends EventKey<T>>(event: K$1, handler: Listener<T[K$1]>): Binding<T[K$1], K$1>;
  /**
  * Emit an event with data
  */
  emit<K$1 extends EventKey<T>>(event: K$1, ...args: Args<T[K$1]>): boolean;
  emitParallel<K$1 extends EventKey<T>>(event: K$1, ...args: Args<T[K$1]>): Promise<boolean>;
  emitSerial<K$1 extends EventKey<T>>(event: K$1, ...args: Args<T[K$1]>): Promise<boolean>;
  off<K$1 extends EventKey<T>, B extends Binding<T[K$1], K$1>>(event: K$1, binding: B): void;
  clear<K$1 extends EventKey<T>>(event?: K$1): void;
}
//#endregion
//#region src/mini-signals-utils.d.ts
/**
* Helper to create a signal map for SignalEmitter
*/
declare function createSignalMap<T extends EventMap<any>>(events: Array<keyof T>): MiniSignalMap<T>;
//#endregion
export { EventHandler, EventKey, EventMap, MiniSignal, MiniSignalBinding, MiniSignalEmitter, MiniSignalMap, MiniSignalNode, createSignalMap };
//# sourceMappingURL=index.d.cts.map