@converse/skeletor 0.0.8 → 0.0.9

package/src/types/collection.d.ts

@@ -0,0 +1,366 @@
+export type Options = Record<string, any>;
+export type Attributes = Record<string, any>;
+export type Storage = import("./storage.js").default;
+export type CollectionOptions = Record<string, any>;
+declare const Collection_base: {
+    new (...args: any[]): {
+        on(name: string, callback: (event: any, model: Model, collection: Collection, options: Record<string, any>) => any, context: any): /*elided*/ any;
+        _events: any;
+        _listeners: {};
+        listenTo(obj: any, name: string, callback?: (event: any, model: Model, collection: Collection, options: Record<string, any>) => any): /*elided*/ any;
+        _listeningTo: {};
+        _listenId: any;
+        off(name: string, callback: (event: any, model: Model, collection: Collection, options: Record<string, any>) => any, context?: any): /*elided*/ any;
+        stopListening(obj?: any, name?: string, callback?: (event: any, model: Model, collection: Collection, options: Record<string, any>) => any): /*elided*/ any;
+        once(name: string, callback: (event: any, model: Model, collection: Collection, options: Record<string, any>) => any, context: any): /*elided*/ any;
+        listenToOnce(obj: any, name: string, callback?: (event: any, model: Model, collection: Collection, options: Record<string, any>) => any): /*elided*/ any;
+        trigger(name: string, ...args: any[]): /*elided*/ any;
+    };
+} & ObjectConstructor;
+/**
+ * @typedef {Record.<string, any>} Options
+ * @typedef {Record.<string, any>} Attributes
+ *
+ * @typedef {import('./storage.js').default} Storage
+ *
+ * @typedef {Record.<string, any>} CollectionOptions
+ * @property {Model} [model]
+ * @property {Function} [comparator]
+ */
+/**
+ * If models tend to represent a single row of data, a Collection is
+ * more analogous to a table full of data ... or a small slice or page of that
+ * table, or a collection of rows that belong together for a particular reason
+ * -- all of the messages in this particular folder, all of the documents
+ * belonging to this particular author, and so on. Collections maintain
+ * indexes of their models, both in order, and for lookup by `id`.
+ */
+export class Collection extends Collection_base {
+    /**
+     * Create a new **Collection**, perhaps to contain a specific type of `model`.
+     * If a `comparator` is specified, the Collection will maintain
+     * its models in sort order, as they're added and removed.
+     * @param {Model[]} [models]
+     * @param {CollectionOptions} [options]
+     */
+    constructor(models?: Model[], options?: CollectionOptions, ...args: any[]);
+    _model: any;
+    comparator: any;
+    /**
+     * @param {Storage} storage
+     */
+    set browserStorage(storage: Storage);
+    /**
+     * @returns {Storage} storage
+     */
+    get browserStorage(): Storage;
+    _browserStorage: import("./storage.js").default;
+    /**
+     * @param {Model} model
+     */
+    set model(model: Model);
+    /**
+     * The default model for a collection is just a **Model**.
+     * This should be overridden in most cases.
+     * @returns {typeof Model}
+     */
+    get model(): typeof Model;
+    get length(): any;
+    /**
+     * preinitialize is an empty function by default. You can override it with a function
+     * or object.  preinitialize will run before any instantiation logic is run in the Collection.
+     */
+    preinitialize(): void;
+    /**
+     * Initialize is an empty function by default. Override it with your own
+     * initialization logic.
+     */
+    initialize(): void;
+    /**
+     * The JSON representation of a Collection is an array of the
+     * models' attributes.
+     *@param {Options} options
+     */
+    toJSON(options: Options): any;
+    /**
+     *@param {string} method
+     *@param {Model|Collection} model
+     *@param {Options} options
+     */
+    sync(method: string, model: Model | Collection, options: Options): any;
+    /**
+     * Add a model, or list of models to the set. `models` may be
+     * Models or raw JavaScript objects to be converted to Models, or any
+     * combination of the two.
+     *@param {Model[]|Model|Attributes|Attributes[]} models
+     *@param {Options} options
+     */
+    add(models: Model[] | Model | Attributes | Attributes[], options: Options): any;
+    /**
+     * Remove a model, or a list of models from the set.
+     * @param {Model|Model[]} models
+     * @param {Options} options
+     */
+    remove(models: Model | Model[], options: Options): any;
+    /**
+     * Update a collection by `set`-ing a new list of models, adding new ones,
+     * removing models that are no longer present, and merging models that
+     * already exist in the collection, as necessary. Similar to **Model#set**,
+     * the core operation for updating the data contained by the collection.
+     *@param {Model[]|Model|Attributes|Attributes[]} models
+     * @param {Options} options
+     */
+    set(models: Model[] | Model | Attributes | Attributes[], options: Options): any;
+    clearStore(options?: {}, filter?: (o: any) => any): Promise<void>;
+    /**
+     * When you have more items than you want to add or remove individually,
+     * you can reset the entire set with a new list of models, without firing
+     * any granular `add` or `remove` events. Fires `reset` when finished.
+     * Useful for bulk operations and optimizations.
+     * @param {Model|Model[]} [models]
+     * @param {Options} [options]
+     */
+    reset(models?: Model | Model[], options?: Options): Model | Model[];
+    /**
+     * Add a model to the end of the collection.
+     * @param {Model} model
+     * @param {Options} [options]
+     */
+    push(model: Model, options?: Options): any;
+    /**
+     * Remove a model from the end of the collection.
+     * @param {Options} [options]
+     */
+    pop(options?: Options): any;
+    /**
+     * Add a model to the beginning of the collection.
+     * @param {Model} model
+     * @param {Options} [options]
+     */
+    unshift(model: Model, options?: Options): any;
+    /**
+     * Remove a model from the beginning of the collection.
+     * @param {Options} [options]
+     */
+    shift(options?: Options): any;
+    /** Slice out a sub-array of models from the collection. */
+    slice(...args: any[]): any;
+    /**
+     * @param {Function|Object} callback
+     * @param {any} thisArg
+     */
+    filter(callback: Function | any, thisArg: any): any;
+    /**
+     * @param {Function} pred
+     */
+    every(pred: Function): any;
+    /**
+     * @param {Model[]} values
+     */
+    difference(values: Model[]): any;
+    max(): any;
+    min(): any;
+    drop(n?: number): any;
+    /**
+     * @param {Function|Object} pred
+     */
+    some(pred: Function | any): any;
+    sortBy(iteratee: any): any;
+    isEmpty(): boolean;
+    keyBy(iteratee: any): any;
+    each(callback: any, thisArg: any): any;
+    forEach(callback: any, thisArg: any): any;
+    includes(item: any): any;
+    size(): any;
+    countBy(f: any): any;
+    groupBy(pred: any): any;
+    /**
+     * @param {number} fromIndex
+     */
+    indexOf(fromIndex: number): any;
+    /**
+     * @param {Function|string|RegExp} pred
+     * @param {number} fromIndex
+     */
+    findLastIndex(pred: Function | string | RegExp, fromIndex: number): any;
+    /**
+     * @param {number} fromIndex
+     */
+    lastIndexOf(fromIndex: number): any;
+    /**
+     * @param {Function|string|RegExp} pred
+     */
+    findIndex(pred: Function | string | RegExp): any;
+    last(): any;
+    head(): any;
+    first(): any;
+    map(cb: any, thisArg: any): any;
+    reduce(callback: any, initialValue: any): any;
+    reduceRight(callback: any, initialValue: any): any;
+    toArray(): any[];
+    /**
+     * Get a model from the set by id, cid, model object with id or cid
+     * properties, or an attributes object that is transformed through modelId.
+     * @param {string|number|Object|Model} obj
+     */
+    get(obj: string | number | any | Model): any;
+    /**
+     * Returns `true` if the model is in the collection.
+     * @param {string|number|Object|Model} obj
+     */
+    has(obj: string | number | any | Model): boolean;
+    /**
+     * Get the model at the given index.
+     * @param {number} index
+     */
+    at(index: number): any;
+    /**
+     * Return models with matching attributes. Useful for simple cases of
+     * `filter`.
+     * @param {Attributes} attrs
+     * @param {boolean} [first]
+     */
+    where(attrs: Attributes, first?: boolean): any;
+    /**
+     * Return the first model with matching attributes. Useful for simple cases
+     * of `find`.
+     * @param {Attributes} attrs
+     */
+    findWhere(attrs: Attributes): any;
+    /**
+     * @param {Attributes} predicate
+     * @param {number} [fromIndex]
+     */
+    find(predicate: Attributes, fromIndex?: number): any;
+    /**
+     * Force the collection to re-sort itself. You don't need to call this under
+     * normal circumstances, as the set will maintain sort order as each item
+     * is added.
+     * @param {Options} [options]
+     */
+    sort(options?: Options): this;
+    models: any;
+    /**
+     * Pluck an attribute from each model in the collection.
+     * @param {string} attr
+     */
+    pluck(attr: string): any;
+    /**
+     * Fetch the default set of models for this collection, resetting the
+     * collection when they arrive. If `reset: true` is passed, the response
+     * data will be passed through the `reset` method instead of `set`.
+     * @param {Options} options
+     */
+    fetch(options: Options): any;
+    /**
+     * Create a new instance of a model in this collection. Add the model to the
+     * collection immediately, unless `wait: true` is passed, in which case we
+     * wait for the server to agree.
+     * @param {Model|Attributes} model
+     * @param {Options} [options]
+     */
+    create(model: Model | Attributes, options?: Options): false | Model | (Promise<any> & {
+        isResolved: boolean;
+        isPending: boolean;
+        isRejected: boolean;
+        resolve: Function;
+        reject: Function;
+    }) | Attributes;
+    /**
+     * **parse** converts a response into a list of models to be added to the
+     * collection. The default implementation is just to pass it through.
+     * @param {Object} resp
+     * @param {Options} [options]
+     */
+    parse(resp: any, options?: Options): any;
+    /**
+     * Define how to uniquely identify models in the collection.
+     * @param {Attributes} attrs
+     */
+    modelId(attrs: Attributes): any;
+    /** Get an iterator of all models in this collection. */
+    values(): CollectionIterator;
+    /** Get an iterator of all model IDs in this collection. */
+    keys(): CollectionIterator;
+    /** Get an iterator of all [ID, model] tuples in this collection. */
+    entries(): CollectionIterator;
+    /**
+     * Private method to reset all internal state. Called when the collection
+     * is first initialized or reset.
+     */
+    _reset(): void;
+    _byId: {};
+    /**
+     * @param {Attributes} attrs
+     * @param {Options} [options]
+     */
+    createModel(attrs: Attributes, options?: Options): Model;
+    /**
+     * Prepare a hash of attributes (or other model) to be added to this
+     * collection.
+     * @param {Attributes|Model} attrs
+     * @param {Options} [options]
+     * @return {Model}
+     */
+    _prepareModel(attrs: Attributes | Model, options?: Options): Model;
+    /**
+     * Internal method called by both remove and set.
+     * @param {Model[]} models
+     * @param {Options} [options]
+     */
+    _removeModels(models: Model[], options?: Options): any[];
+    /**
+     * Method for checking whether an object should be considered a model for
+     * the purposes of adding to the collection.
+     * @param {any} model
+     */
+    _isModel(model: any): model is Model;
+    /**
+     * Internal method to create a model's ties to a collection.
+     * @param {Model} model
+     * @param {Options} [options]
+     */
+    _addReference(model: Model, options?: Options): void;
+    /**
+     * Internal method to sever a model's ties to a collection.
+     * @private
+     * @param {Model} model
+     * @param {Options} [options]
+     */
+    private _removeReference;
+    /**
+     * Internal method called every time a model in the set fires an event.
+     * Sets need to update their indexes when models change ids. All other
+     * events simply proxy through. "add" and "remove" events that originate
+     * in other collections are ignored.
+     * @private
+     * @param {any} event
+     * @param {Model} model
+     * @param {Collection} collection
+     * @param {Options} [options]
+     */
+    private _onModelEvent;
+    [Symbol.iterator]: () => CollectionIterator;
+}
+import { Model } from './model.js';
+declare class CollectionIterator {
+    /**
+     * A CollectionIterator implements JavaScript's Iterator protocol, allowing the
+     * use of `for of` loops in modern browsers and interoperation between
+     * Collection and other JavaScript functions and third-party libraries
+     * which can operate on Iterables.
+     * @param {Collection} collection
+     * @param {Number} kind
+     */
+    constructor(collection: Collection, kind: number);
+    _collection: Collection;
+    _kind: number;
+    _index: number;
+    next(): {
+        value: any;
+        done: boolean;
+    };
+    [Symbol.iterator](): this;
+}
+export {};
+//# sourceMappingURL=collection.d.ts.map

package/src/types/collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../collection.js"],"names":[],"mappings":"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"}

package/src/types/drivers/sessionStorage.d.ts

@@ -0,0 +1,37 @@
+export default sessionStorageWrapper;
+declare namespace sessionStorageWrapper {
+    export let _driver: string;
+    export { _initStorage };
+    export let _support: boolean;
+    export { iterate };
+    export { getItem };
+    export { setItem };
+    export { removeItem };
+    export { clear };
+    export { length };
+    export { key };
+    export { keys };
+    export { dropInstance };
+}
+declare function _initStorage(options: any): void;
+declare function iterate(iterator: any, callback: any): any;
+declare function getItem(key: any, callback: any): any;
+/**
+ * Set a key's value and run an optional callback once the value is set.
+ * Unlike Gaia's implementation, the callback function is passed the value,
+ * in case you want to operate on that value only after you're sure it
+ * saved, or something like that.
+ * @template T
+ * @param {string} key - The key under which the value is stored.
+ * @param {T} value - The value to be stored, can be of any type.
+ * @param {(err: any, value: T) => void} [callback] - Optional callback function to be called after the value is set.
+ * @returns {Promise<T>}
+ */
+declare function setItem<T>(key: string, value: T, callback?: (err: any, value: T) => void): Promise<T>;
+declare function removeItem(key: any, callback: any): any;
+declare function clear(callback: any): any;
+declare function length(callback: any): any;
+declare function key(n: any, callback: any): any;
+declare function keys(callback: any): any;
+declare function dropInstance(options: any, callback: any, ...args: any[]): Promise<void>;
+//# sourceMappingURL=sessionStorage.d.ts.map

package/src/types/drivers/sessionStorage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessionStorage.d.ts","sourceRoot":"","sources":["../../drivers/sessionStorage.js"],"names":[],"mappings":";;;;;;;;;;;;;;;AA0DA,kDAQC;AA2CD,4DA0CC;AA7DD,uDAgBC;AA8GD;;;;;;;;;;GAUG;AACH,yBANa,CAAC,OACH,MAAM,SACN,CAAC,aACD,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC,KAAK,IAAI,GAC1B,OAAO,CAAC,CAAC,CAAC,CA+BtB;AAjDD,0DAOC;AAhJD,2CAeC;AA+GD,4CAQC;AAlDD,iDAoBC;AAED,0CAiBC;AAiED,0FAiCC"}

package/src/types/element.d.ts

@@ -0,0 +1,115 @@
+export default ElementView;
+export type TemplateResult = import("lit-html").TemplateResult;
+declare const ElementView_base: {
+    new (...args: any[]): {
+        on(name: string, callback: (event: any, model: import("./model.js").Model, collection: import("./collection.js").Collection, options?: Record<string, any>) => any, context: any): /*elided*/ any;
+        _events: any;
+        _listeners: {};
+        listenTo(obj: any, name: string, callback?: (event: any, model: import("./model.js").Model, collection: import("./collection.js").Collection, options?: Record<string, any>) => any): /*elided*/ any;
+        _listeningTo: {};
+        _listenId: any;
+        off(name: string, callback: (event: any, model: import("./model.js").Model, collection: import("./collection.js").Collection, options?: Record<string, any>) => any, context?: any): /*elided*/ any;
+        stopListening(obj?: any, name?: string, callback?: (event: any, model: import("./model.js").Model, collection: import("./collection.js").Collection, options?: Record<string, any>) => any): /*elided*/ any;
+        once(name: string, callback: (event: any, model: import("./model.js").Model, collection: import("./collection.js").Collection, options?: Record<string, any>) => any, context: any): /*elided*/ any;
+        listenToOnce(obj: any, name: string, callback?: (event: any, model: import("./model.js").Model, collection: import("./collection.js").Collection, options?: Record<string, any>) => any): /*elided*/ any;
+        trigger(name: string, ...args: any[]): /*elided*/ any;
+    };
+} & {
+    new (): HTMLElement;
+    prototype: HTMLElement;
+};
+declare class ElementView extends ElementView_base {
+    /**
+     * @param {Options} options
+     */
+    constructor(options?: Record<string, any>);
+    /**
+     * @typedef {import('./model.js').Model} Model
+     * @typedef {import('./collection.js').Collection} Collection
+     * @typedef {Record.<string, any>} Options
+     *
+     * @callback EventCallback
+     * @param {any} event
+     * @param {Model} model
+     * @param {Collection} collection
+     * @param {Options} [options]
+     */
+    set events(events: {});
+    get events(): {};
+    _declarativeEvents: {};
+    stopListening: any;
+    cid: any;
+    _domEvents: any[];
+    createRenderRoot(): this;
+    connectedCallback(...args: any[]): void;
+    _initialized: boolean;
+    disconnectedCallback(): void;
+    /**
+     * preinitialize is an empty function by default. You can override it with a function
+     * or object.  preinitialize will run before any instantiation logic is run in the View
+     * eslint-disable-next-line class-methods-use-this
+     */
+    preinitialize(): void;
+    /**
+     * Initialize is an empty function by default. Override it with your own
+     * initialization logic.
+     */
+    initialize(): void;
+    beforeRender(): void;
+    afterRender(): void;
+    /**
+     * **render** is the core function that your view should override, in order
+     * to populate its element (`this.el`), with the appropriate HTML. The
+     * convention is for **render** to always return `this`.
+     */
+    render(): this;
+    /**
+     * @returns {string|TemplateResult}
+     */
+    toHTML(): string | TemplateResult;
+    /**
+     * Set callbacks, where `this.events` is a hash of
+     *
+     * *{"event selector": "callback"}*
+     *
+     *     {
+     *       'mousedown .title':  'edit',
+     *       'click .button':     'save',
+     *       'click .open':       function(e) { ... }
+     *     }
+     *
+     * pairs. Callbacks will be bound to the view, with `this` set properly.
+     * Uses event delegation for efficiency.
+     * Omitting the selector binds the event to `this.el`.
+     */
+    delegateEvents(): this;
+    /**
+     * Make a event delegation handler for the given `eventName` and `selector`
+     * and attach it to `this.el`.
+     * If selector is empty, the listener will be bound to `this.el`. If not, a
+     * new handler that will recursively traverse up the event target's DOM
+     * hierarchy looking for a node that matches the selector. If one is found,
+     * the event's `delegateTarget` property is set to it and the return the
+     * result of calling bound `listener` with the parameters given to the
+     * handler.
+     * @param {string} eventName
+     * @param {string} selector
+     * @param {(ev: Event) => any} listener
+     */
+    delegate(eventName: string, selector: string, listener: (ev: Event) => any): this | ((ev: Event) => any);
+    /**
+     * Clears all callbacks previously bound to the view by `delegateEvents`.
+     * You usually don't need to use this, but may wish to if you have multiple
+     * Backbone views attached to the same DOM element.
+     */
+    undelegateEvents(): this;
+    /**
+     * A finer-grained `undelegateEvents` for removing a single delegated event.
+     * `selector` and `listener` are both optional.
+     * @param {string} eventName
+     * @param {string} selector
+     * @param {(ev: Event) => any} listener
+     */
+    undelegate(eventName: string, selector: string, listener: (ev: Event) => any): this;
+}
+//# sourceMappingURL=element.d.ts.map

package/src/types/element.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"element.d.ts","sourceRoot":"","sources":["../element.js"],"names":[],"mappings":";6BAEa,OAAO,UAAU,EAAE,cAAc;;;;;;;;;;;;;;;;;;;AAS9C;IAsBE;;OAEG;IACH,2CAeC;IAtCD;;;;;;;;;;OAUG;IAEH,uBAEC;IAED,iBAEC;IALC,uBAAgC;IAchC,mBAAyB;IAIzB,SAA2B;IAE3B,kBAAoB;IAOtB,yBAGC;IAED,wCAOC;IAHG,sBAAwB;IAK5B,6BAGC;IAED;;;;OAIG;IACH,sBAAkB;IAElB;;;OAGG;IACH,mBAAe;IAEf,qBAAiB;IACjB,oBAAgB;IAEhB;;;;OAIG;IACH,eAKC;IAED;;OAEG;IACH,UAFa,MAAM,GAAC,cAAc,CAIjC;IAED;;;;;;;;;;;;;;OAcG;IACH,uBAaC;IAED;;;;;;;;;;;;OAYG;IACH,oBAJW,MAAM,YACN,MAAM,YACN,CAAC,EAAE,EAAE,KAAK,KAAK,GAAG,gBAAb,KAAK,KAAK,GAAG,EAsC5B;IAED;;;;OAIG;IACH,yBASC;IAED;;;;;;OAMG;IACH,sBAJW,MAAM,YACN,MAAM,YACN,CAAC,EAAE,EAAE,KAAK,KAAK,GAAG,QAyB5B;CACF"}

package/src/types/eventemitter.d.ts

@@ -0,0 +1,93 @@
+/**
+ * @function
+ * @template {new(...args: any[]) => {}} ClassConstructor
+ * @param {ClassConstructor} Base
+ */
+export function EventEmitter<ClassConstructor extends new (...args: any[]) => {}>(Base: ClassConstructor): {
+    new (...args: any[]): {
+        /**
+         * @typedef {import('./model.js').Model} Model
+         * @typedef {import('./collection.js').Collection} Collection
+         * @typedef {Record.<string, any>} Options
+         *
+         * @callback EventCallback
+         * @param {any} event
+         * @param {Model} model
+         * @param {Collection} collection
+         * @param {Options} [options]
+         */
+        /**
+         * Bind an event to a `callback` function. Passing `"all"` will bind
+         * the callback to all events fired.
+         * @param {string} name
+         * @param {EventCallback} callback
+         * @param {any} context
+         * @return {EventEmitter}
+         */
+        on(name: string, callback: (event: any, model: import("./model.js").Model, collection: import("./collection.js").Collection, options?: Record<string, any>) => any, context: any): /*elided*/ any;
+        _events: any;
+        _listeners: {};
+        /**
+         * Inversion-of-control versions of `on`. Tell *this* object to listen to
+         * an event in another object... keeping track of what it's listening to
+         * for easier unbinding later.
+         * @param {any} obj
+         * @param {string} name
+         * @param {EventCallback} [callback]
+         * @return {EventEmitter}
+         */
+        listenTo(obj: any, name: string, callback?: (event: any, model: import("./model.js").Model, collection: import("./collection.js").Collection, options?: Record<string, any>) => any): /*elided*/ any;
+        _listeningTo: {};
+        _listenId: any;
+        /**
+         * Remove one or many callbacks. If `context` is null, removes all
+         * callbacks with that function. If `callback` is null, removes all
+         * callbacks for the event. If `name` is null, removes all bound
+         * callbacks for all events.
+         * @param {string} name
+         * @param {EventCallback} callback
+         * @param {any} [context]
+         * @return {EventEmitter}
+         */
+        off(name: string, callback: (event: any, model: import("./model.js").Model, collection: import("./collection.js").Collection, options?: Record<string, any>) => any, context?: any): /*elided*/ any;
+        /**
+         * Tell this object to stop listening to either specific events ... or
+         * to every object it's currently listening to.
+         * @param {any} [obj]
+         * @param {string} [name]
+         * @param {EventCallback} [callback]
+         * @return {EventEmitter}
+         */
+        stopListening(obj?: any, name?: string, callback?: (event: any, model: import("./model.js").Model, collection: import("./collection.js").Collection, options?: Record<string, any>) => any): /*elided*/ any;
+        /**
+         * Bind an event to only be triggered a single time. After the first time
+         * the callback is invoked, its listener will be removed. If multiple events
+         * are passed in using the space-separated syntax, the handler will fire
+         * once for each event, not once for a combination of all events.
+         * @param {string} name
+         * @param {EventCallback} callback
+         * @param {any} context
+         * @return {EventEmitter}
+         */
+        once(name: string, callback: (event: any, model: import("./model.js").Model, collection: import("./collection.js").Collection, options?: Record<string, any>) => any, context: any): /*elided*/ any;
+        /**
+         * Inversion-of-control versions of `once`.
+         * @param {any} obj
+         * @param {string} name
+         * @param {EventCallback} [callback]
+         * @return {EventEmitter}
+         */
+        listenToOnce(obj: any, name: string, callback?: (event: any, model: import("./model.js").Model, collection: import("./collection.js").Collection, options?: Record<string, any>) => any): /*elided*/ any;
+        /**
+         * Trigger one or many events, firing all bound callbacks. Callbacks are
+         * passed the same arguments as `trigger` is, apart from the event name
+         * (unless you're listening on `"all"`, which will cause your callback to
+         * receive the true name of the event as the first argument).
+         * @param {string} name
+         * @return {EventEmitter}
+         */
+        trigger(name: string, ...args: any[]): /*elided*/ any;
+    };
+} & ClassConstructor;
+export default EventEmitter;
+//# sourceMappingURL=eventemitter.d.ts.map

package/src/types/eventemitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventemitter.d.ts","sourceRoot":"","sources":["../eventemitter.js"],"names":[],"mappings":"AAaA;;;;GAIG;AACH,6BAHyC,gBAAgB,SAA5C,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,EAAG,QAC7B,gBAAgB;kBADA,GAAG,EAAE;QAK5B;;;;;;;;;;WAUG;QAEH;;;;;;;WAOG;iBAJQ,MAAM,oBATN,GAAG,uIAWH,GAAG;;;QAqBd;;;;;;;;WAQG;sBAJQ,GAAG,QACH,MAAM,qBArCN,GAAG;;;QAiEd;;;;;;;;;WASG;kBAJQ,MAAM,oBAtEN,GAAG,wIAwEH,GAAG;QAad;;;;;;;WAOG;4BAJQ,GAAG,SACH,MAAM,qBAzFN,GAAG;QAiHd;;;;;;;;;WASG;mBAJQ,MAAM,oBAtHN,GAAG,uIAwHH,GAAG;QAUd;;;;;;WAMG;0BAJQ,GAAG,QACH,MAAM,qBArIN,GAAG;QA+Id;;;;;;;WAOG;sBAFQ,MAAM;;qBAUpB"}