@converse/skeletor 4.0.0 → 4.0.1

package/dist/skeletor.d.ts

@@ -1,953 +1,922 @@
-import localForage from 'localforage';
-
-/**
- * @deprecated Use `PersistentStorage` instead.
- * @public
- */
-export declare const BrowserStorage: typeof PersistentStorage;
-
-/**
- * @public
- */
-export declare type ClassConstructor<T = any> = new (...args: any[]) => T;
-
-/**
- * @public
- * 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 declare class Collection<T extends Model = Model> extends EventEmitterObject {
-    #private;
-    [key: symbol]: () => CollectionIterator<T>;
-    _storage?: PersistentStorage;
-    _comparator?: Comparator<T>;
-    _url: string;
-    hydrated?: Promise<void>;
-    models: T[];
-    protected _byId: Record<string, T>;
-    protected _model?: new (attributes?: Partial<ModelAttributes>, options?: ModelOptions) => T;
-    /**
-     * 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.
-     */
-    constructor(models?: T[] | ModelAttributes[] | T | ModelAttributes, options?: CollectionOptions<T>);
-    get comparator(): Comparator<T>;
-    set comparator(c: Comparator<T>);
-    /**
-     * The canonical storage accessor. Set to a `PersistentStorage` instance
-     * to enable local persistence for this collection.
-     */
-    get storage(): PersistentStorage | undefined;
-    set storage(s: PersistentStorage);
-    /**
-     * @deprecated Use `storage` instead.
-     */
-    get browserStorage(): PersistentStorage | undefined;
-    set browserStorage(s: PersistentStorage);
-    /**
-     * Override to return `true` to automatically load the collection from
-     * storage on construction. Await `hydrated` to know when hydration
-     * is complete.
-     *
-     * Note: collection `autoSync` is hydrate-only. Unlike `Model`, it does
-     * **not** schedule auto-saves when the collection changes (`add`/`remove`/
-     * `reset`). Persisting members is each model's responsibility — enable
-     * `autoSync` on the contained model class and every model writes its own
-     * record. A collection-level write would be redundant with that.
-     */
-    get autoSync(): boolean;
-    /**
-     * The default model for a collection is just a **Model**.
-     * This should be overridden in most cases.
-     */
-    get model(): new (attributes?: Partial<ModelAttributes>, options?: ModelOptions) => T | Model;
-    set model(model: new (attributes?: Partial<ModelAttributes>, options?: ModelOptions) => T);
-    get length(): number;
-    get url(): string;
-    set url(url: 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 Collection.
-     */
-    preinitialize(..._args: any[]): void;
-    /**
-     * Initialize is an empty function by default. Override it with your own
-     * initialization logic.
-     */
-    initialize(..._args: any[]): void;
-    /**
-     * The JSON representation of a Collection is an array of the
-     * models' attributes.
-     */
-    toJSON(): any[];
-    sync(method: SyncOperation, model: Model | Collection<any>, 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.
-     */
-    add(models: T[] | T | ModelAttributes | ModelAttributes[], options?: Options): T | T[];
-    /**
-     * Remove a model, or a list of models from the set.
-     */
-    remove(models: T | ObjectWithId | (T | ObjectWithId)[], options?: Options): T | T[];
-    /**
-     * 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.
-     */
-    set(models: T[] | T | ModelAttributes | ModelAttributes[], options?: Options): T | T[];
-    clearStore(options?: Options, filter?: (model: T) => boolean): 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.
-     */
-    reset(models?: T[] | T | ModelAttributes | ModelAttributes[], options?: Options): T | T[];
-    /**
-     * Add a model to the end of the collection.
-     */
-    push(model: T | ModelAttributes, options?: Options): T;
-    /**
-     * Remove a model from the end of the collection.
-     */
-    pop(options?: Options): T | undefined;
-    /**
-     * Add a model to the beginning of the collection.
-     */
-    unshift(model: T | ModelAttributes, options?: Options): T;
-    /**
-     * Remove a model from the beginning of the collection.
-     */
-    shift(options?: Options): T | undefined;
-    /** Slice out a sub-array of models from the collection. */
-    slice(start?: number, end?: number): T[];
-    filter(callback: ((model: T) => boolean) | string | Partial<ModelAttributes>, thisArg?: any): T[];
-    every(pred: ((attrs: ModelAttributes) => boolean) | Options): boolean;
-    difference(values: T[]): T[];
-    max(): number;
-    min(): number;
-    drop(n?: number): T[];
-    some(pred: ((attrs: ModelAttributes) => boolean) | Options): boolean;
-    sortBy(iteratee: string | ((model: T) => any) | Partial<ModelAttributes>): T[];
-    isEmpty(): boolean;
-    keyBy(iteratee: string | ((model: T) => string)): Record<string, T>;
-    each(callback: (model: T, index: number, array: T[]) => void, thisArg?: any): void;
-    forEach(callback: (model: T, index: number, array: T[]) => void, thisArg?: any): void;
-    includes(item: T): boolean;
-    size(): number;
-    countBy(f: string | ((model: T) => string) | Partial<ModelAttributes>): Record<string, number>;
-    groupBy(pred: string | ((model: T) => string | number) | Partial<ModelAttributes>): Record<string, T[]>;
-    indexOf(model: T, fromIndex?: number): number;
-    findLastIndex(pred: ((model: T) => boolean) | string | Partial<ModelAttributes>, fromIndex?: number): number;
-    lastIndexOf(model: T, fromIndex?: number): number;
-    findIndex(pred: ((model: T) => boolean) | string | Partial<ModelAttributes>): number;
-    last(): T | undefined;
-    head(): T | undefined;
-    first(): T | undefined;
-    map<U>(cb: string | ((model: T) => U) | Partial<ModelAttributes>, thisArg?: any): U[];
-    reduce<U = T>(callback: (accumulator: U, model: T, index: number, array: T[]) => U, initialValue?: U): U | T;
-    reduceRight<U = T>(callback: (accumulator: U, model: T, index: number, array: T[]) => U, initialValue?: U): U | T;
-    toArray(): T[];
-    /**
-     * 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.
-     */
-    get(obj?: string | number | ModelAttributes | T | null): T | undefined;
-    /**
-     * Returns `true` if the model is in the collection.
-     */
-    has(obj: string | number | ModelAttributes | T | null): boolean;
-    /**
-     * Get the model at the given index.
-     */
-    at(index: number): T | undefined;
-    /**
-     * Return models with matching attributes. Useful for simple cases of
-     * `filter`.
-     */
-    where(attrs: ModelAttributes | Partial<ModelAttributes>, first?: boolean): T[] | T | undefined;
-    /**
-     * Return the first model with matching attributes. Useful for simple cases
-     * of `find`.
-     */
-    findWhere(attrs: ModelAttributes): T | undefined;
-    find(predicate: ((model: T) => boolean) | Partial<ModelAttributes> | string, fromIndex?: number): T | undefined;
-    /**
-     * 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.
-     */
-    sort(options?: Options): this;
-    /**
-     * Pluck an attribute from each model in the collection.
-     */
-    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`.
-     */
-    fetch(options?: Options): Promise<any> | 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.
-     */
-    create(model: T | ModelAttributes, options?: FetchOrCreateOptions): Promise<T> | T;
-    /**
-     * Subscribe to collection changes (add, remove, reset, sort, update).
-     * Returns an unsubscribe function.
-     *
-     * `collection.subscribe(callback)` — fires once per operation on add/remove/reset/sort (via `update`, `reset`, `sort` events).
-     * `collection.subscribe(event, callback)` — subscribe to a specific event (base EventEmitter form).
-     *
-     * Compatible with React's `useSyncExternalStore` and other store-style APIs.
-     */
-    subscribe(event: string, callback: EventCallback, context?: unknown): () => void;
-    subscribe(callback: (collection: this) => void): () => void;
-    /**
-     * **parse** converts a response into a list of models to be added to the
-     * collection. The default implementation is just to pass it through.
-     */
-    parse(resp: any, _options?: Options): any;
-    /**
-     * Define how to uniquely identify models in the collection.
-     */
-    modelId(attrs: ModelAttributes): string | number | undefined;
-    /** Get an iterator of all models in this collection. */
-    values(): CollectionIterator<T>;
-    /**
-     * @public
-     * Enable for...of iteration over the collection.
-     */
-    [Symbol.iterator]: () => CollectionIterator<T>;
-    /** Get an iterator of all model IDs in this collection. */
-    keys(): CollectionIterator<T>;
-    /** Get an iterator of all [ID, model] tuples in this collection. */
-    entries(): CollectionIterator<T>;
-    /**
-     * Private method to reset all internal state. Called when the collection
-     * is first initialized or reset.
-     */
-    _reset(): void;
-    createModel(attrs: ModelAttributes, options?: Options): T;
-    /**
-     * Prepare a hash of attributes (or other model) to be added to this
-     * collection.
-     */
-    _prepareModel(attrs: ModelAttributes | T, options?: Options): T | null;
-    /**
-     * Internal method called by both remove and set.
-     */
-    _removeModels(models: (T | ObjectWithId)[], options?: Options): T[];
-    /**
-     * Method for checking whether an object should be considered a model for
-     * the purposes of adding to the collection.
-     */
-    _isModel(model: any): model is T;
-    /**
-     * Internal method to create a model's ties to a collection.
-     */
-    _addReference(model: T, _options?: Options): void;
-    /**
-     * Internal method to sever a model's ties to a collection.
-     */
-    _removeReference(model: T, _options?: Options): void;
-    /**
-     * 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.
-     */
-    _onModelEvent(event: string, model: T, collection: Collection<T>, options?: Options): void;
-}
-
-/**
- * @public
- */
-export declare class CollectionIterator<T extends Model> {
-    private _collection;
-    private _kind;
-    private _index;
-    /**
-     * 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.
-     */
-    constructor(collection: Collection<T>, kind: number);
-    next(): IteratorResult<any>;
-    [Symbol.iterator](): IterableIterator<any>;
-}
-
-/**
- * @public
- */
-export declare type CollectionOptions<T extends Model = Model> = Options & {
-    model?: new (attributes?: Partial<ModelAttributes>, options?: ModelOptions) => T;
-    comparator?: Comparator<T>;
-    previousModels?: Model[];
-};
-
-/**
- * @public
- */
-export declare type Comparator<T extends Model = Model> = string | boolean | ((a: T, b: T) => number) | ((a?: T) => string);
-
-/**
- * @public
- */
-export declare type ComputedProperties<M> = Record<string, ComputedProperty<M>>;
-
-/**
- * @public
- */
-export declare type ComputedProperty<M> = {
-    deps: string[];
-    fn: (model: M) => any;
-};
-
-/**
- * @public
- */
-export declare type EventCallback = (...args: any[]) => void;
-
-/**
- * @public
- */
-export declare type EventCallbackMap = Record<string, EventCallback>;
-
-/**
- * @public
- */
-export declare type EventContext = unknown;
-
-/**
- * @public
- */
-export declare function EventEmitter<T extends ClassConstructor>(Base: T): {
-    new (...args: any[]): {
-        [x: string]: any;
-        _events?: EventHandlersMap;
-        _listeners?: EventListenerMap;
-        _listeningTo?: EventListenerMap;
-        _listenId?: string;
-        /**
-         * Bind an event to a `callback` function. Passing `"all"` will bind
-         * the callback to all events fired.
-         */
-        on(name: string | EventCallbackMap, callback?: EventCallback | EventContext, context?: EventContext): /*elided*/ any;
-        /**
-         * 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.
-         */
-        listenTo(obj: ObjectListenedTo, name: string | EventCallbackMap, callback?: EventCallback): /*elided*/ 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.
-         */
-        off(name?: string | EventCallbackMap | null, callback?: EventCallback | EventContext | null, context?: EventContext): /*elided*/ any;
-        /**
-         * Tell this object to stop listening to either specific events ... or
-         * to every object it's currently listening to.
-         */
-        stopListening(obj?: any, name?: string | EventCallbackMap, callback?: EventCallback): /*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.
-         */
-        once(name: string | EventCallbackMap, callback?: EventCallback | EventContext, context?: EventContext): /*elided*/ any;
-        /**
-         * Inversion-of-control versions of `once`.
-         */
-        listenToOnce(obj: any, name: string | EventCallbackMap, callback?: EventCallback): /*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).
-         */
-        trigger(name: string, ...args: any[]): /*elided*/ any;
-        /**
-         * Subscribe to an event. Returns an unsubscribe function.
-         * Compatible with `useSyncExternalStore` and other store-style APIs.
-         */
-        subscribe(event: string, callback: EventCallback, context?: EventContext): () => void;
-    };
-} & T;
-
-/**
- * @public
- */
-export declare const EventEmitterObject: {
-    new (...args: any[]): {
-        [x: string]: any;
-        _events?: EventHandlersMap;
-        _listeners?: EventListenerMap;
-        _listeningTo?: EventListenerMap;
-        _listenId?: string;
-        /**
-         * Bind an event to a `callback` function. Passing `"all"` will bind
-         * the callback to all events fired.
-         */
-        on(name: string | EventCallbackMap, callback?: EventCallback | EventContext, context?: EventContext): /*elided*/ any;
-        /**
-         * 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.
-         */
-        listenTo(obj: ObjectListenedTo, name: string | EventCallbackMap, callback?: EventCallback): /*elided*/ 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.
-         */
-        off(name?: string | EventCallbackMap | null, callback?: EventCallback | EventContext | null, context?: EventContext): /*elided*/ any;
-        /**
-         * Tell this object to stop listening to either specific events ... or
-         * to every object it's currently listening to.
-         */
-        stopListening(obj?: any, name?: string | EventCallbackMap, callback?: EventCallback): /*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.
-         */
-        once(name: string | EventCallbackMap, callback?: EventCallback | EventContext, context?: EventContext): /*elided*/ any;
-        /**
-         * Inversion-of-control versions of `once`.
-         */
-        listenToOnce(obj: any, name: string | EventCallbackMap, callback?: EventCallback): /*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).
-         */
-        trigger(name: string, ...args: any[]): /*elided*/ any;
-        /**
-         * Subscribe to an event. Returns an unsubscribe function.
-         * Compatible with `useSyncExternalStore` and other store-style APIs.
-         */
-        subscribe(event: string, callback: EventCallback, context?: EventContext): () => void;
-    };
-} & ObjectConstructor;
-
-/**
- * @public
- */
-export declare interface EventHandler {
-    callback: EventCallback;
-    context: any;
-    ctx: any;
-    listening?: ListeningType | null;
-}
-
-/**
- * @public
- */
-export declare interface EventHandlersMap {
-    all?: EventHandler[];
-    [name: string]: EventHandler[];
-}
-
-/**
- * @public
- */
-export declare type EventListenerMap = Record<string, ListeningType>;
-
-/**
- * @public
- */
-export declare type FetchOrCreateOptions = Options & {
-    promise?: boolean;
-    success?: (m: Model, resp: any, callbackOpts: Options) => void;
-};
-
-/**
- * Return the PersistentStorage instance configured on `obj`, checking both
- * the canonical `storage` accessor and the deprecated `browserStorage` alias
- * so that subclasses that still override `get browserStorage()` continue to work.
- * @public
- */
-export declare function getStorage(obj: Model<any> | Collection<any> | null | undefined): PersistentStorage | undefined;
-
-/**
- * The error the default `sync` hands to `options.error`, and rejects with, for
- * a response outside the 2xx range.
- * @public
- */
-export declare class HTTPError extends Error {
-    readonly status: number;
-    readonly response: Response;
-    constructor(response: Response, method: string, url: string);
-}
-
-/**
- * @public
- */
-export declare interface IEventEmitter {
-    _events?: Record<string, any>;
-    _listeners?: ListeningMap;
-    _listeningTo?: ListeningMap;
-    _listenId?: string;
-    on(name: string | EventCallbackMap, callback?: EventCallback | EventContext, context?: EventContext): this;
-    off(name?: string | EventCallbackMap | null, callback?: EventCallback | EventContext | null, context?: EventContext): this;
-    trigger(name: string, ...args: any[]): this;
-    stopListening(obj?: any, name?: string | EventCallbackMap, callback?: EventCallback): this;
-    once(name: string | EventCallbackMap, callback?: EventCallback | EventContext, context?: EventContext): this;
-    listenTo(obj: ObjectListenedTo, name: string | EventCallbackMap, callback?: EventCallback): this;
-    listenToOnce(obj: any, name: string | EventCallbackMap, callback?: EventCallback): this;
-}
-
-/**
- * @public
- */
-export declare type ListeningMap = Record<string, ListeningType>;
-
-/**
- * @public
- */
-export declare interface ListeningType {
-    _events?: EventCallbackMap;
-    cleanup(): void;
-    count: number;
-    id: string;
-    interop: boolean;
-    listener: IEventEmitter;
-    obj: any;
-    start(name: string | EventCallbackMap, callback: EventCallback, context: any, _listening: ListeningType): this;
-    stop(name: string | EventCallbackMap, callback: EventCallback): void;
-}
-
-/**
- * @public
- * **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 declare class Model<T extends ModelAttributes = ModelAttributes> extends EventEmitterObject {
-    #private;
-    _storage?: PersistentStorage;
-    _changing: boolean;
-    _pending: boolean | ModelOptions;
-    _previousAttributes?: T;
-    _url: string;
-    _urlRoot: string;
-    attrs: T;
-    attributes: T;
-    changed: Partial<T>;
-    cid: string;
-    collection?: Collection;
-    id: string | number;
-    hydrated?: Promise<void>;
-    validationError: string | number | null;
-    /**
-     * Create a new model with the specified attributes. A client id (`cid`)
-     * is automatically generated and assigned for you.
-     */
-    constructor(attributes?: Partial<T>, options?: ModelOptions);
-    /**
-     * The canonical storage accessor. Set to a `PersistentStorage` instance
-     * to enable local persistence for this model.
-     */
-    get storage(): PersistentStorage | undefined;
-    set storage(s: PersistentStorage);
-    /**
-     * @deprecated Use `storage` instead.
-     */
-    get browserStorage(): PersistentStorage | undefined;
-    set browserStorage(s: PersistentStorage);
-    /**
-     * Override to enable automatic persistence. When true, any `set()` call
-     * that changes attributes will schedule a debounced save to `storage`, and
-     * the model will auto-hydrate from storage on construction.
-     */
-    get autoSync(): boolean;
-    /**
-     * Debounce delay (ms) for auto-save writes. Override to tune.
-     */
-    get autoSyncDelay(): number;
-    /**
-     * 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(...args: any[]): void;
-    /**
-     * Initialize is an empty function by default. Override it with your own
-     * initialization logic.
-     */
-    initialize(attrs?: Partial<T>, options?: ModelOptions): void;
-    validate(attrs: Partial<T> | ObjectWithId, options?: ModelOptions): string | number | null | void;
-    /**
-     * Return a hash of defaults for the model's attributes.
-     */
-    defaults(): Partial<T>;
-    /**
-     * Declare computed properties. Override in subclasses to define properties
-     * that derive their value from other attributes. Each entry specifies the
-     * attribute keys it depends on (`deps`) and a function (`fn`) that receives
-     * the model and returns the computed value. The value is cached and
-     * recalculated automatically when any dep changes, firing a `change:key`
-     * event.
-     */
-    get computed(): ComputedProperties<this>;
-    /**
-     * Return a copy of the model's `attributes` object.
-     */
-    toJSON(): T;
-    /**
-     * Override this if you need custom syncing semantics for *this* particular model.
-     */
-    sync(method: SyncOperation, model: Model<any>, options: Options): any;
-    /**
-     * Get the value of an attribute, or a computed property.
-     */
-    get<K extends keyof T>(attr: K): T[K];
-    keys(): string[];
-    values(): T[keyof T][];
-    pairs(): [keyof T, T[keyof T]][];
-    entries(): [keyof T, T[keyof T]][];
-    invert(): Record<string, keyof T>;
-    pick<K extends keyof T>(...args: K[]): Pick<T, K>;
-    omit<K extends keyof T>(...args: K[]): Omit<T, K>;
-    isEmpty(): boolean;
-    /**
-     * Returns `true` if the attribute contains a value that is not null
-     * or undefined.
-     */
-    has(attr: keyof T): boolean;
-    /**
-     * Returns `true` if the model's attributes satisfy `attrs`.
-     *
-     * An attributes object is compared with lodash's `isMatch`: a partial, deep
-     * comparison, so `{ form: { type: 'hidden' } }` matches a `form` attribute
-     * that has `type: 'hidden'` alongside other keys. A function is called with
-     * the attributes and its result coerced to a boolean.
-     *
-     * To scan a collection, prefer `Collection#find`, `filter` or `where`. They
-     * build their matcher once per scan instead of once per model.
-     */
-    matches(attrs: Partial<T> | ((attrs: T) => any)): 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.
-     */
-    set(key: string | Partial<T> | ObjectWithId, val?: any, options?: ModelOptions): this;
-    /**
-     * Remove an attribute from the model, firing `"change"`. `unset` is a noop
-     * if the attribute doesn't exist.
-     */
-    unset(attr: keyof T, options?: ModelOptions): this;
-    /**
-     * Clear all attributes on the model, firing `"change"`.
-     */
-    clear(options?: ModelOptions): this;
-    /**
-     * Determine if the model has changed since the last `"change"` event.
-     * If you specify an attribute name, determine if that attribute has changed.
-     */
-    hasChanged(attr?: keyof T): boolean;
-    /**
-     * 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.
-     */
-    changedAttributes(diff?: Partial<T>): Partial<T> | false;
-    /**
-     * Get the previous value of an attribute, recorded at the time the last
-     * `"change"` event was fired.
-     */
-    previous<K extends keyof T>(attr: K): T[K] | null;
-    /**
-     * Get all of the attributes of the model at the time of the previous
-     * `"change"` event.
-     */
-    previousAttributes(): T | undefined;
-    /**
-     * Fetch the model from the server, merging the response with the model's
-     * local attributes. Any changed attributes will trigger a "change" event.
-     */
-    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.
-     */
-    save(key?: string | null | Partial<T>, val?: any, options?: ModelOptions): 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.
-     */
-    destroy(options?: ModelOptions): any;
-    get urlRoot(): string;
-    set urlRoot(root: string);
-    /**
-     * 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.
-     */
-    get url(): string;
-    set url(url: string);
-    /**
-     * **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.
-     */
-    parse(resp: any, options?: ModelOptions): Partial<T> | null | void;
-    /**
-     * 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.
-     */
-    isValid(options?: ModelOptions): boolean;
-    /**
-     * Subscribe to model changes. Returns an unsubscribe function.
-     *
-     * `model.subscribe(callback)` — fires on any attribute change, receives `(model, changed)`.
-     * `model.subscribe(event, callback)` — subscribe to a specific event (base EventEmitter form).
-     *
-     * Compatible with React's `useSyncExternalStore` and other store-style APIs.
-     */
-    subscribe(event: string, callback: EventCallback, context?: unknown): () => void;
-    subscribe(callback: (model: this, changed: Partial<T>) => void): () => void;
-    /**
-     * Run validation against the next complete set of model attributes,
-     * returning `true` if all is well. Otherwise, fire an `"invalid"` event.
-     */
-    _validate(attrs: Partial<T> | ObjectWithId, options?: ModelOptions): boolean;
-}
-
-/**
- * @public
- */
-export declare type ModelAttributes = Record<string | number, any> & {
-    id?: string | number;
-};
-
-/**
- * @public
- */
-export declare type ModelOptions = Options & {
-    collection?: Collection;
-    parse?: boolean;
-    unset?: boolean;
-    silent?: boolean;
-    validate?: boolean;
-    /** Suppress the auto-save triggered by set() on autoSync models. */
-    noAutoSave?: boolean;
-    /** Mark a set() call as originating from a storage read; suppresses auto-save. */
-    fromStorage?: boolean;
-};
-
-/**
- * @public
- */
-export declare function noConflict(): any;
-
-/**
- * Constructor for a Node.js-only storage driver. Registered by the
- * `@converse/skeletor/node` entry point via {@link PersistentStorage.nodeStorage}.
- * @public
- */
-export declare type NodeStorageConstructor = new (name: string, storageDir?: string, inMemory?: boolean) => StorageDriver;
-
-/**
- * @public
- */
-export declare type ObjectListenedTo = object & {
-    _listenId?: string;
-};
-
-/**
- * @public
- */
-export declare type ObjectWithId = Record<string, any> & {
-    id: string | number;
-};
-
-/**
- * @public
- */
-export declare type Options = Record<string, any>;
-
-/**
- * @public
- */
-export declare class PersistentStorage {
-    storeInitialized: Promise<void>;
-    storeReady: boolean;
-    store: StorageDriver;
-    name: string;
-    static sessionStorageInitialized: Promise<void>;
-    static localForage: typeof localForage;
-    static nodeStorage: NodeStorageConstructor | null;
-    /**
-     * Directory the `'node'` store type writes its database files to. The driver's
-     * own default is relative, so it resolves against `process.cwd()` and a process
-     * started from two directories ends up with two separate sets of state. Set an
-     * absolute path (`$XDG_STATE_HOME/<app>`, say) to pin it. Left `null`, the
-     * driver's default applies.
-     *
-     * Only the `'node'` string store type reads this; passing a driver instance to
-     * the constructor means you've already chosen a directory yourself.
-     * @public
-     */
-    static nodeStorageDir: string | null;
-    /** Register a storage instance with a weak reference. @public */
-    static register(instance: PersistentStorage): void;
-    /**
-     * Flush the debounced write buffer of every registered PersistentStorage
-     * instance. Called automatically on pagehide/visibilitychange when autoSync
-     * is in use; can also be called manually.
-     * @public
-     */
-    static flushAll(): void;
-    constructor(id: string, type: StoreType | StorageDriver, batchedWrites?: boolean);
-    /**
-     * @param type - The storage type: 'local', 'session', 'indexed', 'node', or 'in_memory'
-     * @param batchedWrites - Whether to enable batched writes
-     */
-    initStore(type: StoreType, batchedWrites: boolean): Promise<void>;
-    flush(): void;
-    clear(): Promise<void>;
-    sync(): {
-        (method: SyncOperation, model: Model, options: SyncOptions): Promise<void>;
-        __name__: string;
-    };
-    removeCollectionReference(model: Model, collection: Collection | undefined): Promise<any> | undefined;
-    addCollectionReference(model: Model, collection: Collection | undefined): Promise<any> | undefined;
-    getCollectionReferenceData(model: Model): Record<string, string[]>;
-    save(model: Model): Promise<any>;
-    create(model: Model, options: SyncOptions): Promise<any>;
-    update(model: Model): Promise<any>;
-    find(model: Model): Promise<any>;
-    findAll(): Promise<any[]>;
-    destroy(model: Model, collection: Collection | undefined): Promise<Model>;
-    getStorageSize(): Promise<number>;
-    getItemName(id: string | number): string;
-}
-
-/**
- * @public
- */
-declare const skeletor: SkeletorType;
-export default skeletor;
-
-/**
- * @public
- */
-export declare interface SkeletorType {
-    Collection: typeof Collection;
-    EventEmitter: typeof EventEmitter;
-    Model: typeof Model;
-    sync: typeof sync;
-    HTTPError: typeof HTTPError;
-    VERSION?: string;
-    noConflict?: () => SkeletorType;
-}
-
-/**
- * Storage driver interface for key-value persistence.
- * @public
- */
-export declare interface StorageDriver {
-    ready(): Promise<void>;
-    setItem(key: string, value: any): Promise<any>;
-    getItem(key: string): Promise<any>;
-    removeItem(key: string): Promise<void>;
-    clear(): Promise<void>;
-    length(): Promise<number>;
-    key(keyIndex: number): Promise<string | null>;
-    keys(): Promise<string[]>;
-    /**
-     * Write several items in one go. A successful write is signalled by the
-     * promise settling, not by what it resolves with: drivers may resolve with
-     * the written items (localForage does) or with nothing, and callers must
-     * treat both as success.
-     */
-    setItems?(items: Record<string, any>): Promise<Record<string, any> | void>;
-    getItems?(keys: string[]): Promise<Record<string, any>>;
-    debouncedSetItems?: {
-        (items: Record<string, any>): Promise<Record<string, any> | void>;
-        flush?: () => void;
-    };
-}
-
-/**
- * @public
- */
-export declare type StoreType = 'local' | 'session' | 'indexed' | 'in_memory' | 'node';
-
-/**
- * The default `sync`: a JSON request over `fetch()` to the model's `url()`.
- * Override it (or `Model.sync`/`Collection.sync`) to change how models are
- * persisted, for instance to batch rapid-fire updates with `setTimeout`, to
- * talk over WebSockets, or to write to browser storage.
- *
- * It honours both contracts a `sync` may use. On a 2xx response the JSON body
- * (`null` when the body is empty) is passed to `options.success` and the
- * returned promise resolves with it. On a non-2xx response, a network failure
- * or an unparsable body, `options.error` receives the error (an `HTTPError`
- * for the first) and the promise rejects with it.
- *
- * `options.data` is sent as query parameters on GET, which may not carry a
- * body, and as a JSON body otherwise. For create, update and patch the body
- * defaults to `options.attrs` or the model's `toJSON()`.
- * @public
- */
-export declare function sync(method: SyncOperation, model: Model | Collection<any>, options?: SyncOptions): Promise<any>;
-
-/**
- * @public
- */
-export declare type SyncOperation = 'create' | 'update' | 'patch' | 'delete' | 'read';
-
-/**
- * @public
- */
-export declare interface SyncOptions {
-    url?: string;
-    data?: any;
-    attrs?: any;
-    success?: (data?: any, options?: SyncOptions) => void;
-    error?: (error: any) => void;
-    xhr?: any;
-    wait?: boolean;
-    collection?: Collection;
-}
-
-export { }
+import localForage from 'localforage';
+
+/**
+ * @public
+ * **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.
+ */
+declare class Model<T extends ModelAttributes = ModelAttributes> extends EventEmitterObject {
+    _storage?: PersistentStorage;
+    _changing: boolean;
+    _pending: boolean | ModelOptions;
+    _previousAttributes?: T;
+    _url: string;
+    _urlRoot: string;
+    attrs: T;
+    attributes: T;
+    changed: Partial<T>;
+    cid: string;
+    collection?: Collection;
+    id: string | number;
+    hydrated?: Promise<void>;
+    validationError: string | number | null;
+    /**
+     * Create a new model with the specified attributes. A client id (`cid`)
+     * is automatically generated and assigned for you.
+     */
+    constructor(attributes?: Partial<T>, options?: ModelOptions);
+    /**
+     * The canonical storage accessor. Set to a `PersistentStorage` instance
+     * to enable local persistence for this model.
+     */
+    get storage(): PersistentStorage | undefined;
+    set storage(s: PersistentStorage);
+    /**
+     * @deprecated Use `storage` instead.
+     */
+    get browserStorage(): PersistentStorage | undefined;
+    set browserStorage(s: PersistentStorage);
+    /**
+     * Override to enable automatic persistence. When true, any `set()` call
+     * that changes attributes will schedule a debounced save to `storage`, and
+     * the model will auto-hydrate from storage on construction.
+     */
+    get autoSync(): boolean;
+    /**
+     * Debounce delay (ms) for auto-save writes. Override to tune.
+     */
+    get autoSyncDelay(): number;
+    /**
+     * 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(...args: any[]): void;
+    /**
+     * Initialize is an empty function by default. Override it with your own
+     * initialization logic.
+     */
+    initialize(attrs?: Partial<T>, options?: ModelOptions): void;
+    validate(attrs: Partial<T> | ObjectWithId, options?: ModelOptions): string | number | null | void;
+    /**
+     * Return a hash of defaults for the model's attributes.
+     */
+    defaults(): Partial<T>;
+    /**
+     * Declare computed properties. Override in subclasses to define properties
+     * that derive their value from other attributes. Each entry specifies the
+     * attribute keys it depends on (`deps`) and a function (`fn`) that receives
+     * the model and returns the computed value. The value is cached and
+     * recalculated automatically when any dep changes, firing a `change:key`
+     * event.
+     */
+    get computed(): ComputedProperties<this>;
+    /**
+     * Return a copy of the model's `attributes` object.
+     */
+    toJSON(): T;
+    /**
+     * Override this if you need custom syncing semantics for *this* particular model.
+     */
+    sync(method: SyncOperation, model: Model<any>, options: Options): any;
+    /**
+     * Get the value of an attribute, or a computed property.
+     */
+    get<K extends keyof T>(attr: K): T[K];
+    keys(): string[];
+    values(): T[keyof T][];
+    pairs(): [keyof T, T[keyof T]][];
+    entries(): [keyof T, T[keyof T]][];
+    invert(): Record<string, keyof T>;
+    pick<K extends keyof T>(...args: K[]): Pick<T, K>;
+    omit<K extends keyof T>(...args: K[]): Omit<T, K>;
+    isEmpty(): boolean;
+    /**
+     * Returns `true` if the attribute contains a value that is not null
+     * or undefined.
+     */
+    has(attr: keyof T): boolean;
+    /**
+     * Returns `true` if the model's attributes satisfy `attrs`.
+     *
+     * An attributes object is compared with lodash's `isMatch`: a partial, deep
+     * comparison, so `{ form: { type: 'hidden' } }` matches a `form` attribute
+     * that has `type: 'hidden'` alongside other keys. A function is called with
+     * the attributes and its result coerced to a boolean.
+     *
+     * To scan a collection, prefer `Collection#find`, `filter` or `where`. They
+     * build their matcher once per scan instead of once per model.
+     */
+    matches(attrs: Partial<T> | ((attrs: T) => any)): 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.
+     */
+    set(key: string | Partial<T> | ObjectWithId, val?: any, options?: ModelOptions): this;
+    /**
+     * Remove an attribute from the model, firing `"change"`. `unset` is a noop
+     * if the attribute doesn't exist.
+     */
+    unset(attr: keyof T, options?: ModelOptions): this;
+    /**
+     * Clear all attributes on the model, firing `"change"`.
+     */
+    clear(options?: ModelOptions): this;
+    /**
+     * Determine if the model has changed since the last `"change"` event.
+     * If you specify an attribute name, determine if that attribute has changed.
+     */
+    hasChanged(attr?: keyof T): boolean;
+    /**
+     * 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.
+     */
+    changedAttributes(diff?: Partial<T>): Partial<T> | false;
+    /**
+     * Get the previous value of an attribute, recorded at the time the last
+     * `"change"` event was fired.
+     */
+    previous<K extends keyof T>(attr: K): T[K] | null;
+    /**
+     * Get all of the attributes of the model at the time of the previous
+     * `"change"` event.
+     */
+    previousAttributes(): T | undefined;
+    /**
+     * Fetch the model from the server, merging the response with the model's
+     * local attributes. Any changed attributes will trigger a "change" event.
+     */
+    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.
+     */
+    save(key?: string | null | Partial<T>, val?: any, options?: ModelOptions): 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.
+     */
+    destroy(options?: ModelOptions): any;
+    get urlRoot(): string;
+    set urlRoot(root: string);
+    /**
+     * 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.
+     */
+    get url(): string;
+    set url(url: string);
+    /**
+     * **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.
+     */
+    parse(resp: any, options?: ModelOptions): Partial<T> | null | void;
+    /**
+     * 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.
+     */
+    isValid(options?: ModelOptions): boolean;
+    /**
+     * Subscribe to model changes. Returns an unsubscribe function.
+     *
+     * `model.subscribe(callback)` — fires on any attribute change, receives `(model, changed)`.
+     * `model.subscribe(event, callback)` — subscribe to a specific event (base EventEmitter form).
+     *
+     * Compatible with React's `useSyncExternalStore` and other store-style APIs.
+     */
+    subscribe(event: string, callback: EventCallback, context?: unknown): () => void;
+    subscribe(callback: (model: this, changed: Partial<T>) => void): () => void;
+    /**
+     * Run validation against the next complete set of model attributes,
+     * returning `true` if all is well. Otherwise, fire an `"invalid"` event.
+     */
+    _validate(attrs: Partial<T> | ObjectWithId, options?: ModelOptions): boolean;
+}
+
+/**
+ * Storage driver interface for key-value persistence.
+ * @public
+ */
+interface StorageDriver {
+    ready(): Promise<void>;
+    setItem(key: string, value: any): Promise<any>;
+    getItem(key: string): Promise<any>;
+    removeItem(key: string): Promise<void>;
+    clear(): Promise<void>;
+    length(): Promise<number>;
+    key(keyIndex: number): Promise<string | null>;
+    keys(): Promise<string[]>;
+    /**
+     * Write several items in one go. A successful write is signalled by the
+     * promise settling, not by what it resolves with: drivers may resolve with
+     * the written items (localForage does) or with nothing, and callers must
+     * treat both as success.
+     */
+    setItems?(items: Record<string, any>): Promise<Record<string, any> | void>;
+    getItems?(keys: string[]): Promise<Record<string, any>>;
+    debouncedSetItems?: {
+        (items: Record<string, any>): Promise<Record<string, any> | void>;
+        flush?: () => void;
+    };
+}
+/**
+ * @public
+ */
+type StoreType = 'local' | 'session' | 'indexed' | 'in_memory' | 'node';
+
+/**
+ * Constructor for a Node.js-only storage driver. Registered by the
+ * `@converse/skeletor/node` entry point via {@link PersistentStorage.nodeStorage}.
+ * @public
+ */
+type NodeStorageConstructor = new (name: string, storageDir?: string, inMemory?: boolean) => StorageDriver;
+/**
+ * @public
+ */
+declare class PersistentStorage {
+    storeInitialized: Promise<void>;
+    storeReady: boolean;
+    store: StorageDriver;
+    name: string;
+    static sessionStorageInitialized: Promise<void>;
+    static localForage: typeof localForage;
+    static nodeStorage: NodeStorageConstructor | null;
+    /**
+     * Directory the `'node'` store type writes its database files to. The driver's
+     * own default is relative, so it resolves against `process.cwd()` and a process
+     * started from two directories ends up with two separate sets of state. Set an
+     * absolute path (`$XDG_STATE_HOME/<app>`, say) to pin it. Left `null`, the
+     * driver's default applies.
+     *
+     * Only the `'node'` string store type reads this; passing a driver instance to
+     * the constructor means you've already chosen a directory yourself.
+     * @public
+     */
+    static nodeStorageDir: string | null;
+    /** Register a storage instance with a weak reference. @public */
+    static register(instance: PersistentStorage): void;
+    /**
+     * Flush the debounced write buffer of every registered PersistentStorage
+     * instance. Called automatically on pagehide/visibilitychange when autoSync
+     * is in use; can also be called manually.
+     * @public
+     */
+    static flushAll(): void;
+    constructor(id: string, type: StoreType | StorageDriver, batchedWrites?: boolean);
+    /**
+     * @param type - The storage type: 'local', 'session', 'indexed', 'node', or 'in_memory'
+     * @param batchedWrites - Whether to enable batched writes
+     */
+    initStore(type: StoreType, batchedWrites: boolean): Promise<void>;
+    flush(): void;
+    clear(): Promise<void>;
+    sync(): {
+        (method: SyncOperation, model: Model, options: SyncOptions): Promise<void>;
+        __name__: string;
+    };
+    removeCollectionReference(model: Model, collection: Collection | undefined): Promise<any> | undefined;
+    addCollectionReference(model: Model, collection: Collection | undefined): Promise<any> | undefined;
+    getCollectionReferenceData(model: Model): Record<string, string[]>;
+    save(model: Model): Promise<any>;
+    create(model: Model, options: SyncOptions): Promise<any>;
+    update(model: Model): Promise<any>;
+    find(model: Model): Promise<any>;
+    findAll(): Promise<any[]>;
+    destroy(model: Model, collection: Collection | undefined): Promise<Model>;
+    getStorageSize(): Promise<number>;
+    getItemName(id: string | number): string;
+}
+
+/**
+ * @public
+ * 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`.
+ */
+declare class Collection<T extends Model = Model> extends EventEmitterObject {
+    [key: symbol]: () => CollectionIterator<T>;
+    _storage?: PersistentStorage;
+    _comparator?: Comparator<T>;
+    _url: string;
+    hydrated?: Promise<void>;
+    models: T[];
+    protected _byId: Record<string, T>;
+    protected _model?: new (attributes?: Partial<ModelAttributes>, options?: ModelOptions) => T;
+    /**
+     * 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.
+     */
+    constructor(models?: T[] | ModelAttributes[] | T | ModelAttributes, options?: CollectionOptions<T>);
+    get comparator(): Comparator<T>;
+    set comparator(c: Comparator<T>);
+    /**
+     * The canonical storage accessor. Set to a `PersistentStorage` instance
+     * to enable local persistence for this collection.
+     */
+    get storage(): PersistentStorage | undefined;
+    set storage(s: PersistentStorage);
+    /**
+     * @deprecated Use `storage` instead.
+     */
+    get browserStorage(): PersistentStorage | undefined;
+    set browserStorage(s: PersistentStorage);
+    /**
+     * Override to return `true` to automatically load the collection from
+     * storage on construction. Await `hydrated` to know when hydration
+     * is complete.
+     *
+     * Note: collection `autoSync` is hydrate-only. Unlike `Model`, it does
+     * **not** schedule auto-saves when the collection changes (`add`/`remove`/
+     * `reset`). Persisting members is each model's responsibility — enable
+     * `autoSync` on the contained model class and every model writes its own
+     * record. A collection-level write would be redundant with that.
+     */
+    get autoSync(): boolean;
+    /**
+     * The default model for a collection is just a **Model**.
+     * This should be overridden in most cases.
+     */
+    get model(): new (attributes?: Partial<ModelAttributes>, options?: ModelOptions) => T | Model;
+    set model(model: new (attributes?: Partial<ModelAttributes>, options?: ModelOptions) => T);
+    get length(): number;
+    get url(): string;
+    set url(url: 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 Collection.
+     */
+    preinitialize(..._args: any[]): void;
+    /**
+     * Initialize is an empty function by default. Override it with your own
+     * initialization logic.
+     */
+    initialize(..._args: any[]): void;
+    /**
+     * The JSON representation of a Collection is an array of the
+     * models' attributes.
+     */
+    toJSON(): any[];
+    sync(method: SyncOperation, model: Model | Collection<any>, 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.
+     */
+    add(models: T[] | T | ModelAttributes | ModelAttributes[], options?: Options): T | T[];
+    /**
+     * Remove a model, or a list of models from the set.
+     */
+    remove(models: T | ObjectWithId | (T | ObjectWithId)[], options?: Options): T | T[];
+    /**
+     * 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.
+     */
+    set(models: T[] | T | ModelAttributes | ModelAttributes[], options?: Options): T | T[];
+    clearStore(options?: Options, filter?: (model: T) => boolean): 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.
+     */
+    reset(models?: T[] | T | ModelAttributes | ModelAttributes[], options?: Options): T | T[];
+    /**
+     * Add a model to the end of the collection.
+     */
+    push(model: T | ModelAttributes, options?: Options): T;
+    /**
+     * Remove a model from the end of the collection.
+     */
+    pop(options?: Options): T | undefined;
+    /**
+     * Add a model to the beginning of the collection.
+     */
+    unshift(model: T | ModelAttributes, options?: Options): T;
+    /**
+     * Remove a model from the beginning of the collection.
+     */
+    shift(options?: Options): T | undefined;
+    /** Slice out a sub-array of models from the collection. */
+    slice(start?: number, end?: number): T[];
+    filter(callback: ((model: T) => boolean) | string | Partial<ModelAttributes>, thisArg?: any): T[];
+    every(pred: ((attrs: ModelAttributes) => boolean) | Options): boolean;
+    difference(values: T[]): T[];
+    max(): number;
+    min(): number;
+    drop(n?: number): T[];
+    some(pred: ((attrs: ModelAttributes) => boolean) | Options): boolean;
+    sortBy(iteratee: string | ((model: T) => any) | Partial<ModelAttributes>): T[];
+    isEmpty(): boolean;
+    keyBy(iteratee: string | ((model: T) => string)): Record<string, T>;
+    each(callback: (model: T, index: number, array: T[]) => void, thisArg?: any): void;
+    forEach(callback: (model: T, index: number, array: T[]) => void, thisArg?: any): void;
+    includes(item: T): boolean;
+    size(): number;
+    countBy(f: string | ((model: T) => string) | Partial<ModelAttributes>): Record<string, number>;
+    groupBy(pred: string | ((model: T) => string | number) | Partial<ModelAttributes>): Record<string, T[]>;
+    indexOf(model: T, fromIndex?: number): number;
+    findLastIndex(pred: ((model: T) => boolean) | string | Partial<ModelAttributes>, fromIndex?: number): number;
+    lastIndexOf(model: T, fromIndex?: number): number;
+    findIndex(pred: ((model: T) => boolean) | string | Partial<ModelAttributes>): number;
+    last(): T | undefined;
+    head(): T | undefined;
+    first(): T | undefined;
+    map<U>(cb: string | ((model: T) => U) | Partial<ModelAttributes>, thisArg?: any): U[];
+    reduce<U = T>(callback: (accumulator: U, model: T, index: number, array: T[]) => U, initialValue?: U): U | T;
+    reduceRight<U = T>(callback: (accumulator: U, model: T, index: number, array: T[]) => U, initialValue?: U): U | T;
+    toArray(): T[];
+    /**
+     * 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.
+     */
+    get(obj?: string | number | ModelAttributes | T | null): T | undefined;
+    /**
+     * Returns `true` if the model is in the collection.
+     */
+    has(obj: string | number | ModelAttributes | T | null): boolean;
+    /**
+     * Get the model at the given index.
+     */
+    at(index: number): T | undefined;
+    /**
+     * Return models with matching attributes. Useful for simple cases of
+     * `filter`.
+     */
+    where(attrs: ModelAttributes | Partial<ModelAttributes>, first?: boolean): T[] | T | undefined;
+    /**
+     * Return the first model with matching attributes. Useful for simple cases
+     * of `find`.
+     */
+    findWhere(attrs: ModelAttributes): T | undefined;
+    find(predicate: ((model: T) => boolean) | Partial<ModelAttributes> | string, fromIndex?: number): T | undefined;
+    /**
+     * 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.
+     */
+    sort(options?: Options): this;
+    /**
+     * Pluck an attribute from each model in the collection.
+     */
+    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`.
+     */
+    fetch(options?: Options): Promise<any> | 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.
+     */
+    create(model: T | ModelAttributes, options?: FetchOrCreateOptions): Promise<T> | T;
+    /**
+     * Subscribe to collection changes (add, remove, reset, sort, update).
+     * Returns an unsubscribe function.
+     *
+     * `collection.subscribe(callback)` — fires once per operation on add/remove/reset/sort (via `update`, `reset`, `sort` events).
+     * `collection.subscribe(event, callback)` — subscribe to a specific event (base EventEmitter form).
+     *
+     * Compatible with React's `useSyncExternalStore` and other store-style APIs.
+     */
+    subscribe(event: string, callback: EventCallback, context?: unknown): () => void;
+    subscribe(callback: (collection: this) => void): () => void;
+    /**
+     * **parse** converts a response into a list of models to be added to the
+     * collection. The default implementation is just to pass it through.
+     */
+    parse(resp: any, _options?: Options): any;
+    /**
+     * Define how to uniquely identify models in the collection.
+     */
+    modelId(attrs: ModelAttributes): string | number | undefined;
+    /** Get an iterator of all models in this collection. */
+    values(): CollectionIterator<T>;
+    /**
+     * @public
+     * Enable for...of iteration over the collection.
+     */
+    [Symbol.iterator]: () => CollectionIterator<T>;
+    /** Get an iterator of all model IDs in this collection. */
+    keys(): CollectionIterator<T>;
+    /** Get an iterator of all [ID, model] tuples in this collection. */
+    entries(): CollectionIterator<T>;
+    /**
+     * Private method to reset all internal state. Called when the collection
+     * is first initialized or reset.
+     */
+    _reset(): void;
+    createModel(attrs: ModelAttributes, options?: Options): T;
+    /**
+     * Prepare a hash of attributes (or other model) to be added to this
+     * collection.
+     */
+    _prepareModel(attrs: ModelAttributes | T, options?: Options): T | null;
+    /**
+     * Internal method called by both remove and set.
+     */
+    _removeModels(models: (T | ObjectWithId)[], options?: Options): T[];
+    /**
+     * Method for checking whether an object should be considered a model for
+     * the purposes of adding to the collection.
+     */
+    _isModel(model: any): model is T;
+    /**
+     * Internal method to create a model's ties to a collection.
+     */
+    _addReference(model: T, _options?: Options): void;
+    /**
+     * Internal method to sever a model's ties to a collection.
+     */
+    _removeReference(model: T, _options?: Options): void;
+    /**
+     * 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.
+     */
+    _onModelEvent(event: string, model: T, collection: Collection<T>, options?: Options): void;
+}
+/**
+ * @public
+ */
+declare class CollectionIterator<T extends Model> {
+    private _collection;
+    private _kind;
+    private _index;
+    /**
+     * 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.
+     */
+    constructor(collection: Collection<T>, kind: number);
+    next(): IteratorResult<any>;
+    [Symbol.iterator](): IterableIterator<any>;
+}
+
+/**
+ * @public
+ */
+type SyncOperation = 'create' | 'update' | 'patch' | 'delete' | 'read';
+/**
+ * @public
+ */
+type ObjectListenedTo = object & {
+    _listenId?: string;
+};
+/**
+ * @public
+ */
+interface SyncOptions {
+    url?: string;
+    data?: any;
+    attrs?: any;
+    success?: (data?: any, options?: SyncOptions) => void;
+    error?: (error: any) => void;
+    xhr?: any;
+    wait?: boolean;
+    collection?: Collection;
+}
+/**
+ * @public
+ */
+type ClassConstructor<T = any> = new (...args: any[]) => T;
+/**
+ * @public
+ */
+type EventContext = unknown;
+/**
+ * @public
+ */
+type EventCallback = (...args: any[]) => void;
+/**
+ * @public
+ */
+type EventCallbackMap = Record<string, EventCallback>;
+/**
+ * @public
+ */
+type EventListenerMap = Record<string, ListeningType>;
+/**
+ * @public
+ */
+interface EventHandlersMap {
+    all?: EventHandler[];
+    [name: string]: EventHandler[];
+}
+/**
+ * @public
+ */
+type ListeningMap = Record<string, ListeningType>;
+/**
+ * @public
+ */
+type ObjectWithId = Record<string, any> & {
+    id: string | number;
+};
+/**
+ * @public
+ */
+interface IEventEmitter {
+    _events?: Record<string, any>;
+    _listeners?: ListeningMap;
+    _listeningTo?: ListeningMap;
+    _listenId?: string;
+    on(name: string | EventCallbackMap, callback?: EventCallback | EventContext, context?: EventContext): this;
+    off(name?: string | EventCallbackMap | null, callback?: EventCallback | EventContext | null, context?: EventContext): this;
+    trigger(name: string, ...args: any[]): this;
+    stopListening(obj?: any, name?: string | EventCallbackMap, callback?: EventCallback): this;
+    once(name: string | EventCallbackMap, callback?: EventCallback | EventContext, context?: EventContext): this;
+    listenTo(obj: ObjectListenedTo, name: string | EventCallbackMap, callback?: EventCallback): this;
+    listenToOnce(obj: any, name: string | EventCallbackMap, callback?: EventCallback): this;
+}
+/**
+ * @public
+ */
+interface EventHandler {
+    callback: EventCallback;
+    context: any;
+    ctx: any;
+    listening?: ListeningType | null;
+}
+/**
+ * @public
+ */
+interface ListeningType {
+    _events?: EventCallbackMap;
+    cleanup(): void;
+    count: number;
+    id: string;
+    interop: boolean;
+    listener: IEventEmitter;
+    obj: any;
+    start(name: string | EventCallbackMap, callback: EventCallback, context: any, _listening: ListeningType): this;
+    stop(name: string | EventCallbackMap, callback: EventCallback): void;
+}
+/**
+ * @public
+ */
+type Comparator<T extends Model = Model> = string | boolean | ((a: T, b: T) => number) | ((a?: T) => string);
+/**
+ * @public
+ */
+type ComputedProperty<M> = {
+    deps: string[];
+    fn: (model: M) => any;
+};
+/**
+ * @public
+ */
+type ComputedProperties<M> = Record<string, ComputedProperty<M>>;
+/**
+ * @public
+ */
+type ModelAttributes = Record<string | number, any> & {
+    id?: string | number;
+};
+/**
+ * @public
+ */
+type Options = Record<string, any>;
+/**
+ * @public
+ */
+type FetchOrCreateOptions = Options & {
+    promise?: boolean;
+    success?: (m: Model, resp: any, callbackOpts: Options) => void;
+};
+/**
+ * @public
+ */
+type CollectionOptions<T extends Model = Model> = Options & {
+    model?: new (attributes?: Partial<ModelAttributes>, options?: ModelOptions) => T;
+    comparator?: Comparator<T>;
+    previousModels?: Model[];
+};
+/**
+ * @public
+ */
+type ModelOptions = Options & {
+    collection?: Collection;
+    parse?: boolean;
+    unset?: boolean;
+    silent?: boolean;
+    validate?: boolean;
+    /** Suppress the auto-save triggered by set() on autoSync models. */
+    noAutoSave?: boolean;
+    /** Mark a set() call as originating from a storage read; suppresses auto-save. */
+    fromStorage?: boolean;
+};
+
+/**
+ * @public
+ */
+declare function EventEmitter<T extends ClassConstructor>(Base: T): {
+    new (...args: any[]): {
+        [x: string]: any;
+        _events?: EventHandlersMap;
+        _listeners?: EventListenerMap;
+        _listeningTo?: EventListenerMap;
+        _listenId?: string;
+        /**
+         * Bind an event to a `callback` function. Passing `"all"` will bind
+         * the callback to all events fired.
+         */
+        on(name: string | EventCallbackMap, callback?: EventCallback | EventContext, context?: EventContext): /*elided*/ any;
+        /**
+         * 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.
+         */
+        listenTo(obj: ObjectListenedTo, name: string | EventCallbackMap, callback?: EventCallback): /*elided*/ 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.
+         */
+        off(name?: string | EventCallbackMap | null, callback?: EventCallback | EventContext | null, context?: EventContext): /*elided*/ any;
+        /**
+         * Tell this object to stop listening to either specific events ... or
+         * to every object it's currently listening to.
+         */
+        stopListening(obj?: any, name?: string | EventCallbackMap, callback?: EventCallback): /*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.
+         */
+        once(name: string | EventCallbackMap, callback?: EventCallback | EventContext, context?: EventContext): /*elided*/ any;
+        /**
+         * Inversion-of-control versions of `once`.
+         */
+        listenToOnce(obj: any, name: string | EventCallbackMap, callback?: EventCallback): /*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).
+         */
+        trigger(name: string, ...args: any[]): /*elided*/ any;
+        /**
+         * Subscribe to an event. Returns an unsubscribe function.
+         * Compatible with `useSyncExternalStore` and other store-style APIs.
+         */
+        subscribe(event: string, callback: EventCallback, context?: EventContext): () => void;
+    };
+} & T;
+/**
+ * @public
+ */
+declare const EventEmitterObject: {
+    new (...args: any[]): {
+        [x: string]: any;
+        _events?: EventHandlersMap;
+        _listeners?: EventListenerMap;
+        _listeningTo?: EventListenerMap;
+        _listenId?: string;
+        /**
+         * Bind an event to a `callback` function. Passing `"all"` will bind
+         * the callback to all events fired.
+         */
+        on(name: string | EventCallbackMap, callback?: EventCallback | EventContext, context?: EventContext): /*elided*/ any;
+        /**
+         * 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.
+         */
+        listenTo(obj: ObjectListenedTo, name: string | EventCallbackMap, callback?: EventCallback): /*elided*/ 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.
+         */
+        off(name?: string | EventCallbackMap | null, callback?: EventCallback | EventContext | null, context?: EventContext): /*elided*/ any;
+        /**
+         * Tell this object to stop listening to either specific events ... or
+         * to every object it's currently listening to.
+         */
+        stopListening(obj?: any, name?: string | EventCallbackMap, callback?: EventCallback): /*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.
+         */
+        once(name: string | EventCallbackMap, callback?: EventCallback | EventContext, context?: EventContext): /*elided*/ any;
+        /**
+         * Inversion-of-control versions of `once`.
+         */
+        listenToOnce(obj: any, name: string | EventCallbackMap, callback?: EventCallback): /*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).
+         */
+        trigger(name: string, ...args: any[]): /*elided*/ any;
+        /**
+         * Subscribe to an event. Returns an unsubscribe function.
+         * Compatible with `useSyncExternalStore` and other store-style APIs.
+         */
+        subscribe(event: string, callback: EventCallback, context?: EventContext): () => void;
+    };
+} & ObjectConstructor;
+
+/**
+ * Return the PersistentStorage instance configured on `obj`, checking both
+ * the canonical `storage` accessor and the deprecated `browserStorage` alias
+ * so that subclasses that still override `get browserStorage()` continue to work.
+ * @public
+ */
+declare function getStorage(obj: Model<any> | Collection<any> | null | undefined): PersistentStorage | undefined;
+/**
+ * The error the default `sync` hands to `options.error`, and rejects with, for
+ * a response outside the 2xx range.
+ * @public
+ */
+declare class HTTPError extends Error {
+    readonly status: number;
+    readonly response: Response;
+    constructor(response: Response, method: string, url: string);
+}
+/**
+ * The default `sync`: a JSON request over `fetch()` to the model's `url()`.
+ * Override it (or `Model.sync`/`Collection.sync`) to change how models are
+ * persisted, for instance to batch rapid-fire updates with `setTimeout`, to
+ * talk over WebSockets, or to write to browser storage.
+ *
+ * It honours both contracts a `sync` may use. On a 2xx response the JSON body
+ * (`null` when the body is empty) is passed to `options.success` and the
+ * returned promise resolves with it. On a non-2xx response, a network failure
+ * or an unparsable body, `options.error` receives the error (an `HTTPError`
+ * for the first) and the promise rejects with it.
+ *
+ * `options.data` is sent as query parameters on GET, which may not carry a
+ * body, and as a JSON body otherwise. For create, update and patch the body
+ * defaults to `options.attrs` or the model's `toJSON()`.
+ * @public
+ */
+declare function sync(method: SyncOperation, model: Model | Collection<any>, options?: SyncOptions): Promise<any>;
+
+/**
+ * @public
+ */
+interface SkeletorType {
+    Collection: typeof Collection;
+    EventEmitter: typeof EventEmitter;
+    Model: typeof Model;
+    sync: typeof sync;
+    HTTPError: typeof HTTPError;
+    VERSION?: string;
+    noConflict?: () => SkeletorType;
+}
+/**
+ * @public
+ */
+declare const skeletor: SkeletorType;
+/**
+ * @public
+ */
+declare function noConflict(): any;
+
+/**
+ * @deprecated Use `PersistentStorage` instead.
+ * @public
+ */
+declare const BrowserStorage: typeof PersistentStorage;
+
+export { BrowserStorage, Collection, CollectionIterator, EventEmitter, EventEmitterObject, HTTPError, Model, PersistentStorage, skeletor as default, getStorage, noConflict, sync };
+export type { ClassConstructor, CollectionOptions, Comparator, ComputedProperties, ComputedProperty, EventCallback, EventCallbackMap, EventContext, EventHandler, EventHandlersMap, EventListenerMap, FetchOrCreateOptions, IEventEmitter, ListeningMap, ListeningType, ModelAttributes, ModelOptions, NodeStorageConstructor, ObjectListenedTo, ObjectWithId, Options, SkeletorType, StorageDriver, StoreType, SyncOperation, SyncOptions };