@orchestr-sh/orchestr 1.10.0 → 1.11.1

package/dist/Support/Facade.d.cts

@@ -0,0 +1,43 @@
+import { Application } from "../Foundation/Application.cjs";
+
+//#region src/Support/Facade.d.ts
+/**
+ * Facade - Laravel's Facade base class
+ * Provides static proxy to underlying service in the container
+ */
+declare abstract class Facade {
+  private static app;
+  private static resolvedInstances;
+  /**
+   * Set the application instance for facades
+   */
+  static setFacadeApplication(app: Application): void;
+  /**
+   * Get the application instance
+   */
+  static getFacadeApplication(): Application;
+  /**
+   * Get the registered name of the component
+   * This should be overridden by child classes
+   */
+  protected static getFacadeAccessor(): string;
+  /**
+   * Resolve the facade root instance from the container
+   */
+  protected static resolveFacadeInstance(name: string): any;
+  /**
+   * Get the root object behind the facade
+   */
+  protected static getFacadeRoot(): any;
+  /**
+   * Clear a resolved facade instance
+   */
+  static clearResolvedInstance(name: string): void;
+  /**
+   * Clear all resolved instances
+   */
+  static clearResolvedInstances(): void;
+}
+//#endregion
+export { Facade };
+//# sourceMappingURL=Facade.d.cts.map

package/dist/Support/Facade.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Facade.d.cts","names":[],"sources":["../../src/Support/Facade.ts"],"mappings":";;;;;AAMA;;uBAAsB,MAAA;EAAA,eACL,GAAA;EAAA,eACA,iBAAA;EAAA;;;EAAA,OAKR,oBAAA,CAAqB,GAAA,EAAK,WAAA;EAO1B;;;EAAA,OAAA,oBAAA,CAAA,GAAwB,WAAA;EAeQ;;;;EAAA,iBAPtB,iBAAA,CAAA;EAsCY;;;EAAA,iBA/BZ,qBAAA,CAAsB,IAAA;;;;mBAiBtB,aAAA,CAAA;;;;SAOV,qBAAA,CAAsB,IAAA;;;;SAOtB,sBAAA,CAAA;AAAA"}

package/dist/Support/Facade.d.mts

@@ -0,0 +1,43 @@
+import { Application } from "../Foundation/Application.mjs";
+
+//#region src/Support/Facade.d.ts
+/**
+ * Facade - Laravel's Facade base class
+ * Provides static proxy to underlying service in the container
+ */
+declare abstract class Facade {
+  private static app;
+  private static resolvedInstances;
+  /**
+   * Set the application instance for facades
+   */
+  static setFacadeApplication(app: Application): void;
+  /**
+   * Get the application instance
+   */
+  static getFacadeApplication(): Application;
+  /**
+   * Get the registered name of the component
+   * This should be overridden by child classes
+   */
+  protected static getFacadeAccessor(): string;
+  /**
+   * Resolve the facade root instance from the container
+   */
+  protected static resolveFacadeInstance(name: string): any;
+  /**
+   * Get the root object behind the facade
+   */
+  protected static getFacadeRoot(): any;
+  /**
+   * Clear a resolved facade instance
+   */
+  static clearResolvedInstance(name: string): void;
+  /**
+   * Clear all resolved instances
+   */
+  static clearResolvedInstances(): void;
+}
+//#endregion
+export { Facade };
+//# sourceMappingURL=Facade.d.mts.map

package/dist/Support/Facade.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Facade.d.mts","names":[],"sources":["../../src/Support/Facade.ts"],"mappings":";;;;;AAMA;;uBAAsB,MAAA;EAAA,eACL,GAAA;EAAA,eACA,iBAAA;EAAA;;;EAAA,OAKR,oBAAA,CAAqB,GAAA,EAAK,WAAA;EAO1B;;;EAAA,OAAA,oBAAA,CAAA,GAAwB,WAAA;EAeQ;;;;EAAA,iBAPtB,iBAAA,CAAA;EAsCY;;;EAAA,iBA/BZ,qBAAA,CAAsB,IAAA;;;;mBAiBtB,aAAA,CAAA;;;;SAOV,qBAAA,CAAsB,IAAA;;;;SAOtB,sBAAA,CAAA;AAAA"}

package/dist/Support/Facade.mjs

@@ -0,0 +1,2 @@
+var e=class e{static app;static resolvedInstances=new Map;static setFacadeApplication(t){e.app=t}static getFacadeApplication(){return e.app}static getFacadeAccessor(){throw Error(`Facade does not implement getFacadeAccessor method.`)}static resolveFacadeInstance(t){if(e.resolvedInstances.has(t))return e.resolvedInstances.get(t);if(e.app){let n=e.app.make(t);return e.resolvedInstances.set(t,n),n}throw Error(`A facade root has not been set.`)}static getFacadeRoot(){return e.resolveFacadeInstance(this.getFacadeAccessor())}static clearResolvedInstance(t){e.resolvedInstances.delete(t)}static clearResolvedInstances(){e.resolvedInstances.clear()}};export{e as Facade};
+//# sourceMappingURL=Facade.mjs.map

package/dist/Support/Facade.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Facade.mjs","names":[],"sources":["../../src/Support/Facade.ts"],"sourcesContent":["import { Application } from '@/Foundation/Application';\n\n/**\n * Facade - Laravel's Facade base class\n * Provides static proxy to underlying service in the container\n */\nexport abstract class Facade {\n  private static app: Application;\n  private static resolvedInstances: Map<string, any> = new Map();\n\n  /**\n   * Set the application instance for facades\n   */\n  static setFacadeApplication(app: Application): void {\n    Facade.app = app;\n  }\n\n  /**\n   * Get the application instance\n   */\n  static getFacadeApplication(): Application {\n    return Facade.app;\n  }\n\n  /**\n   * Get the registered name of the component\n   * This should be overridden by child classes\n   */\n  protected static getFacadeAccessor(): string {\n    throw new Error('Facade does not implement getFacadeAccessor method.');\n  }\n\n  /**\n   * Resolve the facade root instance from the container\n   */\n  protected static resolveFacadeInstance(name: string): any {\n    if (Facade.resolvedInstances.has(name)) {\n      return Facade.resolvedInstances.get(name);\n    }\n\n    if (Facade.app) {\n      const instance = Facade.app.make(name);\n      Facade.resolvedInstances.set(name, instance);\n      return instance;\n    }\n\n    throw new Error('A facade root has not been set.');\n  }\n\n  /**\n   * Get the root object behind the facade\n   */\n  protected static getFacadeRoot(): any {\n    return Facade.resolveFacadeInstance(this.getFacadeAccessor());\n  }\n\n  /**\n   * Clear a resolved facade instance\n   */\n  static clearResolvedInstance(name: string): void {\n    Facade.resolvedInstances.delete(name);\n  }\n\n  /**\n   * Clear all resolved instances\n   */\n  static clearResolvedInstances(): void {\n    Facade.resolvedInstances.clear();\n  }\n}\n\n/**\n * Create a Facade class dynamically with proxy support\n * This allows calling methods statically: MyFacade.method()\n */\nexport function createFacade<T extends object>(accessor: string): new () => T {\n  class DynamicFacade extends Facade {\n    protected static getFacadeAccessor(): string {\n      return accessor;\n    }\n\n    constructor() {\n      super();\n      return new Proxy(this, {\n        get(target, prop, receiver) {\n          const root = DynamicFacade.getFacadeRoot();\n          if (root && typeof root[prop] === 'function') {\n            return (...args: any[]) => root[prop](...args);\n          }\n          return root[prop];\n        },\n      });\n    }\n  }\n\n  // Create a Proxy on the class itself for static method calls\n  return new Proxy(DynamicFacade as any, {\n    get(target, prop) {\n      if (prop in target) {\n        return target[prop];\n      }\n\n      const root = target.getFacadeRoot();\n      if (root && typeof root[prop] === 'function') {\n        return (...args: any[]) => root[prop](...args);\n      }\n      return root[prop];\n    },\n  });\n}\n"],"mappings":"AAMA,IAAsB,EAAtB,MAAsB,CAAO,CAC3B,OAAe,IACf,OAAe,kBAAsC,IAAI,IAKzD,OAAO,qBAAqB,EAAwB,CAClD,EAAO,IAAM,EAMf,OAAO,sBAAoC,CACzC,OAAO,EAAO,IAOhB,OAAiB,mBAA4B,CAC3C,MAAU,MAAM,sDAAsD,CAMxE,OAAiB,sBAAsB,EAAmB,CACxD,GAAI,EAAO,kBAAkB,IAAI,EAAK,CACpC,OAAO,EAAO,kBAAkB,IAAI,EAAK,CAG3C,GAAI,EAAO,IAAK,CACd,IAAM,EAAW,EAAO,IAAI,KAAK,EAAK,CAEtC,OADA,EAAO,kBAAkB,IAAI,EAAM,EAAS,CACrC,EAGT,MAAU,MAAM,kCAAkC,CAMpD,OAAiB,eAAqB,CACpC,OAAO,EAAO,sBAAsB,KAAK,mBAAmB,CAAC,CAM/D,OAAO,sBAAsB,EAAoB,CAC/C,EAAO,kBAAkB,OAAO,EAAK,CAMvC,OAAO,wBAA+B,CACpC,EAAO,kBAAkB,OAAO"}

package/dist/Support/Injectable.cjs

@@ -0,0 +1 @@
+require(`../_virtual/_rolldown/runtime.cjs`);function e(){return e=>{}}exports.Injectable=e;

package/dist/Support/Injectable.d.cts

@@ -0,0 +1,24 @@
+//#region src/Support/Injectable.d.ts
+/**
+ * Injectable Decorator
+ *
+ * Marks a class as injectable, enabling TypeScript to emit decorator metadata
+ * required for automatic dependency injection via reflect-metadata.
+ *
+ * This decorator does nothing at runtime - it only triggers TypeScript's
+ * emitDecoratorMetadata feature to include parameter type information.
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * export class UserController extends Controller {
+ *   constructor(private userService: UserService) {
+ *     super();
+ *   }
+ * }
+ * ```
+ */
+declare function Injectable(): ClassDecorator;
+//#endregion
+export { Injectable };
+//# sourceMappingURL=Injectable.d.cts.map

package/dist/Support/Injectable.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Injectable.d.cts","names":[],"sources":["../../src/Support/Injectable.ts"],"mappings":";;AAmBA;;;;;;;;;;;;;;;;;;iBAAgB,UAAA,CAAA,GAAc,cAAA"}

package/dist/Support/Injectable.d.mts

@@ -0,0 +1,24 @@
+//#region src/Support/Injectable.d.ts
+/**
+ * Injectable Decorator
+ *
+ * Marks a class as injectable, enabling TypeScript to emit decorator metadata
+ * required for automatic dependency injection via reflect-metadata.
+ *
+ * This decorator does nothing at runtime - it only triggers TypeScript's
+ * emitDecoratorMetadata feature to include parameter type information.
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * export class UserController extends Controller {
+ *   constructor(private userService: UserService) {
+ *     super();
+ *   }
+ * }
+ * ```
+ */
+declare function Injectable(): ClassDecorator;
+//#endregion
+export { Injectable };
+//# sourceMappingURL=Injectable.d.mts.map

package/dist/Support/Injectable.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Injectable.d.mts","names":[],"sources":["../../src/Support/Injectable.ts"],"mappings":";;AAmBA;;;;;;;;;;;;;;;;;;iBAAgB,UAAA,CAAA,GAAc,cAAA"}

package/dist/Support/Injectable.mjs

@@ -0,0 +1,2 @@
+function e(){return e=>{}}export{e as Injectable};
+//# sourceMappingURL=Injectable.mjs.map

package/dist/Support/Injectable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Injectable.mjs","names":[],"sources":["../../src/Support/Injectable.ts"],"sourcesContent":["/**\n * Injectable Decorator\n *\n * Marks a class as injectable, enabling TypeScript to emit decorator metadata\n * required for automatic dependency injection via reflect-metadata.\n *\n * This decorator does nothing at runtime - it only triggers TypeScript's\n * emitDecoratorMetadata feature to include parameter type information.\n *\n * @example\n * ```typescript\n * @Injectable()\n * export class UserController extends Controller {\n *   constructor(private userService: UserService) {\n *     super();\n *   }\n * }\n * ```\n */\nexport function Injectable(): ClassDecorator {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n  return (target: Function) => {\n    // This decorator is intentionally empty.\n    // Its sole purpose is to trigger TypeScript's emitDecoratorMetadata\n    // feature, which adds reflection metadata to the class constructor.\n  };\n}\n"],"mappings":"AAmBA,SAAgB,GAA6B,CAE3C,MAAQ,IAAqB"}

package/dist/Support/Testing/Fakes/EventFake.cjs

@@ -0,0 +1,2 @@
+require(`../../../_virtual/_rolldown/runtime.cjs`);var e=class{dispatched=new Map;fakedEvents=[];exceptedEvents=[];originalDispatcher;listeners=new Map;constructor(e){this.container=e}setFakedEvents(e){this.fakedEvents=e}setExceptedEvents(e){this.exceptedEvents=e}setOriginalDispatcher(e){this.originalDispatcher=e}shouldFake(e){return this.exceptedEvents.length>0?!this.exceptedEvents.includes(e):this.fakedEvents.length>0?this.fakedEvents.includes(e):!0}listen(e,t){let n=Array.isArray(e)?e:[e];for(let e of n)this.listeners.has(e)||this.listeners.set(e,[]),this.listeners.get(e).push(t)}hasListeners(e){return this.listeners.has(e)&&this.listeners.get(e).length>0}subscribe(e){}dispatch(e,t=[],n=!1){let r=this.getEventName(e);return this.shouldFake(r)?(this.dispatched.has(r)||this.dispatched.set(r,[]),this.dispatched.get(r).push({event:e,payload:t,timestamp:Date.now()}),[]):this.originalDispatcher?this.originalDispatcher.dispatch(e,t,n):[]}until(e,t=[]){return this.dispatch(e,t,!0)[0]||null}push(e,t=[]){}flush(e){}forget(e){this.dispatched.delete(e),this.listeners.delete(e)}forgetPushed(){}getRawListeners(){return this.listeners}getEventName(e){return typeof e==`string`?e:e.constructor.name}assertDispatched(e,t){let n=typeof e==`string`?e:e.name,r=this.dispatched.get(n)||[];if(r.length===0){let e=Array.from(this.dispatched.keys()).join(`, `)||`none`;throw Error(`Event [${n}] was not dispatched.\nDispatched events: ${e}`)}if(t&&r.filter(e=>{let n=typeof e.event==`string`?null:e.event;return n&&t(n)}).length===0)throw Error(`Event [${n}] was dispatched ${r.length} time(s) but none matched the provided callback.`)}assertNotDispatched(e,t){let n=typeof e==`string`?e:e.name,r=this.dispatched.get(n)||[];if(!t){if(r.length>0)throw Error(`Event [${n}] was dispatched ${r.length} time(s).`);return}let i=r.filter(e=>{let n=typeof e.event==`string`?null:e.event;return n&&t(n)});if(i.length>0)throw Error(`Event [${n}] was unexpectedly dispatched ${i.length} time(s) matching the provided callback.`)}assertDispatchedTimes(e,t){let n=typeof e==`string`?e:e.name,r=this.dispatched.get(n)||[];if(r.length!==t)throw Error(`Event [${n}] was dispatched ${r.length} time(s) instead of ${t}.`)}assertNothingDispatched(){let e=Array.from(this.dispatched.values()).reduce((e,t)=>e+t.length,0);if(e>0){let t=Array.from(this.dispatched.entries()).map(([e,t])=>`  ${e}: ${t.length}`).join(`
+`);throw Error(`Expected no events to be dispatched, but ${e} were:\n${t}`)}}assertListening(e,t){let n=typeof e==`string`?e:e.name,r=this.listeners.get(n)||[];if(r.length===0)throw Error(`No listeners are registered for event [${n}].`);if(t){let e=typeof t==`string`?t:this.getListenerName(t);if(!r.some(t=>(typeof t==`string`?t:this.getListenerName(t))===e))throw Error(`Listener [${e}] is not registered for event [${n}].`)}}getListenerName(e){return typeof e==`string`?e:typeof e==`function`?e.name||`<Closure>`:typeof e==`object`&&e.constructor?e.constructor.name:`<Unknown>`}getDispatched(e){let t=typeof e==`string`?e:e.name;return this.dispatched.get(t)||[]}getDispatchedEventNames(){return Array.from(this.dispatched.keys())}getDispatchedCount(){return Array.from(this.dispatched.values()).reduce((e,t)=>e+t.length,0)}clear(){this.dispatched.clear()}clearListeners(){this.listeners.clear()}reset(){this.clear(),this.clearListeners(),this.fakedEvents=[],this.exceptedEvents=[],this.originalDispatcher=void 0}};exports.EventFake=e;

package/dist/Support/Testing/Fakes/EventFake.d.cts

@@ -0,0 +1,294 @@
+import { Event } from "../../../Events/Event.cjs";
+import { Container } from "../../../Container/Container.cjs";
+import { EventListener } from "../../../Events/types.cjs";
+import { DispatcherContract } from "../../../Events/Contracts/Dispatcher.cjs";
+
+//#region src/Support/Testing/Fakes/EventFake.d.ts
+/**
+ * Dispatched Event Record
+ *
+ * Represents a single event dispatch with metadata
+ */
+interface DispatchedEvent {
+  /** The event instance or event name */
+  event: Event | string;
+  /** Additional payload passed to the event */
+  payload: any[];
+  /** Timestamp when the event was dispatched */
+  timestamp: number;
+}
+/**
+ * Event Fake Dispatcher
+ *
+ * A test double for the event dispatcher that records all dispatched events
+ * instead of actually calling listeners. Provides assertion methods to verify
+ * event dispatching behavior in tests.
+ *
+ * @example
+ * ```typescript
+ * // Replace the real dispatcher with a fake
+ * const fake = new EventFake(app);
+ * app.instance('events', fake);
+ *
+ * // Test code that dispatches events
+ * dispatch(new UserRegistered(user));
+ *
+ * // Assert the event was dispatched
+ * fake.assertDispatched(UserRegistered);
+ * fake.assertDispatchedTimes(UserRegistered, 1);
+ * ```
+ */
+declare class EventFake implements DispatcherContract {
+  protected container: Container;
+  /**
+   * All dispatched events organized by event name
+   */
+  protected dispatched: Map<string, DispatchedEvent[]>;
+  /**
+   * Events that should be faked (empty = fake all)
+   */
+  protected fakedEvents: string[];
+  /**
+   * Events that should NOT be faked (all others will be)
+   */
+  protected exceptedEvents: string[];
+  /**
+   * The original dispatcher (for pass-through)
+   */
+  protected originalDispatcher?: DispatcherContract;
+  /**
+   * Registered listeners (for assertListening)
+   */
+  protected listeners: Map<string, EventListener[]>;
+  constructor(container: Container);
+  /**
+   * Set which events should be faked
+   *
+   * @param events - Array of event names or classes to fake
+   */
+  setFakedEvents(events: string[]): void;
+  /**
+   * Set which events should NOT be faked (all others will be)
+   *
+   * @param events - Array of event names or classes to NOT fake
+   */
+  setExceptedEvents(events: string[]): void;
+  /**
+   * Set the original dispatcher for pass-through
+   *
+   * @param dispatcher - The real dispatcher instance
+   */
+  setOriginalDispatcher(dispatcher: DispatcherContract): void;
+  /**
+   * Check if an event should be faked
+   *
+   * @param eventName - The event name to check
+   * @returns true if the event should be faked
+   */
+  protected shouldFake(eventName: string): boolean;
+  /**
+   * Register an event listener
+   *
+   * @param events - Event name(s) to listen for
+   * @param listener - The listener to call
+   */
+  listen(events: string | string[], listener: EventListener): void;
+  /**
+   * Check if an event has listeners
+   *
+   * @param eventName - The event name to check
+   * @returns true if the event has registered listeners
+   */
+  hasListeners(eventName: string): boolean;
+  /**
+   * Register an event subscriber
+   *
+   * @param subscriber - The subscriber instance
+   */
+  subscribe(subscriber: any): void;
+  /**
+   * Dispatch an event
+   *
+   * @param event - The event instance or name
+   * @param payload - Additional arguments to pass
+   * @param halt - Stop on first non-null response
+   * @returns Array of listener results
+   */
+  dispatch(event: string | Event, payload?: any[], halt?: boolean): any[];
+  /**
+   * Dispatch an event until the first non-null response
+   *
+   * @param event - The event instance or name
+   * @param payload - Additional arguments to pass
+   * @returns The first non-null listener result
+   */
+  until(event: string | Event, payload?: any[]): any;
+  /**
+   * Push an event onto the queue for later flushing
+   *
+   * @param event - The event name
+   * @param payload - Additional arguments to pass
+   */
+  push(event: string, payload?: any[]): void;
+  /**
+   * Flush all queued events
+   *
+   * @param event - The event name to flush
+   */
+  flush(event: string): void;
+  /**
+   * Remove all listeners for an event
+   *
+   * @param event - The event name
+   */
+  forget(event: string): void;
+  /**
+   * Clear all queued events
+   */
+  forgetPushed(): void;
+  /**
+   * Get all registered listeners
+   *
+   * @returns Map of event names to listeners
+   */
+  getRawListeners(): Map<string, EventListener[]>;
+  /**
+   * Get the event name from an event instance or string
+   *
+   * @param event - The event instance or name
+   * @returns The event name
+   */
+  protected getEventName(event: string | Event): string;
+  /**
+   * Assert that an event was dispatched
+   *
+   * @param event - The event name or class
+   * @param callback - Optional callback to filter events
+   * @throws Error if the event was not dispatched
+   *
+   * @example
+   * ```typescript
+   * // Assert event was dispatched
+   * fake.assertDispatched(UserRegistered);
+   *
+   * // Assert event with specific properties
+   * fake.assertDispatched(UserRegistered, (event) => {
+   *   return event.user.email === 'test@example.com';
+   * });
+   * ```
+   */
+  assertDispatched(event: string | (new (...args: any[]) => Event), callback?: (event: Event) => boolean): void;
+  /**
+   * Assert that an event was NOT dispatched
+   *
+   * @param event - The event name or class
+   * @param callback - Optional callback to filter events
+   * @throws Error if the event was dispatched
+   *
+   * @example
+   * ```typescript
+   * // Assert event was not dispatched
+   * fake.assertNotDispatched(UserDeleted);
+   *
+   * // Assert event with specific properties was not dispatched
+   * fake.assertNotDispatched(UserRegistered, (event) => {
+   *   return event.user.email === 'admin@example.com';
+   * });
+   * ```
+   */
+  assertNotDispatched(event: string | (new (...args: any[]) => Event), callback?: (event: Event) => boolean): void;
+  /**
+   * Assert that an event was dispatched a specific number of times
+   *
+   * @param event - The event name or class
+   * @param times - Expected number of dispatches
+   * @throws Error if the dispatch count doesn't match
+   *
+   * @example
+   * ```typescript
+   * fake.assertDispatchedTimes(UserRegistered, 3);
+   * ```
+   */
+  assertDispatchedTimes(event: string | (new (...args: any[]) => Event), times: number): void;
+  /**
+   * Assert that no events were dispatched
+   *
+   * @throws Error if any events were dispatched
+   *
+   * @example
+   * ```typescript
+   * fake.assertNothingDispatched();
+   * ```
+   */
+  assertNothingDispatched(): void;
+  /**
+   * Assert that a listener is registered for an event
+   *
+   * @param event - The event name or class
+   * @param listener - Optional specific listener to check for
+   * @throws Error if the listener is not registered
+   *
+   * @example
+   * ```typescript
+   * // Assert any listener is registered
+   * fake.assertListening(UserRegistered);
+   *
+   * // Assert specific listener is registered
+   * fake.assertListening(UserRegistered, SendWelcomeEmail);
+   * ```
+   */
+  assertListening(event: string | (new (...args: any[]) => Event), listener?: string | EventListener): void;
+  /**
+   * Get the name of a listener
+   *
+   * @param listener - The listener instance or closure
+   * @returns The listener name
+   */
+  protected getListenerName(listener: EventListener): string;
+  /**
+   * Get all dispatched events for a given event name
+   *
+   * @param event - The event name or class
+   * @returns Array of dispatched event records
+   *
+   * @example
+   * ```typescript
+   * const dispatches = fake.getDispatched(UserRegistered);
+   * expect(dispatches).toHaveLength(3);
+   * ```
+   */
+  getDispatched(event: string | (new (...args: any[]) => Event)): DispatchedEvent[];
+  /**
+   * Get all dispatched event names
+   *
+   * @returns Array of event names
+   */
+  getDispatchedEventNames(): string[];
+  /**
+   * Get the total count of dispatched events
+   *
+   * @returns Total number of event dispatches
+   */
+  getDispatchedCount(): number;
+  /**
+   * Clear all recorded dispatches
+   *
+   * @example
+   * ```typescript
+   * // Clear between tests
+   * fake.clear();
+   * ```
+   */
+  clear(): void;
+  /**
+   * Clear all registered listeners
+   */
+  clearListeners(): void;
+  /**
+   * Reset the fake completely
+   */
+  reset(): void;
+}
+//#endregion
+export { EventFake };
+//# sourceMappingURL=EventFake.d.cts.map

package/dist/Support/Testing/Fakes/EventFake.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventFake.d.cts","names":[],"sources":["../../../../src/Support/Testing/Fakes/EventFake.ts"],"mappings":";;;;;;;;AAGoD;;;UAO1C,eAAA;EAER;EAAA,KAAA,EAAO,KAAA;EAGP;EAAA,OAAA;EAGS;EAAT,SAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;cAwBW,SAAA,YAAqB,kBAAA;EAAA,UA0BV,SAAA,EAAW,SAAA;EA0WG;;;EAAA,UAhY1B,UAAA,EAAY,GAAA,SAAY,eAAA;EAJgB;;;EAAA,UASxC,WAAA;EAiBuB;;;EAAA,UAZvB,cAAA;EALA;;;EAAA,UAUA,kBAAA,GAAqB,kBAAA;EAKrB;;;EAAA,UAAA,SAAA,EAAW,GAAA,SAAY,aAAA;cAEX,SAAA,EAAW,SAAA;EAAX;;;;;EAOtB,cAAA,CAAe,MAAA;EAkBmB;;;;;EATlC,iBAAA,CAAkB,MAAA;EAwC0B;;;;;EA/B5C,qBAAA,CAAsB,UAAA,EAAY,kBAAA;EAwElC;;;;;;EAAA,UA9DU,UAAA,CAAW,SAAA;EA8Ff;;;;;;EAzEN,MAAA,CAAO,MAAA,qBAA2B,QAAA,EAAU,aAAA;EAqG5C;;;;;;EAlFA,YAAA,CAAa,SAAA;EA6G0B;;;;;EApGvC,SAAA,CAAU,UAAA;EA+H2E;;;;;;;;EAlHrF,QAAA,CAAS,KAAA,WAAgB,KAAA,EAAO,OAAA,UAAqB,IAAA;EA2JgB;;;;;;;EA3HrE,KAAA,CAAM,KAAA,WAAgB,KAAA,EAAO,OAAA;EA8MY;;;;;;EApMzC,IAAA,CAAK,KAAA,UAAe,OAAA;EA+NM;;;;;EAtN1B,KAAA,CAAM,KAAA;EA8PN;;;;;EArPA,MAAA,CAAO,KAAA;EAyRF;;;EAjRL,YAAA,CAAA;;;;;;EASA,eAAA,CAAA,GAAmB,GAAA,SAAY,aAAA;;;;;;;YAUrB,YAAA,CAAa,KAAA,WAAgB,KAAA;;;;;;;;;;;;;;;;;;;EA2BvC,gBAAA,CAAiB,KAAA,oBAAyB,IAAA,YAAgB,KAAA,GAAQ,QAAA,IAAY,KAAA,EAAO,KAAA;;;;;;;;;;;;;;;;;;;EAyCrF,mBAAA,CAAoB,KAAA,oBAAyB,IAAA,YAAgB,KAAA,GAAQ,QAAA,IAAY,KAAA,EAAO,KAAA;;;;;;;;;;;;;EAoCxF,qBAAA,CAAsB,KAAA,oBAAyB,IAAA,YAAgB,KAAA,GAAQ,KAAA;;;;;;;;;;;EAmBvE,uBAAA,CAAA;;;;;;;;;;;;;;;;;EA4BA,eAAA,CAAgB,KAAA,oBAAyB,IAAA,YAAgB,KAAA,GAAQ,QAAA,YAAoB,aAAA;;;;;;;YA2B3E,eAAA,CAAgB,QAAA,EAAU,aAAA;;;;;;;;;;;;;EA8BpC,aAAA,CAAc,KAAA,oBAAyB,IAAA,YAAgB,KAAA,IAAS,eAAA;;;;;;EAUhE,uBAAA,CAAA;;;;;;EASA,kBAAA,CAAA;;;;;;;;;;EAaA,KAAA,CAAA;;;;EAOA,cAAA,CAAA;;;;EAOA,KAAA,CAAA;AAAA"}