@converse/skeletor 0.0.9 → 2.0.0

package/src/types/element.d.ts

@@ -1,115 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,93 +0,0 @@
-/**
- * @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

@@ -1 +0,0 @@
-{"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"}

package/src/types/helpers.d.ts

@@ -1,62 +0,0 @@
-export function guid(): string;
-export function inherits(protoProps: any, staticProps: any): any;
-export function getResolveablePromise(): Promise<any> & {
-    isResolved: boolean;
-    isPending: boolean;
-    isRejected: boolean;
-    resolve: Function;
-    reject: Function;
-};
-export function urlError(): void;
-export function wrapError(model: any, options: any): void;
-/**
- * @typedef {import('./model.js').Model} Model
- * @typedef {import('./collection.js').Collection} Collection
- */
-/**
- * @param {Model | Collection} model
- */
-export function getSyncMethod(model: Model | Collection): any;
-/**
- * @typedef {Object} SyncOptions
- * @property {string} [url]
- * @property {any} [data]
- * @property {any} [attrs]
- * @property {Function} [success]
- * @property {Function} [error]
- * @property {any} [xhr]
- */
-/**
- * Override this function to change the manner in which Backbone persists
- * models to the server. You will be passed the type of request, and the
- * model in question. By default makes a `fetch()` API call
- * to the model's `url()`.
- *
- * Some possible customizations could be:
- *
- * - Use `setTimeout` to batch rapid-fire updates into a single request.
- * - Persist models via WebSockets instead of Ajax.
- * - Persist models to browser storage
- *
- * @param {'create'|'update'|'patch'} method
- * @param {import('./model.js').Model} model
- * @param {SyncOptions} [options]
- */
-export function sync(method: "create" | "update" | "patch", model: import("./model.js").Model, options?: SyncOptions): Promise<Response>;
-/**
- * Custom error for indicating timeouts
- * @namespace _converse
- */
-export class NotImplementedError extends Error {
-}
-export type Model = import("./model.js").Model;
-export type Collection = import("./collection.js").Collection;
-export type SyncOptions = {
-    url?: string;
-    data?: any;
-    attrs?: any;
-    success?: Function;
-    error?: Function;
-    xhr?: any;
-};
-//# sourceMappingURL=helpers.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../helpers.js"],"names":[],"mappings":"AAkBA,+BAGC;AASD,iEA6BC;AAED;gBAGgB,OAAO;eACP,OAAO;gBACP,OAAO;;;EAwCtB;AAGD,iCAEC;AAGD,0DAMC;AAWD;;;GAGG;AAGH;;GAEG;AACH,qCAFW,KAAK,GAAG,UAAU,OAK5B;AAED;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,6BAJW,QAAQ,GAAC,QAAQ,GAAC,OAAO,SACzB,OAAO,YAAY,EAAE,KAAK,YAC1B,WAAW,qBAsBrB;AAxLD;;;GAGG;AACH;CAAiD;oBAyHpC,OAAO,YAAY,EAAE,KAAK;yBAC1B,OAAO,iBAAiB,EAAE,UAAU;;UAcnC,MAAM;WACN,GAAG;YACH,GAAG;;;UAGH,GAAG"}

package/src/types/index.d.ts

@@ -1,19 +0,0 @@
-export default skeletor;
-declare namespace skeletor {
-    let VERSION: string;
-    function noConflict(): {
-        Collection: typeof Collection;
-        ElementView: typeof ElementView;
-        EventEmitter: typeof EventEmitter;
-        Model: typeof Model;
-        sync: typeof sync;
-    };
-}
-import { Collection } from './collection.js';
-import ElementView from './element.js';
-import EventEmitter from './eventemitter.js';
-import { Model } from './model.js';
-import Storage from './storage.js';
-import { sync } from './helpers.js';
-export { Collection, ElementView, EventEmitter, Model, Storage, sync };
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.js"],"names":[],"mappings":";;;IA+BA;;;;;;MAGC;;2BA9B0B,iBAAiB;wBAHpB,cAAc;yBACb,mBAAmB;sBAGtB,YAAY;oBAFd,cAAc;qBAGb,cAAc"}

package/src/types/listening.d.ts

@@ -1,40 +0,0 @@
-export default Listening;
-/**
- * A listening class that tracks and cleans up memory bindings
- * when all callbacks have been offed.
- */
-declare class Listening {
-    /** @typedef {import('./eventemitter.js').default} EventEmitter */
-    /**
-     * @param {any} listener
-     * @param {any} obj
-     */
-    constructor(listener: any, obj: any);
-    id: any;
-    listener: any;
-    obj: any;
-    interop: boolean;
-    count: number;
-    _events: any;
-    /**
-     * @param {string} name
-     * @param {Function} callback
-     * @param {any} context
-     * @param {Listening} _listening
-     */
-    start(name: string, callback: Function, context: any, _listening: Listening): this;
-    /**
-     * Stop's listening to a callback (or several).
-     * Uses an optimized counter if the listenee uses Backbone.Events.
-     * Otherwise, falls back to manual tracking to support events
-     * library interop.
-     * @param {string} name
-     * @param {Function} callback
-     */
-    stop(name: string, callback: Function): void;
-    /**
-     * Cleans up memory bindings between the listener and the listenee.
-     */
-    cleanup(): void;
-}
-//# sourceMappingURL=listening.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"listening.d.ts","sourceRoot":"","sources":["../listening.js"],"names":[],"mappings":";AAEA;;;GAGG;AACH;IAEE,kEAAkE;IAElE;;;OAGG;IACH,sBAHW,GAAG,OACH,GAAG,EASb;IANC,QAA4B;IAC5B,cAAwB;IACxB,SAAc;IACd,iBAAmB;IACnB,cAAc;IACd,aAAwB;IAG1B;;;;;OAKG;IACH,YALW,MAAM,+BAEN,GAAG,cACH,SAAS,QAmBnB;IAED;;;;;;;OAOG;IACH,WAHW,MAAM,4BAgBhB;IAED;;OAEG;IACH,gBAGC;CACF"}

package/src/types/model.d.ts

@@ -1,230 +0,0 @@
-export type Collection = import("./collection.js").Collection;
-export type Attributes = Record<string, any>;
-export type Options = Record<string, any>;
-export type ModelOptions = Record<string, any>;
-declare const Model_base: {
-    new (...args: any[]): {
-        on(name: string, callback: (event: any, model: 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: Model, collection: import("./collection.js").Collection, options: Record<string, any>) => any): /*elided*/ any;
-        _listeningTo: {};
-        _listenId: any;
-        off(name: string, callback: (event: any, model: Model, collection: import("./collection.js").Collection, options: Record<string, any>) => any, context?: any): /*elided*/ any;
-        stopListening(obj?: any, name?: string, callback?: (event: any, model: Model, collection: import("./collection.js").Collection, options: Record<string, any>) => any): /*elided*/ any;
-        once(name: string, callback: (event: any, model: Model, collection: import("./collection.js").Collection, options: Record<string, any>) => any, context: any): /*elided*/ any;
-        listenToOnce(obj: any, name: string, callback?: (event: any, model: Model, collection: import("./collection.js").Collection, options: Record<string, any>) => any): /*elided*/ any;
-        trigger(name: string, ...args: any[]): /*elided*/ any;
-    };
-} & ObjectConstructor;
-/**
- * @typedef {import('./collection.js').Collection} Collection
- * @typedef {Record.<string, any>} Attributes
- *
- * @typedef {Record.<string, any>} Options
- * @property {boolean} [validate]
- *
- * @typedef {Record.<string, any>} ModelOptions
- * @property {Collection} [collection]
- * @property {boolean} [parse]
- * @property {boolean} [unset]
- * @property {boolean} [silent]
- */
-/**
- * **Models** are the basic data object in the framework --
- * frequently representing a row in a table in a database on your server.
- * A discrete chunk of data and a bunch of useful, related methods for
- * performing computations and transformations on that data.
- */
-export class Model extends Model_base {
-    /**
-     * Create a new model with the specified attributes. A client id (`cid`)
-     * is automatically generated and assigned for you.
-     * @param {Attributes} [attributes]
-     * @param {ModelOptions} [options]
-     */
-    constructor(attributes?: Attributes, options?: ModelOptions, ...args: any[]);
-    cid: any;
-    attributes: {};
-    validationError: string;
-    collection: any;
-    changed: {};
-    /**
-     * @param {Storage} storage
-     */
-    set browserStorage(storage: Storage);
-    /**
-     * @returns {Storage} storage
-     */
-    get browserStorage(): Storage;
-    _browserStorage: Storage;
-    /**
-     * The default name for the JSON `id` attribute is `"id"`. MongoDB and
-     * CouchDB users may want to set this to `"_id"` (by overriding this getter
-     * in a subclass).
-     */
-    get idAttribute(): string;
-    /**
-     * The prefix is used to create the client id which is used to identify models locally.
-     * You may want to override this if you're experiencing name clashes with model ids.
-     */
-    get cidPrefix(): string;
-    /**
-     * 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 Model.
-     */
-    preinitialize(): void;
-    /**
-     * Initialize is an empty function by default. Override it with your own
-     * initialization logic.
-     * @param {Attributes} [attrs]
-     * @param {ModelOptions} [options]
-     */
-    initialize(attrs?: Attributes, options?: ModelOptions): void;
-    /**
-     * @param {object} attrs
-     * @param {object} [options]
-     * @returns {string} The validation error message
-     */
-    validate(attrs: object, options?: object): string;
-    /**
-     * Return a copy of the model's `attributes` object.
-     */
-    toJSON(): any;
-    /**
-     * Override this if you need custom syncing semantics for *this* particular model.
-     * @param {'create'|'update'|'patch'|'delete'|'read'} method
-     * @param {Model} model
-     * @param {Options} options
-     */
-    sync(method: "create" | "update" | "patch" | "delete" | "read", model: Model, options: Options): any;
-    /**
-     * Get the value of an attribute.
-     * @param {string} attr
-     */
-    get(attr: string): any;
-    keys(): string[];
-    values(): any[];
-    pairs(): [string, any][];
-    entries(): [string, any][];
-    invert(): any;
-    pick(...args: any[]): any;
-    omit(...args: any[]): any;
-    isEmpty(): any;
-    /**
-     * Returns `true` if the attribute contains a value that is not null
-     * or undefined.
-     * @param {string} attr
-     */
-    has(attr: string): boolean;
-    /**
-     * Special-cased proxy to lodash's `matches` method.
-     * @param {Attributes} attrs
-     */
-    matches(attrs: Attributes): boolean;
-    /**
-     * Set a hash of model attributes on the object, firing `"change"`. This is
-     * the core primitive operation of a model, updating the data and notifying
-     * anyone who needs to know about the change in state. The heart of the beast.
-     * @param {string|Object} key
-     * @param {string|Object} [val]
-     * @param {Options} [options]
-     */
-    set(key: string | any, val?: string | any, options?: Options): false | this;
-    _changing: boolean;
-    _previousAttributes: any;
-    id: any;
-    _pending: boolean | Options;
-    /**
-     * Remove an attribute from the model, firing `"change"`. `unset` is a noop
-     * if the attribute doesn't exist.
-     * @param {string} attr
-     * @param {Options} [options]
-     */
-    unset(attr: string, options?: Options): false | this;
-    /**
-     * Clear all attributes on the model, firing `"change"`.
-     * @param {Options} options
-     */
-    clear(options: Options): false | this;
-    /**
-     * Determine if the model has changed since the last `"change"` event.
-     * If you specify an attribute name, determine if that attribute has changed.
-     * @param {string} [attr]
-     */
-    hasChanged(attr?: string): any;
-    /**
-     * Return an object containing all the attributes that have changed, or
-     * false if there are no changed attributes. Useful for determining what
-     * parts of a view need to be updated and/or what attributes need to be
-     * persisted to the server. Unset attributes will be set to undefined.
-     * You can also pass an attributes object to diff against the model,
-     * determining if there *would be* a change.
-     * @param {Object} diff
-     */
-    changedAttributes(diff: any): any;
-    /**
-     * Get the previous value of an attribute, recorded at the time the last
-     * `"change"` event was fired.
-     * @param {string} [attr]
-     */
-    previous(attr?: string): any;
-    /**
-     * Get all of the attributes of the model at the time of the previous
-     * `"change"` event.
-     */
-    previousAttributes(): any;
-    /**
-     * Fetch the model from the server, merging the response with the model's
-     * local attributes. Any changed attributes will trigger a "change" event.
-     * @param {Options} [options={}]
-     */
-    fetch(options?: Options): any;
-    /**
-     * Set a hash of model attributes, and sync the model to the server.
-     * If the server returns an attributes hash that differs, the model's
-     * state will be `set` again.
-     * @param {string|Attributes} [key]
-     * @param {boolean|number|string|Options} [val]
-     * @param {Options} [options]
-     */
-    save(key?: string | Attributes, val?: boolean | number | string | Options, options?: Options): any;
-    /**
-     * Destroy this model on the server if it was already persisted.
-     * Optimistically removes the model from its collection, if it has one.
-     * If `wait: true` is passed, waits for the server to respond before removal.
-     * @param {Options} [options]
-     */
-    destroy(options?: Options): boolean;
-    /**
-     * Default URL for the model's representation on the server -- if you're
-     * using Backbone's restful methods, override this to change the endpoint
-     * that will be called.
-     */
-    url(): any;
-    /**
-     * **parse** converts a response into the hash of attributes to be `set` on
-     * the model. The default implementation is just to pass the response along.
-     * @param {Options} resp
-     * @param {Options} [options]
-     */
-    parse(resp: Options, options?: Options): Options;
-    /**
-     * A model is new if it has never been saved to the server, and lacks an id.
-     */
-    isNew(): boolean;
-    /**
-     * Check if the model is currently in a valid state.
-     * @param {Options} [options]
-     */
-    isValid(options?: Options): boolean;
-    /**
-     * Run validation against the next complete set of model attributes,
-     * returning `true` if all is well. Otherwise, fire an `"invalid"` event.
-     * @param {Attributes} attrs
-     * @param {Options} [options]
-     */
-    _validate(attrs: Attributes, options?: Options): boolean;
-}
-export {};
-//# sourceMappingURL=model.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../model.js"],"names":[],"mappings":"yBAgBa,OAAO,iBAAiB,EAAE,UAAU;yBACpC,MAAM,CAAE,MAAM,EAAE,GAAG,CAAC;sBAEpB,MAAM,CAAE,MAAM,EAAE,GAAG,CAAC;2BAGpB,MAAM,CAAE,MAAM,EAAE,GAAG,CAAC;;;;;;;;;;;;;;;;AAPjC;;;;;;;;;;;;GAYG;AAEH;;;;;GAKG;AACH;IACE;;;;;OAKG;IACH,yBAHW,UAAU,YACV,YAAY,kBAyBtB;IAlBC,SAAmC;IACnC,eAAoB;IAGpB,wBAA2B;IAEH,gBAAoC;IAW5D,YAAiB;IAGnB;;OAEG;IACH,4BAFW,OAAO,EAIjB;IAED;;OAEG;IACH,sBAFa,OAAO,CAInB;IARC,yBAA8B;IAUhC;;;;OAIG;IAEH,0BAEC;IAED;;;OAGG;IAEH,wBAEC;IAED;;;OAGG;IAEH,sBAAkB;IAElB;;;;;OAKG;IACH,mBAHW,UAAU,YACV,YAAY,QAEM;IAE7B;;;;OAIG;IACH,gBAJW,MAAM,YACN,MAAM,GACJ,MAAM,CAIlB;IAED;;OAEG;IACH,cAEC;IAED;;;;;OAKG;IAEH,aALW,QAAQ,GAAC,QAAQ,GAAC,OAAO,GAAC,QAAQ,GAAC,MAAM,SACzC,KAAK,WACL,OAAO,OAKjB;IAED;;;OAGG;IACH,UAFW,MAAM,OAIhB;IAED,iBAEC;IAED,gBAEC;IAED,yBAEC;IAED,2BAEC;IAED,cAEC;IAED,0BAKC;IAED,0BAKC;IAED,eAEC;IAED;;;;OAIG;IACH,UAFW,MAAM,WAIhB;IAED;;;OAGG;IACH,eAFW,UAAU,WAIpB;IAED;;;;;;;OAOG;IACH,SAJW,MAAM,MAAO,QACb,MAAM,MAAO,YACb,OAAO,gBAuEjB;IA/CC,mBAAqB;IAGnB,yBAAiD;IAqBpB,QAAoC;IAI7C,4BAAuB;IAqB/C;;;;;OAKG;IACH,YAHW,MAAM,YACN,OAAO,gBAIjB;IAED;;;OAGG;IACH,eAFW,OAAO,gBAMjB;IAED;;;;OAIG;IACH,kBAFW,MAAM,OAKhB;IAED;;;;;;;;OAQG;IACH,kCAeC;IAED;;;;OAIG;IACH,gBAFW,MAAM,OAKhB;IAED;;;OAGG;IACH,0BAEC;IAED;;;;OAIG;IACH,gBAFW,OAAO,OAgBjB;IAED;;;;;;;OAOG;IACH,WAJW,MAAM,GAAC,UAAU,QACjB,OAAO,GAAC,MAAM,GAAC,MAAM,GAAC,OAAO,YAC7B,OAAO,OAiEjB;IAED;;;;;OAKG;IACH,kBAFW,OAAO,WA2BjB;IAED;;;;OAIG;IACH,WAKC;IAED;;;;;OAKG;IACH,YAHW,OAAO,YACP,OAAO,WAIjB;IAED;;OAEG;IACH,iBAEC;IAED;;;OAGG;IACH,kBAFW,OAAO,WAIjB;IAED;;;;;OAKG;IACH,iBAHW,UAAU,YACV,OAAO,WASjB;CACF"}

package/src/types/storage.d.ts

@@ -1,35 +0,0 @@
-export default Storage;
-declare class Storage {
-    constructor(id: any, type: any, batchedWrites?: boolean);
-    storeInitialized: Promise<void>;
-    store: any;
-    name: any;
-    /**
-     * @param {'local'|'session'|'indexed'|'in_memory'} type
-     * @param {boolean} batchedWrites
-     */
-    initStore(type: "local" | "session" | "indexed" | "in_memory", batchedWrites: boolean): Promise<void>;
-    flush(): any;
-    clear(): Promise<void>;
-    sync(): {
-        (method: any, model: any, options: any): Promise<void>;
-        __name__: string;
-    };
-    removeCollectionReference(model: any, collection: any): any;
-    addCollectionReference(model: any, collection: any): any;
-    getCollectionReferenceData(model: any): {};
-    save(model: any): Promise<any>;
-    create(model: any, options: any): Promise<any>;
-    update(model: any): Promise<any>;
-    find(model: any): any;
-    findAll(): Promise<any[]>;
-    destroy(model: any, collection: any): Promise<any>;
-    getStorageSize(): any;
-    getItemName(id: any): string;
-}
-declare namespace Storage {
-    export let sessionStorageInitialized: Promise<void>;
-    export { localForage };
-}
-import localForage from 'localforage';
-//# sourceMappingURL=storage.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../storage.js"],"names":[],"mappings":";AAkBA;IACE,yDAgBC;IATG,gCAA2D;IAE3D,WAAiB;IAMnB,UAAc;IAGhB;;;OAGG;IACH,gBAHW,OAAO,GAAC,SAAS,GAAC,SAAS,GAAC,WAAW,iBACvC,OAAO,iBAgBjB;IAED,aAEC;IAED,uBAMC;IAED;;;MAiFC;IAED,4DAOC;IAED,yDAUC;IAED,2CAYC;IAED,+BAYC;IAED,+CASC;IAED,iCAEC;IAED,sBAEC;IAED,0BASC;IAED,mDAKC;IAED,sBAEC;IAED,6BAEC;CACF;;;;;wBA/OuB,aAAa"}

package/src/types/utils/events.d.ts

@@ -1,28 +0,0 @@
-/**
- * Iterates over the standard `event, callback` (as well as the fancy multiple
- * space-separated events `"change blur", callback` and jQuery-style event
- * maps `{event: callback}`).
- */
-export function eventsApi(iteratee: any, events: any, name: any, callback: any, opts: any): any;
-export function onApi(events: any, name: any, callback: any, options: any): any;
-/**
- * An try-catch guarded #on function, to prevent poisoning the global
- * `_listening` variable.
- * @param {any} obj
- * @param {string} name
- * @param {Function} callback
- * @param {any} context
- */
-export function tryCatchOn(obj: any, name: string, callback: Function, context: any): any;
-/**
- * The reducing API that removes a callback from the `events` object.
- */
-export function offApi(events: any, name: any, callback: any, options: any): any;
-/**
- * Reduces the event callbacks into a map of `{event: onceWrapper}`.
- * `offer` unbinds the `onceWrapper` after it has been called.
- */
-export function onceMap(map: any, name: any, callback: any, offer: any): any;
-/** Handles triggering the appropriate event callbacks. */
-export function triggerApi(objEvents: any, name: any, callback: any, args: any): any;
-//# sourceMappingURL=events.d.ts.map

package/src/types/utils/events.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../utils/events.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,gGAmBC;AAGD,gFAWC;AAED;;;;;;;GAOG;AACH,gCALW,GAAG,QACH,MAAM,+BAEN,GAAG,OAQb;AAED;;GAEG;AACH,iFAkDC;AAED;;;GAGG;AACH,6EASC;AAED,0DAA0D;AAC1D,qFASC"}