eventify 2.0.1 → 3.0.0

package/README.md

@@ -1,226 +1,385 @@
 # Eventify
 
-Eventify is a lightweight module that can be mixed in to any object in order to provide it with custom events. It has no external dependencies. Based on Backbone.Events
+Tiny event emitter with strict TypeScript types, wildcard namespaces, and optional schema validation.
 
-[![Build Status](https://secure.travis-ci.org/bermi/eventify.png?branch=master)](http://travis-ci.org/bermi/eventify)
+- ESM only, tree-shakeable
+- Node 20+, Bun, modern browsers
+- Backbone-style semantics (`all`, listener snapshots, predictable order)
 
-[![browser support](http://ci.testling.com/bermi/eventify.png)](http://ci.testling.com/bermi/eventify)
+## Install
 
-*(non-ES5 environments require an ES5 shim)*
+```bash
+npm install eventify
+```
 
-## Installing
+## Quickstart
 
-### On the browser
+```ts
+import { createEmitter } from "eventify";
 
-A 3.19 kB (1.4K gzipped) browser ready version is available on the dist/ folder.
+const emitter = createEmitter();
 
-    <script src="dist/eventify.min.js" type="text/javascript"></script>
+emitter.on("alert", (message) => {
+  console.log(message);
+});
 
+emitter.trigger("alert", "hello");
+```
 
-### Node.js
+## Usage
 
-    $ npm install eventify
+### Mixins
 
+```ts
+import { decorateWithEvents } from "eventify";
 
-### Ender support
+const target = decorateWithEvents({ name: "service" });
+```
 
-    ender add eventify
+### Typed Events
 
-Will provide access to the $.eventify function
+```ts
+type Events = {
+  ready: void;
+  "change:title": string;
+  data: [string, number];
+};
 
+const emitter = createEmitter<Events>();
 
-## Documentation
+emitter.on("data", (name, count) => {
+  console.log(name, count);
+});
 
-Eventify is a module that can be mixed in to any object, giving the object the ability to bind and trigger custom named events. Events do not have to be declared before they are bound, and may take passed arguments. For example:
+emitter.trigger("data", "hello", 42);
+```
 
-    var object = {};
+### Event Maps + Space-Delimited Names
 
-    Eventify.enable(object);
+```ts
+emitter.on({
+  "change:title": () => console.log("title"),
+  "change:author": () => console.log("author"),
+});
 
-    object.on("alert", function(msg) {
-      alert("Triggered " + msg);
-    });
+emitter.on("open close", () => console.log("toggled"));
+```
 
-    object.trigger("alert", "an event");
+### Namespaces + Wildcards
 
-The prototype is also exposed so you can extend it:
+Event names are split by `namespaceDelimiter` (default `/`). The `wildcard` token (default `*`) matches segments.
 
-    function MyEmitter() {
-      // ...
-    }
+- `*` in the middle matches one segment
+- trailing `*` matches remaining segments
+- `*` alone matches any event (use `"all"` if you need the event name)
+- leading/trailing delimiters create empty segments that must match exactly
 
-    MyEmitter.prototype = Object.create(Eventify.proto);
+```ts
+const emitter = createEmitter({
+  namespaceDelimiter: "/",
+  wildcard: "*",
+});
 
-    MyEmitter.prototype.foo = function () {
-      //...
-    };
+emitter.on("/product/foo/org/123/user/56/*", () => {
+  console.log("any account for that user");
+});
 
-If you want to create a plain emitter in a lightweight manner, use `Eventify.create()`:
+emitter.on("/product/foo/org/123/*", () => {
+  console.log("any user in org 123");
+});
 
-    var emitter = Eventify.create();
+emitter.on("/product/foo/*", () => {
+  console.log("any org in product foo");
+});
 
-    emitter.on("foo", function (message) {
-      //...
-    })
+emitter.trigger("/product/foo/org/123/user/56/account/abcd");
+```
 
+Middle-segment wildcards:
 
-### *enable* Eventify.enable(destination)
+```ts
+emitter.on("/product/foo/org/*/tracked-object/*/assesment", () => {
+  console.log("any tracked-object assesment within an org");
+});
+```
 
-Copies the methods on, off and trigger to the destination object, and returns the destination object.
+Colon namespaces:
 
-For example, to make a handy event dispatcher that can coordinate events among different areas of your application:
+```ts
+const emitter = createEmitter({
+  namespaceDelimiter: ":",
+  wildcard: "*",
+});
 
-    var dispatcher = Eventify.enable()
+emitter.on("namespace:foo:*", () => {
+  console.log("any sub-event in namespace:foo");
+});
+```
 
+### Schemas (Zod v4 Compatible)
 
-### *on* object.on(event, callback, [context])
+Any schema with `parse` or `safeParse` works. Zod is supported via DI.
 
-Bind a callback function to an object. The callback will be invoked whenever the event is fired. If you have a large number of different events, the convention is to use colons to namespace them: "poll:start", or "change:selection". The event string may also be a space-delimited list of several events...
+```ts
+import { z } from "zod";
+import { createEmitter, setDefaultSchemaValidator } from "eventify";
 
-    book.on("change:title change:author", ...);
+const schemas = {
+  data: z.tuple([z.string(), z.number()]),
+  ready: z.undefined(),
+};
 
-To supply a context value for this when the callback is invoked, pass the optional third argument: model.on('change', this.render, this)
+const emitter = createEmitter({
+  schemas,
+  validate: setDefaultSchemaValidator,
+});
 
-Callbacks bound to the special "all" event will be triggered when any event occurs, and are passed the name of the event as the first argument. For example, to proxy all events from one object to another:
+emitter.on("data", (name, count) => {
+  console.log(name, count);
+});
 
-    proxy.on("all", function(eventName) {
-      object.trigger(eventName);
-    });
+emitter.trigger("data", "hello", 1);
+```
 
+Validation runs on `trigger`/`emit`/`produce`. If validation fails, the call throws and no listeners run.
 
-All event methods also support an event map syntax, as an alternative to positional arguments:
+### Error Handling
 
-    book.on({
-      "change:title": titleView.update,
-      "change:author": authorPane.update,
-      "destroy": bookView.remove
-    });
+Listener failures never crash by default. Errors are routed to `onError`.
 
+```ts
+const emitter = createEmitter({
+  onError: (error, meta) => {
+    console.error(meta.event, error);
+  },
+});
 
-### *off* object.off([event], [callback], [context])
+emitter.on("boom", () => {
+  throw new Error("nope");
+});
 
-Remove a previously-bound callback function from an object. If no context is specified, all of the versions of the callback with different contexts will be removed. If no callback is specified, all callbacks for the event will be removed. If no event is specified, all event callbacks on the object will be removed.
+emitter.trigger("boom");
+```
 
-    // Removes just the `onChange` callback.
-    object.off("change", onChange);
+### EventTarget Interop
 
-    // Removes all "change" callbacks.
-    object.off("change");
+`createEmitter` and `decorateWithEvents` expose `addEventListener`, `removeEventListener`, and `dispatchEvent`.
 
-    // Removes the `onChange` callback for all events.
-    object.off(null, onChange);
+`trigger`/`emit`/`produce` dispatch a `CustomEvent` with the payload in `event.detail`.
+`dispatchEvent` only uses the EventTarget path (and matching `on` listeners). It does not run schemas, patterns, or `"all"`.
+`detail` is the single payload for 1-arg events, an array for multi-arg events, and `undefined` for no-arg events.
 
-    // Removes all callbacks for `context` for all events.
-    object.off(null, null, context);
+### Async Iteration
 
-    // Removes all callbacks on `object`.
-    object.off();
+```ts
+const emitter = createEmitter();
+const iterator = emitter.iterate("data");
 
+emitter.trigger("data", "a", 1);
 
-### *trigger* object.trigger(event, [*args])
+const { value } = await iterator.next();
+// value -> ["a", 1]
+```
 
-Trigger callbacks for the given event, or space-delimited list of events. Subsequent arguments to trigger will be passed along to the event callbacks.
+Iterate all events:
 
-### **once** object.once(event, callback, [context])
+```ts
+const all = emitter.iterate("all");
+emitter.trigger("ready");
+const { value } = await all.next();
+// value -> ["ready"]
+```
 
-Just like on, but causes the bound callback to only fire once before being removed. Handy for saying "the next time that X happens, do this".
+Abort with an `AbortSignal`:
 
+```ts
+const controller = new AbortController();
+const iterator = emitter.iterate("data", { signal: controller.signal });
+controller.abort();
+```
+
+`for await` with abort:
+
+```ts
+const controller = new AbortController();
 
-### **listenTo** object.listenTo(other, event, callback)
+(async () => {
+  for await (const value of emitter.iterate("data", {
+    signal: controller.signal,
+  })) {
+    console.log(value);
+    controller.abort();
+  }
+})();
+```
 
-Tell an object to listen to a particular event on an other object. The advantage of using this form, instead of other.on(event, callback, object), is that listenTo allows the object to keep track of the events, and they can be removed all at once later on. The callback will always be called with object as context.
+### Failure Modes + Constraints
 
-    view.listenTo(model, 'change', view.render);
-
-### **stopListening** object.stopListening([other], [event], [callback])
-
-Tell an object to stop listening to events. Either call stopListening with no arguments to have the object remove all of its registered callbacks ... or be more precise by telling it to remove just the events it's listening to on a specific object, or a specific event, or just a specific callback.
-
-    view.stopListening();
-
-    view.stopListening(model);
-
-### **listenToOnce** object.listenToOnce(other, event, callback)
-
-Just like listenTo, but causes the bound callback to only fire once before being removed.
-
-
-### *noConflict* var LocalEventify = Eventify.noConflict();
-
-Returns the Eventify object back to its original value. You can use the return value of Eventify.noConflict() to keep a local reference to Eventify. Useful for embedding Eventify on third-party websites, where you don't want to clobber the existing Eventify object.
-
-    var localEventify = Eventify.noConflict();
-    var model = localEventify.enable();
-
-
-Another option is to bind the Eventify library to the window object using a different name. You can do so by declaring the localEventifyLibraryName before loading the Eventify library code. For example:
-
-    <script>var localEventifyLibraryName = 'EventManager';</script>
-    <script src="/dist/eventify.min.js" type="text/javascript"></script>
-    <script>
-        var dispatcher = EventManager.enable();
-    </script>
-
-
-## Testing
-
-In order to run the tests you will need to have nodejs installed.
-
-Install dev dependencies with:
-
-    $ npm install
-
-And then run the tests with:
-
-    $ make test
-
-### On the browser
-
-    $ make test-browser
-
-### Code coverage
-
-You will need to install https://github.com/visionmedia/node-jscoverage
-and then run
-
-    $ make test-coverage
-
-## Development watcher and test runner
-
-### Continuous linting
-
-    $ make dev
-
-### Continuous testing
-
-    $ make test-watch
-
-### Continuous linting + testing
-
-    $ make dev-test
+- Validation failure: `trigger`/`emit`/`produce` throws and no listeners run (including wildcard and `all`).
+- Listener errors: thrown errors or rejected promises are routed to `onError` and do not stop other listeners.
+- Invalid callbacks: invoking a non-function throws a `TypeError` that is routed to `onError`.
+- `onError` failures: errors thrown by the handler are swallowed to avoid crashing producers.
+- `iterate` backpressure: if producers emit faster than you consume, the iterator queue grows. Use `AbortSignal`, `return()`, or stop iteration.
+- `listenTo`/`listenToOnce`: the target must be an Eventify emitter (or another object with compatible `on`/`once`/`off`).
+
+Constraint tools:
+
+- Payload: `schemas` + `validate` enforce data shape at emit time.
+- Cardinality: `once` / `listenToOnce`.
+- Lifetime: `off` / `stopListening` / `iterate` + `AbortSignal`.
+- Namespace scope: `namespaceDelimiter` + `wildcard`.
+- Errors: `onError` centralizes listener failures.
+
+### Semantics
+
+- Dispatch order: event listeners, then matching patterns, then `"all"`.
+- Listener lists are snapshotted at emit time; mutations during dispatch do not affect the current cycle.
+- The `context` defaults to the emitter.
+- Duplicate registrations are allowed.
+- `"all"` is a compatibility feature (Backbone/Eventify style); it is not a standard `EventTarget` concept.
 
+## API
+
+### Preferred Named Exports
+
+```ts
+createEmitter([options]);
+decorateWithEvents([target], [options]);
+setDefaultSchemaValidator(schema, payload, meta);
+```
+
+`createEmitter` returns a standalone emitter. `decorateWithEvents` mixes Eventify methods into an existing object.
+`setDefaultSchemaValidator` is the default validator function (no global mutation).
+
+### Default Export (Compat)
+
+```ts
+Eventify.create([options]);
+Eventify.enable([target], [options]);
+Eventify.defaultSchemaValidator;
+Eventify.version;
+Eventify.proto;
+```
+
+The `Eventify` default export remains for compatibility.
+
+### Options
+
+```ts
+type EventifyOptions = {
+  schemas?: Record<string, SchemaLike>;
+  validate?: SchemaValidator;
+  onError?: (
+    error: unknown,
+    meta: {
+      event: string;
+      args: unknown[];
+      listener?: (...args: unknown[]) => unknown;
+      emitter: object;
+    },
+  ) => void;
+  namespaceDelimiter?: string; // default "/"
+  wildcard?: string; // default "*"
+};
+```
+
+### Events
+
+```ts
+on(event, callback, [context])
+on({ event: callback, ... }, [context])
+on("a b c", callback, [context])
+```
+
+```ts
+once(event, callback, [context])
+once({ event: callback, ... }, [context])
+once("a b c", callback, [context])
+```
+
+```ts
+off()
+off(event, [callback], [context])
+off({ event: callback, ... }, [context])
+```
+
+```ts
+trigger(event, ...args);
+emit(event, ...args);
+produce(event, ...args);
+```
+
+`emit` and `produce` are aliases of `trigger`.
+
+### EventTarget Interop
+
+```ts
+addEventListener(type, listener, [options]);
+removeEventListener(type, listener, [options]);
+dispatchEvent(event);
+```
+
+### Cross-Emitter Listening
+
+```ts
+listenTo(other, event, callback)
+listenTo(other, { event: callback, ... })
+```
+
+```ts
+listenToOnce(other, event, callback)
+listenToOnce(other, { event: callback, ... })
+```
+
+```ts
+stopListening([other], [event], [callback]);
+```
+
+### Async Iteration
+
+```ts
+iterate(event, [options]);
+```
+
+For `"all"`, each value is `[eventName, ...args]`. For other events, a single argument is yielded as a value; multiple arguments are yielded as an array.
+
+### Type Exports
+
+```ts
+EventMap;
+EventName;
+EventHandler;
+EventHandlerMap;
+SchemaLike;
+SchemaMap;
+SchemaValidator;
+EventsFromSchemas;
+```
+
+## Benchmarks + Changelog
+
+- `BENCHMARKS.md`
+- `CHANGELOG.md`
+
+## Development + Release
+
+```bash
+bun install
+bun run format
+bun test --coverage
+bun run build:all
+bunx playwright install --with-deps chromium
+bun run test:browser
+bun run test:all
+bun run ci:local
+```
+
+```bash
+bun run publish
+```
+
+`ci:local` requires `act` installed locally.
 
 ## License
 
-(The MIT License)
-
-Copyright (c) 2012 Bermi Ferrer &lt;bermi@bermilabs.com&gt;
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-'Software'), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+MIT

package/dist/index.d.ts

@@ -0,0 +1,117 @@
+export type EventMap = Record<string, unknown>;
+export type PayloadArgs<T> = [T] extends [void] ? [] : [T] extends [undefined] ? [] : T extends readonly unknown[] ? T : [T];
+export type PayloadValue<T> = T extends readonly unknown[] ? T : T;
+export type EventName<Events extends EventMap> = Extract<keyof Events, string>;
+export type EventHandler<T> = (...args: PayloadArgs<T>) => unknown;
+export type AllHandler<Events extends EventMap> = (event: EventName<Events>, ...args: unknown[]) => unknown;
+export type EventHandlerMap<Events extends EventMap> = {
+    [K in keyof Events]?: EventHandler<Events[K]>;
+};
+export type SchemaLike<T = unknown> = {
+    parse: (input: unknown) => T;
+} | {
+    safeParse: (input: unknown) => {
+        success: true;
+        data: T;
+    } | {
+        success: false;
+        error: unknown;
+    };
+};
+export type SchemaMap = Record<string, SchemaLike>;
+export type InferSchema<S> = S extends {
+    parse: (input: unknown) => infer T;
+} ? T : S extends {
+    safeParse: (input: unknown) => {
+        success: true;
+        data: infer T;
+    };
+} ? T : unknown;
+export type EventsFromSchemas<TSchemas> = TSchemas extends SchemaMap ? {
+    [K in keyof TSchemas]: InferSchema<TSchemas[K]>;
+} : EventMap;
+export type ValidationMeta = {
+    event: string;
+};
+export type SchemaValidator<TSchema extends SchemaLike = SchemaLike> = (schema: TSchema, payload: unknown, meta: ValidationMeta) => unknown;
+export type ErrorMeta<Events extends EventMap> = {
+    event: EventName<Events> | string;
+    args: unknown[];
+    listener?: (...args: unknown[]) => unknown;
+    emitter: object;
+};
+export type ErrorHandler<Events extends EventMap> = (error: unknown, meta: ErrorMeta<Events>) => void;
+export type EventifyOptions<TSchemas extends SchemaMap | undefined = undefined, TEvents extends EventMap = EventMap> = {
+    schemas?: TSchemas;
+    validate?: SchemaValidator;
+    onError?: ErrorHandler<TEvents>;
+    namespaceDelimiter?: string;
+    wildcard?: string;
+};
+export type IterateOptions = {
+    signal?: AbortSignal;
+};
+export interface EventifyEmitter<Events extends EventMap = EventMap> {
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions): void;
+    dispatchEvent(event: Event): boolean;
+    on<K extends EventName<Events>>(name: K, callback: EventHandler<Events[K]>, context?: unknown): this;
+    on(name: "all", callback: AllHandler<Events>, context?: unknown): this;
+    on(name: EventHandlerMap<Events>, context?: unknown): this;
+    on(name: string, callback?: (...args: unknown[]) => unknown, context?: unknown): this;
+    once<K extends EventName<Events>>(name: K, callback: EventHandler<Events[K]>, context?: unknown): this;
+    once(name: "all", callback: AllHandler<Events>, context?: unknown): this;
+    once(name: EventHandlerMap<Events>, context?: unknown): this;
+    once(name: string, callback?: (...args: unknown[]) => unknown, context?: unknown): this;
+    off(): this;
+    off<K extends EventName<Events>>(name: K, callback?: EventHandler<Events[K]> | null, context?: unknown): this;
+    off(name: EventHandlerMap<Events>, context?: unknown): this;
+    off(name?: string | null, callback?: ((...args: unknown[]) => unknown) | null, context?: unknown): this;
+    trigger<K extends EventName<Events>>(name: K, ...args: PayloadArgs<Events[K]>): this;
+    trigger(name: string, ...args: unknown[]): this;
+    emit<K extends EventName<Events>>(name: K, ...args: PayloadArgs<Events[K]>): this;
+    emit(name: string, ...args: unknown[]): this;
+    produce<K extends EventName<Events>>(name: K, ...args: PayloadArgs<Events[K]>): this;
+    produce(name: string, ...args: unknown[]): this;
+    listenTo<OtherEvents extends EventMap, K extends EventName<OtherEvents>>(other: EventifyEmitter<OtherEvents>, name: K, callback: EventHandler<OtherEvents[K]>): this;
+    listenTo<OtherEvents extends EventMap>(other: EventifyEmitter<OtherEvents>, name: EventHandlerMap<OtherEvents>): this;
+    listenTo(other: EventifyEmitter<EventMap>, name: string, callback?: (...args: unknown[]) => unknown): this;
+    listenToOnce<OtherEvents extends EventMap, K extends EventName<OtherEvents>>(other: EventifyEmitter<OtherEvents>, name: K, callback: EventHandler<OtherEvents[K]>): this;
+    listenToOnce<OtherEvents extends EventMap>(other: EventifyEmitter<OtherEvents>, name: EventHandlerMap<OtherEvents>): this;
+    listenToOnce(other: EventifyEmitter<EventMap>, name: string, callback?: (...args: unknown[]) => unknown): this;
+    stopListening<OtherEvents extends EventMap>(other?: EventifyEmitter<OtherEvents> | null, name?: EventName<OtherEvents> | EventHandlerMap<OtherEvents> | null, callback?: ((...args: unknown[]) => unknown) | null): this;
+    iterate<K extends EventName<Events>>(name: K, options?: IterateOptions): AsyncIterableIterator<PayloadValue<Events[K]>>;
+    iterate(name: "all", options?: IterateOptions): AsyncIterableIterator<[EventName<Events>, ...unknown[]]>;
+    iterate(name: string, options?: IterateOptions): AsyncIterableIterator<unknown>;
+}
+export interface EventifyStatic<Events extends EventMap = EventMap> extends EventifyEmitter<Events> {
+    version: string;
+    enable<TTarget extends object, TSchemas extends SchemaMap>(target: TTarget | undefined, options: EventifyOptions<TSchemas, EventsFromSchemas<TSchemas>> & {
+        schemas: TSchemas;
+    }): TTarget & EventifyEmitter<EventsFromSchemas<TSchemas>>;
+    enable<TTarget extends object, TEvents extends EventMap = EventMap, TSchemas extends SchemaMap | undefined = undefined>(target?: TTarget, options?: EventifyOptions<TSchemas, TEvents>): TTarget & EventifyEmitter<TEvents>;
+    create<TSchemas extends SchemaMap>(options: EventifyOptions<TSchemas, EventsFromSchemas<TSchemas>> & {
+        schemas: TSchemas;
+    }): EventifyEmitter<EventsFromSchemas<TSchemas>>;
+    create<TEvents extends EventMap = EventMap, TSchemas extends SchemaMap | undefined = undefined>(options?: EventifyOptions<TSchemas, TEvents>): EventifyEmitter<TEvents>;
+    mixin: EventifyStatic["enable"];
+    proto: EventifyEmitter<EventMap>;
+    noConflict: () => EventifyStatic<Events>;
+    defaultSchemaValidator: SchemaValidator;
+}
+export declare function defaultSchemaValidator(schema: SchemaLike, payload: unknown, _meta: ValidationMeta): unknown;
+export declare function createEventify<TSchemas extends SchemaMap>(options: EventifyOptions<TSchemas, EventsFromSchemas<TSchemas>> & {
+    schemas: TSchemas;
+}): EventifyEmitter<EventsFromSchemas<TSchemas>>;
+export declare function createEventify<TEvents extends EventMap = EventMap, TSchemas extends SchemaMap | undefined = undefined>(options?: EventifyOptions<TSchemas, TEvents>): EventifyEmitter<TEvents>;
+export declare function enable<TTarget extends object, TSchemas extends SchemaMap>(target: TTarget | undefined, options: EventifyOptions<TSchemas, EventsFromSchemas<TSchemas>> & {
+    schemas: TSchemas;
+}): TTarget & EventifyEmitter<EventsFromSchemas<TSchemas>>;
+export declare function enable<TTarget extends object, TEvents extends EventMap = EventMap, TSchemas extends SchemaMap | undefined = undefined>(target?: TTarget, options?: EventifyOptions<TSchemas, TEvents>): TTarget & EventifyEmitter<TEvents>;
+declare const Eventify: EventifyStatic;
+declare const createEmitter: typeof createEventify;
+declare const decorateWithEvents: typeof enable;
+declare const setDefaultSchemaValidator: typeof defaultSchemaValidator;
+export { Eventify, createEmitter, decorateWithEvents, setDefaultSchemaValidator, };
+export default Eventify;
+//# sourceMappingURL=index.d.ts.map