@orchestr-sh/orchestr 1.6.1 → 1.7.0

package/dist/Database/Ensemble/Events/ModelSaving.d.ts

@@ -0,0 +1,12 @@
+/**
+ * ModelSaving Event
+ *
+ * Fired before a model is saved (before insert or update)
+ * Returning false from a listener will halt the operation
+ */
+import { Ensemble } from '../Ensemble';
+import { ModelEvent } from './ModelEvent';
+export declare class ModelSaving<T extends Ensemble = Ensemble> extends ModelEvent<T> {
+    constructor(model: T);
+}
+//# sourceMappingURL=ModelSaving.d.ts.map

package/dist/Database/Ensemble/Events/ModelSaving.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModelSaving.d.ts","sourceRoot":"","sources":["../../../../src/Database/Ensemble/Events/ModelSaving.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,qBAAa,WAAW,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ,CAAE,SAAQ,UAAU,CAAC,CAAC,CAAC;gBAC/D,KAAK,EAAE,CAAC;CAGrB"}

package/dist/Database/Ensemble/Events/ModelSaving.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * ModelSaving Event
+ *
+ * Fired before a model is saved (before insert or update)
+ * Returning false from a listener will halt the operation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelSaving = void 0;
+const ModelEvent_1 = require("./ModelEvent");
+class ModelSaving extends ModelEvent_1.ModelEvent {
+    constructor(model) {
+        super(model);
+    }
+}
+exports.ModelSaving = ModelSaving;
+//# sourceMappingURL=ModelSaving.js.map

package/dist/Database/Ensemble/Events/ModelSaving.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModelSaving.js","sourceRoot":"","sources":["../../../../src/Database/Ensemble/Events/ModelSaving.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;AAGH,6CAA0C;AAE1C,MAAa,WAA2C,SAAQ,uBAAa;IAC3E,YAAY,KAAQ;QAClB,KAAK,CAAC,KAAK,CAAC,CAAC;IACf,CAAC;CACF;AAJD,kCAIC"}

package/dist/Database/Ensemble/Events/ModelUpdated.d.ts

@@ -0,0 +1,11 @@
+/**
+ * ModelUpdated Event
+ *
+ * Fired after a model is updated (after update query)
+ */
+import { Ensemble } from '../Ensemble';
+import { ModelEvent } from './ModelEvent';
+export declare class ModelUpdated<T extends Ensemble = Ensemble> extends ModelEvent<T> {
+    constructor(model: T);
+}
+//# sourceMappingURL=ModelUpdated.d.ts.map

package/dist/Database/Ensemble/Events/ModelUpdated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModelUpdated.d.ts","sourceRoot":"","sources":["../../../../src/Database/Ensemble/Events/ModelUpdated.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,qBAAa,YAAY,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ,CAAE,SAAQ,UAAU,CAAC,CAAC,CAAC;gBAChE,KAAK,EAAE,CAAC;CAGrB"}

package/dist/Database/Ensemble/Events/ModelUpdated.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * ModelUpdated Event
+ *
+ * Fired after a model is updated (after update query)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelUpdated = void 0;
+const ModelEvent_1 = require("./ModelEvent");
+class ModelUpdated extends ModelEvent_1.ModelEvent {
+    constructor(model) {
+        super(model);
+    }
+}
+exports.ModelUpdated = ModelUpdated;
+//# sourceMappingURL=ModelUpdated.js.map

package/dist/Database/Ensemble/Events/ModelUpdated.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModelUpdated.js","sourceRoot":"","sources":["../../../../src/Database/Ensemble/Events/ModelUpdated.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAGH,6CAA0C;AAE1C,MAAa,YAA4C,SAAQ,uBAAa;IAC5E,YAAY,KAAQ;QAClB,KAAK,CAAC,KAAK,CAAC,CAAC;IACf,CAAC;CACF;AAJD,oCAIC"}

package/dist/Database/Ensemble/Events/ModelUpdating.d.ts

@@ -0,0 +1,12 @@
+/**
+ * ModelUpdating Event
+ *
+ * Fired before a model is updated (before update query)
+ * Returning false from a listener will halt the operation
+ */
+import { Ensemble } from '../Ensemble';
+import { ModelEvent } from './ModelEvent';
+export declare class ModelUpdating<T extends Ensemble = Ensemble> extends ModelEvent<T> {
+    constructor(model: T);
+}
+//# sourceMappingURL=ModelUpdating.d.ts.map

package/dist/Database/Ensemble/Events/ModelUpdating.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModelUpdating.d.ts","sourceRoot":"","sources":["../../../../src/Database/Ensemble/Events/ModelUpdating.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,qBAAa,aAAa,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ,CAAE,SAAQ,UAAU,CAAC,CAAC,CAAC;gBACjE,KAAK,EAAE,CAAC;CAGrB"}

package/dist/Database/Ensemble/Events/ModelUpdating.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * ModelUpdating Event
+ *
+ * Fired before a model is updated (before update query)
+ * Returning false from a listener will halt the operation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelUpdating = void 0;
+const ModelEvent_1 = require("./ModelEvent");
+class ModelUpdating extends ModelEvent_1.ModelEvent {
+    constructor(model) {
+        super(model);
+    }
+}
+exports.ModelUpdating = ModelUpdating;
+//# sourceMappingURL=ModelUpdating.js.map

package/dist/Database/Ensemble/Events/ModelUpdating.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModelUpdating.js","sourceRoot":"","sources":["../../../../src/Database/Ensemble/Events/ModelUpdating.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;AAGH,6CAA0C;AAE1C,MAAa,aAA6C,SAAQ,uBAAa;IAC7E,YAAY,KAAQ;QAClB,KAAK,CAAC,KAAK,CAAC,CAAC;IACf,CAAC;CACF;AAJD,sCAIC"}

package/dist/Database/Ensemble/Events/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Ensemble Model Events
+ *
+ * Export all model lifecycle events
+ */
+export { ModelEvent } from './ModelEvent';
+export { ModelRetrieved } from './ModelRetrieved';
+export { ModelCreating } from './ModelCreating';
+export { ModelCreated } from './ModelCreated';
+export { ModelUpdating } from './ModelUpdating';
+export { ModelUpdated } from './ModelUpdated';
+export { ModelSaving } from './ModelSaving';
+export { ModelSaved } from './ModelSaved';
+export { ModelDeleting } from './ModelDeleting';
+export { ModelDeleted } from './ModelDeleted';
+//# sourceMappingURL=index.d.ts.map

package/dist/Database/Ensemble/Events/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/Database/Ensemble/Events/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/Database/Ensemble/Events/index.js

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * Ensemble Model Events
+ *
+ * Export all model lifecycle events
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelDeleted = exports.ModelDeleting = exports.ModelSaved = exports.ModelSaving = exports.ModelUpdated = exports.ModelUpdating = exports.ModelCreated = exports.ModelCreating = exports.ModelRetrieved = exports.ModelEvent = void 0;
+var ModelEvent_1 = require("./ModelEvent");
+Object.defineProperty(exports, "ModelEvent", { enumerable: true, get: function () { return ModelEvent_1.ModelEvent; } });
+var ModelRetrieved_1 = require("./ModelRetrieved");
+Object.defineProperty(exports, "ModelRetrieved", { enumerable: true, get: function () { return ModelRetrieved_1.ModelRetrieved; } });
+var ModelCreating_1 = require("./ModelCreating");
+Object.defineProperty(exports, "ModelCreating", { enumerable: true, get: function () { return ModelCreating_1.ModelCreating; } });
+var ModelCreated_1 = require("./ModelCreated");
+Object.defineProperty(exports, "ModelCreated", { enumerable: true, get: function () { return ModelCreated_1.ModelCreated; } });
+var ModelUpdating_1 = require("./ModelUpdating");
+Object.defineProperty(exports, "ModelUpdating", { enumerable: true, get: function () { return ModelUpdating_1.ModelUpdating; } });
+var ModelUpdated_1 = require("./ModelUpdated");
+Object.defineProperty(exports, "ModelUpdated", { enumerable: true, get: function () { return ModelUpdated_1.ModelUpdated; } });
+var ModelSaving_1 = require("./ModelSaving");
+Object.defineProperty(exports, "ModelSaving", { enumerable: true, get: function () { return ModelSaving_1.ModelSaving; } });
+var ModelSaved_1 = require("./ModelSaved");
+Object.defineProperty(exports, "ModelSaved", { enumerable: true, get: function () { return ModelSaved_1.ModelSaved; } });
+var ModelDeleting_1 = require("./ModelDeleting");
+Object.defineProperty(exports, "ModelDeleting", { enumerable: true, get: function () { return ModelDeleting_1.ModelDeleting; } });
+var ModelDeleted_1 = require("./ModelDeleted");
+Object.defineProperty(exports, "ModelDeleted", { enumerable: true, get: function () { return ModelDeleted_1.ModelDeleted; } });
+//# sourceMappingURL=index.js.map

package/dist/Database/Ensemble/Events/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/Database/Ensemble/Events/index.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAEH,2CAA0C;AAAjC,wGAAA,UAAU,OAAA;AACnB,mDAAkD;AAAzC,gHAAA,cAAc,OAAA;AACvB,iDAAgD;AAAvC,8GAAA,aAAa,OAAA;AACtB,+CAA8C;AAArC,4GAAA,YAAY,OAAA;AACrB,iDAAgD;AAAvC,8GAAA,aAAa,OAAA;AACtB,+CAA8C;AAArC,4GAAA,YAAY,OAAA;AACrB,6CAA4C;AAAnC,0GAAA,WAAW,OAAA;AACpB,2CAA0C;AAAjC,wGAAA,UAAU,OAAA;AACnB,iDAAgD;AAAvC,8GAAA,aAAa,OAAA;AACtB,+CAA8C;AAArC,4GAAA,YAAY,OAAA"}

package/dist/Events/Concerns/Dispatchable.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Dispatchable Concern
+ *
+ * Provides static dispatch methods for events
+ * This mixin is applied to the Event base class to enable:
+ * - Event.dispatch() - Dispatch immediately
+ * - Event.dispatchIf() - Conditional dispatch
+ * - Event.dispatchUnless() - Negative conditional dispatch
+ *
+ * @example
+ * ```typescript
+ * // Dispatch an event
+ * UserRegistered.dispatch(user);
+ *
+ * // Conditional dispatch
+ * UserRegistered.dispatchIf(shouldNotify, user);
+ *
+ * // Dispatch unless condition is true
+ * UserRegistered.dispatchUnless(user.isAdmin, user);
+ *
+ * // Dispatch and wait for first response
+ * const result = UserRegistered.until(user);
+ * ```
+ */
+/**
+ * Dispatchable mixin class
+ *
+ * Provides static methods for dispatching events
+ */
+export declare class Dispatchable {
+    /**
+     * Dispatch the event with the given arguments
+     *
+     * Creates a new instance of the event class and dispatches it through the event dispatcher
+     *
+     * @param args - Constructor arguments for the event
+     * @returns Array of listener responses
+     *
+     * @example
+     * ```typescript
+     * class UserRegistered extends Event {
+     *   constructor(public user: User) {
+     *     super();
+     *   }
+     * }
+     *
+     * // Dispatch the event
+     * UserRegistered.dispatch(user);
+     * ```
+     */
+    static dispatch(...args: any[]): any[];
+    /**
+     * Dispatch the event if the given condition is true
+     *
+     * @param condition - Boolean or function that returns boolean
+     * @param args - Constructor arguments for the event
+     * @returns Array of listener responses or empty array if condition is false
+     *
+     * @example
+     * ```typescript
+     * // Dispatch if condition is true
+     * UserRegistered.dispatchIf(user.isActive, user);
+     *
+     * // Dispatch if function returns true
+     * UserRegistered.dispatchIf(() => shouldNotify(), user);
+     * ```
+     */
+    static dispatchIf(condition: boolean | (() => boolean), ...args: any[]): any[];
+    /**
+     * Dispatch the event unless the given condition is true
+     *
+     * @param condition - Boolean or function that returns boolean
+     * @param args - Constructor arguments for the event
+     * @returns Array of listener responses or empty array if condition is true
+     *
+     * @example
+     * ```typescript
+     * // Dispatch unless user is admin
+     * UserRegistered.dispatchUnless(user.isAdmin, user);
+     *
+     * // Dispatch unless function returns true
+     * UserRegistered.dispatchUnless(() => user.hasRole('admin'), user);
+     * ```
+     */
+    static dispatchUnless(condition: boolean | (() => boolean), ...args: any[]): any[];
+    /**
+     * Dispatch the event and call the first listener that doesn't return null
+     *
+     * This is useful when you want to get a response from an event listener
+     *
+     * @param args - Constructor arguments for the event
+     * @returns First non-null listener response
+     *
+     * @example
+     * ```typescript
+     * // Get a response from the first listener
+     * const result = UserRegistered.until(user);
+     * if (result === false) {
+     *   // Listener vetoed the operation
+     * }
+     * ```
+     */
+    static until(...args: any[]): any;
+}
+/**
+ * Type declaration to merge Dispatchable methods into Event class
+ * This enables TypeScript to understand that Event has these static methods
+ */
+export interface Event extends Dispatchable {
+}
+/**
+ * Apply Dispatchable mixin to Event class
+ *
+ * This function copies all static methods from Dispatchable to the target Event class
+ *
+ * @param eventClass - The Event class to apply the mixin to
+ *
+ * @internal
+ */
+export declare function applyDispatchable(eventClass: any): void;
+//# sourceMappingURL=Dispatchable.d.ts.map

package/dist/Events/Concerns/Dispatchable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Dispatchable.d.ts","sourceRoot":"","sources":["../../../src/Events/Concerns/Dispatchable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAKH;;;;GAIG;AACH,qBAAa,YAAY;IACvB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,CAAC,QAAQ,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE;IAStC;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,UAAU,CAAC,SAAS,EAAE,OAAO,GAAG,CAAC,MAAM,OAAO,CAAC,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE;IAU9E;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,cAAc,CAAC,SAAS,EAAE,OAAO,GAAG,CAAC,MAAM,OAAO,CAAC,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE;IAUlF;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,GAAG;CAQlC;AAED;;;GAGG;AACH,MAAM,WAAW,KAAM,SAAQ,YAAY;CAAG;AAE9C;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,GAAG,GAAG,IAAI,CAuBvD"}

package/dist/Events/Concerns/Dispatchable.js

@@ -0,0 +1,165 @@
+"use strict";
+/**
+ * Dispatchable Concern
+ *
+ * Provides static dispatch methods for events
+ * This mixin is applied to the Event base class to enable:
+ * - Event.dispatch() - Dispatch immediately
+ * - Event.dispatchIf() - Conditional dispatch
+ * - Event.dispatchUnless() - Negative conditional dispatch
+ *
+ * @example
+ * ```typescript
+ * // Dispatch an event
+ * UserRegistered.dispatch(user);
+ *
+ * // Conditional dispatch
+ * UserRegistered.dispatchIf(shouldNotify, user);
+ *
+ * // Dispatch unless condition is true
+ * UserRegistered.dispatchUnless(user.isAdmin, user);
+ *
+ * // Dispatch and wait for first response
+ * const result = UserRegistered.until(user);
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dispatchable = void 0;
+exports.applyDispatchable = applyDispatchable;
+const Facade_1 = require("../../Support/Facade");
+/**
+ * Dispatchable mixin class
+ *
+ * Provides static methods for dispatching events
+ */
+class Dispatchable {
+    /**
+     * Dispatch the event with the given arguments
+     *
+     * Creates a new instance of the event class and dispatches it through the event dispatcher
+     *
+     * @param args - Constructor arguments for the event
+     * @returns Array of listener responses
+     *
+     * @example
+     * ```typescript
+     * class UserRegistered extends Event {
+     *   constructor(public user: User) {
+     *     super();
+     *   }
+     * }
+     *
+     * // Dispatch the event
+     * UserRegistered.dispatch(user);
+     * ```
+     */
+    static dispatch(...args) {
+        const app = Facade_1.Facade.getFacadeApplication();
+        if (!app) {
+            throw new Error('Application not initialized. Cannot dispatch event.');
+        }
+        return app.make('events').dispatch(new this(...args));
+    }
+    /**
+     * Dispatch the event if the given condition is true
+     *
+     * @param condition - Boolean or function that returns boolean
+     * @param args - Constructor arguments for the event
+     * @returns Array of listener responses or empty array if condition is false
+     *
+     * @example
+     * ```typescript
+     * // Dispatch if condition is true
+     * UserRegistered.dispatchIf(user.isActive, user);
+     *
+     * // Dispatch if function returns true
+     * UserRegistered.dispatchIf(() => shouldNotify(), user);
+     * ```
+     */
+    static dispatchIf(condition, ...args) {
+        const shouldDispatch = typeof condition === 'function' ? condition() : condition;
+        if (shouldDispatch) {
+            return this.dispatch(...args);
+        }
+        return [];
+    }
+    /**
+     * Dispatch the event unless the given condition is true
+     *
+     * @param condition - Boolean or function that returns boolean
+     * @param args - Constructor arguments for the event
+     * @returns Array of listener responses or empty array if condition is true
+     *
+     * @example
+     * ```typescript
+     * // Dispatch unless user is admin
+     * UserRegistered.dispatchUnless(user.isAdmin, user);
+     *
+     * // Dispatch unless function returns true
+     * UserRegistered.dispatchUnless(() => user.hasRole('admin'), user);
+     * ```
+     */
+    static dispatchUnless(condition, ...args) {
+        const shouldNotDispatch = typeof condition === 'function' ? condition() : condition;
+        if (!shouldNotDispatch) {
+            return this.dispatch(...args);
+        }
+        return [];
+    }
+    /**
+     * Dispatch the event and call the first listener that doesn't return null
+     *
+     * This is useful when you want to get a response from an event listener
+     *
+     * @param args - Constructor arguments for the event
+     * @returns First non-null listener response
+     *
+     * @example
+     * ```typescript
+     * // Get a response from the first listener
+     * const result = UserRegistered.until(user);
+     * if (result === false) {
+     *   // Listener vetoed the operation
+     * }
+     * ```
+     */
+    static until(...args) {
+        const app = Facade_1.Facade.getFacadeApplication();
+        if (!app) {
+            throw new Error('Application not initialized. Cannot dispatch event.');
+        }
+        return app.make('events').until(new this(...args));
+    }
+}
+exports.Dispatchable = Dispatchable;
+/**
+ * Apply Dispatchable mixin to Event class
+ *
+ * This function copies all static methods from Dispatchable to the target Event class
+ *
+ * @param eventClass - The Event class to apply the mixin to
+ *
+ * @internal
+ */
+function applyDispatchable(eventClass) {
+    // Get all static methods from Dispatchable
+    const staticMethods = Object.getOwnPropertyNames(Dispatchable);
+    for (const name of staticMethods) {
+        // Skip constructor and prototype
+        if (name === 'constructor' || name === 'prototype' || name === 'length' || name === 'name') {
+            continue;
+        }
+        // Get the property descriptor
+        const descriptor = Object.getOwnPropertyDescriptor(Dispatchable, name);
+        if (descriptor) {
+            // Copy the method to the event class
+            Object.defineProperty(eventClass, name, {
+                value: descriptor.value,
+                enumerable: false,
+                configurable: true,
+                writable: true,
+            });
+        }
+    }
+}
+//# sourceMappingURL=Dispatchable.js.map

package/dist/Events/Concerns/Dispatchable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Dispatchable.js","sourceRoot":"","sources":["../../../src/Events/Concerns/Dispatchable.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;;;AAsIH,8CAuBC;AA1JD,iDAA8C;AAE9C;;;;GAIG;AACH,MAAa,YAAY;IACvB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,CAAC,QAAQ,CAAC,GAAG,IAAW;QAC5B,MAAM,GAAG,GAAG,eAAM,CAAC,oBAAoB,EAAE,CAAC;QAC1C,IAAI,CAAC,GAAG,EAAE,CAAC;YACT,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;QACzE,CAAC;QAED,OAAO,GAAG,CAAC,IAAI,CAAqB,QAAQ,CAAC,CAAC,QAAQ,CAAC,IAAK,IAAY,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;IACrF,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,UAAU,CAAC,SAAoC,EAAE,GAAG,IAAW;QACpE,MAAM,cAAc,GAAG,OAAO,SAAS,KAAK,UAAU,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;QAEjF,IAAI,cAAc,EAAE,CAAC;YACnB,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC,CAAC;QAChC,CAAC;QAED,OAAO,EAAE,CAAC;IACZ,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,cAAc,CAAC,SAAoC,EAAE,GAAG,IAAW;QACxE,MAAM,iBAAiB,GAAG,OAAO,SAAS,KAAK,UAAU,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;QAEpF,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACvB,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC,CAAC;QAChC,CAAC;QAED,OAAO,EAAE,CAAC;IACZ,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,CAAC,KAAK,CAAC,GAAG,IAAW;QACzB,MAAM,GAAG,GAAG,eAAM,CAAC,oBAAoB,EAAE,CAAC;QAC1C,IAAI,CAAC,GAAG,EAAE,CAAC;YACT,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;QACzE,CAAC;QAED,OAAO,GAAG,CAAC,IAAI,CAAqB,QAAQ,CAAC,CAAC,KAAK,CAAC,IAAK,IAAY,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;IAClF,CAAC;CACF;AA3GD,oCA2GC;AAQD;;;;;;;;GAQG;AACH,SAAgB,iBAAiB,CAAC,UAAe;IAC/C,2CAA2C;IAC3C,MAAM,aAAa,GAAG,MAAM,CAAC,mBAAmB,CAAC,YAAY,CAAC,CAAC;IAE/D,KAAK,MAAM,IAAI,IAAI,aAAa,EAAE,CAAC;QACjC,iCAAiC;QACjC,IAAI,IAAI,KAAK,aAAa,IAAI,IAAI,KAAK,WAAW,IAAI,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,MAAM,EAAE,CAAC;YAC3F,SAAS;QACX,CAAC;QAED,8BAA8B;QAC9B,MAAM,UAAU,GAAG,MAAM,CAAC,wBAAwB,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC;QAEvE,IAAI,UAAU,EAAE,CAAC;YACf,qCAAqC;YACrC,MAAM,CAAC,cAAc,CAAC,UAAU,EAAE,IAAI,EAAE;gBACtC,KAAK,EAAE,UAAU,CAAC,KAAK;gBACvB,UAAU,EAAE,KAAK;gBACjB,YAAY,EAAE,IAAI;gBAClB,QAAQ,EAAE,IAAI;aACf,CAAC,CAAC;QACL,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/Events/Contracts/Dispatcher.d.ts

@@ -0,0 +1,144 @@
+import type { Event } from '../Event';
+import type { EventListener, EventSubscriber } from '../types';
+/**
+ * Event Dispatcher Contract
+ *
+ * Defines the interface for the event dispatcher service.
+ * The dispatcher manages event listeners and dispatches events to them.
+ *
+ * @example
+ * ```typescript
+ * const dispatcher = app.make<DispatcherContract>('events');
+ *
+ * // Register a listener
+ * dispatcher.listen(UserRegistered, SendWelcomeEmail);
+ *
+ * // Dispatch an event
+ * dispatcher.dispatch(new UserRegistered(user));
+ * ```
+ */
+export interface DispatcherContract {
+    /**
+     * Register an event listener
+     *
+     * @param events - Event name(s) to listen for
+     * @param listener - Listener to invoke when event is dispatched
+     *
+     * @example
+     * ```typescript
+     * // Single event
+     * dispatcher.listen('user.registered', SendWelcomeEmail);
+     *
+     * // Multiple events
+     * dispatcher.listen(['user.registered', 'user.updated'], LogUserActivity);
+     *
+     * // Wildcard
+     * dispatcher.listen('user.*', LogAllUserEvents);
+     * ```
+     */
+    listen(events: string | string[], listener: EventListener): void;
+    /**
+     * Check if an event has any listeners
+     *
+     * @param eventName - The event name to check
+     * @returns True if the event has listeners
+     */
+    hasListeners(eventName: string): boolean;
+    /**
+     * Register an event subscriber
+     *
+     * Subscribers can register multiple event listeners at once
+     *
+     * @param subscriber - The subscriber instance
+     *
+     * @example
+     * ```typescript
+     * class UserEventSubscriber implements EventSubscriber {
+     *   subscribe(events: DispatcherContract) {
+     *     events.listen('user.registered', this.onRegistered.bind(this));
+     *     events.listen('user.updated', this.onUpdated.bind(this));
+     *   }
+     *
+     *   onRegistered(event: UserRegistered) { }
+     *   onUpdated(event: UserUpdated) { }
+     * }
+     *
+     * dispatcher.subscribe(new UserEventSubscriber());
+     * ```
+     */
+    subscribe(subscriber: EventSubscriber): void;
+    /**
+     * Dispatch an event to all listeners
+     *
+     * @param event - Event name or instance
+     * @param payload - Additional arguments to pass to listeners
+     * @param halt - Stop dispatching if a listener returns false
+     * @returns Array of results from listeners
+     *
+     * @example
+     * ```typescript
+     * // Dispatch with event instance
+     * dispatcher.dispatch(new UserRegistered(user));
+     *
+     * // Dispatch with event name and payload
+     * dispatcher.dispatch('user.registered', [user]);
+     *
+     * // Halt on first false return
+     * dispatcher.dispatch(new OrderProcessing(order), [], true);
+     * ```
+     */
+    dispatch(event: string | Event, payload?: any[], halt?: boolean): any[];
+    /**
+     * Dispatch an event until a listener returns a non-null response
+     *
+     * This is useful for events where you want the first "truthy" response
+     *
+     * @param event - Event name or instance
+     * @param payload - Additional arguments to pass to listeners
+     * @returns The first non-null response from a listener
+     *
+     * @example
+     * ```typescript
+     * // Get the first validation result
+     * const isValid = dispatcher.until(new ValidateOrder(order));
+     * ```
+     */
+    until(event: string | Event, payload?: any[]): any;
+    /**
+     * Queue an event for later dispatch
+     *
+     * @param event - Event name
+     * @param payload - Event payload
+     *
+     * @example
+     * ```typescript
+     * dispatcher.push('send.notification', [user, message]);
+     * // Later...
+     * dispatcher.flush('send.notification');
+     * ```
+     */
+    push(event: string, payload?: any[]): void;
+    /**
+     * Flush (dispatch) all queued events for a specific event name
+     *
+     * @param event - Event name to flush
+     */
+    flush(event: string): void;
+    /**
+     * Remove all listeners for an event
+     *
+     * @param event - Event name
+     */
+    forget(event: string): void;
+    /**
+     * Clear all queued events
+     */
+    forgetPushed(): void;
+    /**
+     * Get raw listener mappings
+     *
+     * @returns Map of event names to their listeners
+     */
+    getRawListeners(): Map<string, EventListener[]>;
+}
+//# sourceMappingURL=Dispatcher.d.ts.map

package/dist/Events/Contracts/Dispatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Dispatcher.d.ts","sourceRoot":"","sources":["../../../src/Events/Contracts/Dispatcher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACtC,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAE/D;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;;;;;;;;;;;;;;OAiBG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,QAAQ,EAAE,aAAa,GAAG,IAAI,CAAC;IAEjE;;;;;OAKG;IACH,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;IAEzC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,SAAS,CAAC,UAAU,EAAE,eAAe,GAAG,IAAI,CAAC;IAE7C;;;;;;;;;;;;;;;;;;;OAmBG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,GAAG,EAAE,CAAC;IAExE;;;;;;;;;;;;;;OAcG;IACH,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE,GAAG,GAAG,CAAC;IAEnD;;;;;;;;;;;;OAYG;IACH,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IAE3C;;;;OAIG;IACH,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAE3B;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAE5B;;OAEG;IACH,YAAY,IAAI,IAAI,CAAC;IAErB;;;;OAIG;IACH,eAAe,IAAI,GAAG,CAAC,MAAM,EAAE,aAAa,EAAE,CAAC,CAAC;CACjD"}

package/dist/Events/Contracts/Dispatcher.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Dispatcher.js.map

package/dist/Events/Contracts/Dispatcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Dispatcher.js","sourceRoot":"","sources":["../../../src/Events/Contracts/Dispatcher.ts"],"names":[],"mappings":""}

package/dist/Events/Contracts/ShouldDispatchAfterCommit.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Should Dispatch After Commit Interface
+ *
+ * Marker interface for events that should only be dispatched
+ * after database transactions have been committed.
+ *
+ * This ensures that events are only fired if database changes
+ * are successfully persisted.
+ *
+ * @example
+ * ```typescript
+ * class UserRegistered extends Event implements ShouldDispatchAfterCommit {
+ *   constructor(public readonly user: User) {
+ *     super();
+ *   }
+ * }
+ * ```
+ */
+export interface ShouldDispatchAfterCommit {
+}
+//# sourceMappingURL=ShouldDispatchAfterCommit.d.ts.map

package/dist/Events/Contracts/ShouldDispatchAfterCommit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShouldDispatchAfterCommit.d.ts","sourceRoot":"","sources":["../../../src/Events/Contracts/ShouldDispatchAfterCommit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,yBAAyB;CAEzC"}

package/dist/Events/Contracts/ShouldDispatchAfterCommit.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ShouldDispatchAfterCommit.js.map

package/dist/Events/Contracts/ShouldDispatchAfterCommit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShouldDispatchAfterCommit.js","sourceRoot":"","sources":["../../../src/Events/Contracts/ShouldDispatchAfterCommit.ts"],"names":[],"mappings":""}