@soundworks/core 4.0.0-alpha.28 → 4.0.0-alpha.29

package/types/client/Context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Context.d.ts","sourceRoot":"","sources":["../../src/client/Context.js"],"names":[],"mappings":";AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH;IACE;;;OAGG;IACH,mCAoDC;IA/CC;;;;OAIG;IACH,+BAAoB;IAEpB;;;;OAIG;IACH,iBAHU,MAAM,CAGI;IAqCtB;;;;;;;;;;;;;;;;OAgBG;IACH,4BAEC;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,uBAAgB;IAEhB;;;;;;OAMG;IACH,sBAAe;IAEf;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,sBAeC;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,qBAUC;CACF"}

package/types/client/ContextManager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ContextManager.d.ts","sourceRoot":"","sources":["../../src/client/ContextManager.js"],"names":[],"mappings":";AAuBA;;;;;;;;;GASG;AACH;IAEI,eAAe;IACf,kBAAwC;IACxC,eAAe;IACf,8BAAsC;IAGxC;;;;;OAKG;IACH,iBAMC;IAED;;;;;;OAMG;IACH,oCAyBC;IAED;;;;OAIG;IACH,cAGC;IAED;;;;OAIG;IACH,aAGC;CACF"}

package/types/client/Plugin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Plugin.d.ts","sourceRoot":"","sources":["../../src/client/Plugin.js"],"names":[],"mappings":";;;;;2BAMW,aAAa;;AAJxB;;;;;GAKG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACH;IACE;;;;OAIG;IACH,uCAHW,MAAM,EAahB;IAPC;;;;;OAKG;IACH,sBAAoB;CAevB;uBAhEsB,yBAAyB"}

package/types/client/PluginManager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PluginManager.d.ts","sourceRoot":"","sources":["../../src/client/PluginManager.js"],"names":[],"mappings":";;;;;4BAQW,MAAM,aACN,gBAAc,IAAI;;AAL7B;;;;;;;;GAQG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH;IACE;;OAEG;IACH,mCAMC;IAED,kEAQC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,YAMC;CACF;8BAjI6B,gCAAgC"}

package/types/client/SharedState.d.ts

@@ -1,85 +0,0 @@
-export default SharedState;
-export namespace client {
-    /**
-     * ~onUpdateCallback
-     */
-    type SharedState = (newValues: any, oldValues: any, context?: Mixed) => any;
-}
-/**
- * @callback client.SharedState~onUpdateCallback
- * @param {Object} newValues - Key / value pairs of the updates that have been
- *  applied to the state.
- * @param {Object} oldValues - Key / value pairs of the updated params before
- *  the updates has been applied to the state.
- * @param {Mixed} [context=null] - Optionnal context object that has been passed
- *  with the values updates in the `set` call.
- */
-/**
- * Delete the registered {@link client.SharedState~onUpdateCallback}.
- *
- * @callback client.SharedState~deleteOnUpdateCallback
- */
-/**
- * The `SharedState` is one of the most important and versatile abstraction provided
- * by `soundworks`. It represents a set of parameters that are synchronized accross
- * every nodes of the application (clients and server) that declared some interest
- * to the shared state.
- *
- * A `SharedState` is created according to a "schema" (in the sense of a database
- * schema) that must be declared and registered server-side. Any number of `SharedState`s
- * can be created from a single schema.
- *
- * A shared state can be created both by the clients or by the server (in which case
- * it is generally considered as a global state of the application). Similarly any
- * node of the application (clients or server) can declare interest and "attach" to
- * a state created by another node. All node attached to a state can modify its values
- * and/or react to the modifications applied by other nodes.
- *
- * Tutorial: {@link https://soundworks.dev/guide/state-manager.html}
- *
- * ```
- * // server-side
- * import { Server } from '@soundworks/server/index.js';
- *
- * const server = new Server(config);
- * // declare and register the schema of a shared state.
- * server.stateManager.registerSchema('some-global-state', {
- *   myRandom: {
- *     type: 'float',
- *     default: 0,
- *   }
- * });
- *
- * await server.start();
- *
- * // create a global state server-side
- * const globalState = await server.stateManager.create('some-global-state');
- * // listen and react to the changes made by the clients
- * globalState.onUpdate(updates => console.log(updates));
- * ```
- *
- * ```
- * // client-side
- * import { Client } from '@soundworks/client.index.js';
- *
- * const client = new Client(config);
- * await client.start();
- *
- * // attach to the global state created by the server
- * const globalState = await client.stateManager.attach('some-global-state');
- *
- * // update the value of a `myRandom` parameter every seconds
- * setInterval(() => {
- *   globalState.set({ myRandom: Math.random() });
- * }, 1000);
- * ```
- *
- * @memberof client
- * @extends BaseSharedState
- * @inheritdoc
- * @hideconstructor
- */
-declare class SharedState extends BaseSharedState {
-}
-import BaseSharedState from '../common/BaseSharedState.js';
-//# sourceMappingURL=SharedState.d.ts.map

package/types/client/SharedState.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SharedState.d.ts","sourceRoot":"","sources":["../../src/client/SharedState.js"],"names":[],"mappings":";;;;;;;AAIA;;;;;;;;GAQG;AAEH;;;;GAIG;AAGH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH;CAA4C;4BAjFhB,8BAA8B"}

package/types/client/SharedStateCollection.d.ts

@@ -1,41 +0,0 @@
-export default SharedStateCollection;
-export namespace client {
-    /**
-     * ~onUpdateCallback
-     */
-    type SharedStateCollection = (state: client.SharedState, newValues: any, oldValues: any, context?: Mixed) => any;
-}
-/**
- * @callback client.SharedStateCollection~onUpdateCallback
- * @param {client.SharedState} state - State that triggered the update.
- * @param {Object} newValues - Key / value pairs of the updates that have been
- *  applied to the state.
- * @param {Object} oldValues - Key / value pairs of the updated params before
- *  the updates has been applied to the state.
- * @param {Mixed} [context=null] - Optionnal context object that has been passed
- *  with the values updates in the `set` call.
- */
-/**
- * The `SharedStateCollection` interface represent a collection of all states
- * created from a given schema name on the network.
- *
- * It can optionnaly exclude the states created by the current node.
- *
- * See {@link client.StateManager#getCollection} for factory method API
- *
- * ```
- * const collection = await client.stateManager.getCollection('my-schema');
- * const allValues = collection.getValues();
- * collection.onUpdate((state, newValues, oldValues, context) => {
- *   // do something
- * });
- * ```
- * @memberof client
- * @extends BaseSharedStateCollection
- * @inheritdoc
- * @hideconstructor
- */
-declare class SharedStateCollection extends BaseSharedStateCollection {
-}
-import BaseSharedStateCollection from '../common/BaseSharedStateCollection.js';
-//# sourceMappingURL=SharedStateCollection.d.ts.map

package/types/client/SharedStateCollection.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SharedStateCollection.d.ts","sourceRoot":"","sources":["../../src/client/SharedStateCollection.js"],"names":[],"mappings":";;;;;;;AAIA;;;;;;;;;GASG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH;CAAgE;sCAnC1B,wCAAwC"}

package/types/client/Socket.d.ts

@@ -1,149 +0,0 @@
-export default Socket;
-/**
- * The Socket class is a simple publish / subscribe wrapper built on top of the
- * [isomorphic-ws](https://github.com/heineiuo/isomorphic-ws) library.
- * An instance of `Socket` is automatically created by the `soundworks.Client`
- * (see {@link client.Client#socket}).
- *
- * _Important: In most cases, you should consider using a {@link client.SharedState}
- * rather than directly using the sockets._
- *
- * The Socket class concurrently opens two different WebSockets:
- * - a socket configured with `binaryType = 'blob'` for JSON compatible data
- *  types (i.e. string, number, boolean, object, array and null).
- * - a socket configured with `binaryType= 'arraybuffer'` for efficient streaming
- *  of binary data.
- *
- * Both sockets re-emits all "native" ws events ('open', 'upgrade', 'close', 'error'
- *  and 'message'.
- *
- * @memberof client
- * @hideconstructor
- */
-declare class Socket {
-    /**
-     * WebSocket instance configured with `binaryType = 'blob'`.
-     *
-     * @private
-     */
-    private ws;
-    /**
-     * WebSocket instance configured with `binaryType = 'arraybuffer'`.
-     *
-     * @private
-     */
-    private binaryWs;
-    /** @private */
-    private _stringListeners;
-    /** @private */
-    private _binaryListeners;
-    /** @private */
-    private _heartbeatId;
-    /**
-     * Initialize a websocket connection with the server. Automatically called
-     * during `client.init()`
-     *
-     * @param {string} role - Role of the client (see {@link client.Client#role})
-     * @param {object} config - Configuration of the sockets
-     * @protected
-     * @ignore
-     */
-    protected init(role: string, config: object): Promise<void>;
-    /**
-     * Removes all listeners and immediately close the two sockets. Is automatically
-     * called on `client.stop()`
-     *
-     * Is also called when a disconnection is detected by the heartbeat (note that
-     * in this case, the launcher will call `client.stop()` but the listeners are
-     * already cleared so the event will be trigerred only once)
-     *
-     * @private
-     */
-    private terminate;
-    /**
-     * @param {boolean} binary - Emit to either the string or binary socket.
-     * @param {string} channel - Channel name.
-     * @param {...*} args - Content of the message.
-     * @private
-     */
-    private _emit;
-    /**
-     * @param {Function[]} listeners - List of listeners, either for the string or binary socket.
-     * @param {string} channel - Channel name.
-     * @param {Function} callback - The function to be added to the listeners.
-     * @private
-     */
-    private _addListener;
-    /**
-     * @param {Function[]} listeners - List of listeners, either for the string or binary socket.
-     * @param {string} channel - Channel name.
-     * @param {Function} callback - The function to be removed from the listeners.
-     * @private
-     */
-    private _removeListener;
-    /**
-     * @param {Function[]} listeners - List of listeners, either for the string or binary socket.
-     * @param {string} [channel=null] - Channel name of the listeners to remove. If null
-     *  all the listeners are cleared.
-     * @private
-     */
-    private _removeAllListeners;
-    /**
-     * Send messages with JSON compatible data types on a given channel.
-     *
-     * @param {string} channel - Channel name.
-     * @param {...*} args - Payload of the message. As many arguments as needed, of
-     *  JSON compatible data types (i.e. string, number, boolean, object, array and null).
-     */
-    send(channel: string, ...args: any[]): void;
-    /**
-     * Listen messages with JSON compatible data types on a given channel.
-     *
-     * @param {string} channel - Channel name.
-     * @param {Function} callback - Callback to execute when a message is received,
-     *  arguments of the callback function will match the arguments sent using the
-     *  {@link server.Socket#send} method.
-     */
-    addListener(channel: string, callback: Function): void;
-    /**
-     * Remove a listener from JSON compatible messages on a given channel.
-     *
-     * @param {string} channel - Channel name.
-     * @param {Function} callback - Callback to remove.
-     */
-    removeListener(channel: string, callback: Function): void;
-    /**
-     * Remove all listeners of messages with JSON compatible data types.
-     *
-     * @param {string} channel - Channel name.
-     */
-    removeAllListeners(channel?: string): void;
-    /**
-     * Send binary messages on a given channel.
-     *
-     * @param {string} channel - Channel name.
-     * @param {TypedArray} typedArray - Binary data to be sent.
-     */
-    sendBinary(channel: string, typedArray: TypedArray): void;
-    /**
-     * Listen binary messages on a given channel
-     *
-     * @param {string} channel - Channel name.
-     * @param {Function} callback - Callback to execute when a message is received.
-     */
-    addBinaryListener(channel: string, callback: Function): void;
-    /**
-     * Remove a listener of binary compatible messages from a given channel
-     *
-     * @param {string} channel - Channel name.
-     * @param {Function} callback - Callback to remove.
-     */
-    removeBinaryListener(channel: string, callback: Function): void;
-    /**
-     * Remove all listeners of binary compatible messages on a given channel
-     *
-     * @param {string} channel - Channel of the message.
-     */
-    removeAllBinaryListeners(channel?: string): void;
-}
-//# sourceMappingURL=Socket.d.ts.map

package/types/client/Socket.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Socket.d.ts","sourceRoot":"","sources":["../../src/client/Socket.js"],"names":[],"mappings":";AAiCA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAEI;;;;OAIG;IACH,WAAc;IACd;;;;OAIG;IACH,iBAAoB;IACpB,eAAe;IACf,yBAAiC;IACjC,eAAe;IACf,yBAAiC;IACjC,eAAe;IACf,qBAAwB;IAG1B;;;;;;;;OAQG;IACH,qBALW,MAAM,UACN,MAAM,iBA+KhB;IAED;;;;;;;;;OASG;IACH,kBAmBC;IAED;;;;;OAKG;IACH,cAOC;IAED;;;;;OAKG;IACH,qBAOC;IAED;;;;;OAKG;IACH,wBASC;IAED;;;;;OAKG;IACH,4BAMC;IAED;;;;;;OAMG;IACH,cAJW,MAAM,wBAOhB;IAED;;;;;;;OAOG;IACH,qBALW,MAAM,4BAOhB;IAED;;;;;OAKG;IACH,wBAHW,MAAM,4BAKhB;IAED;;;;OAIG;IACH,6BAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,oBAHW,MAAM,gCAMhB;IAED;;;;;OAKG;IACH,2BAHW,MAAM,4BAKhB;IAED;;;;;OAKG;IACH,8BAHW,MAAM,4BAKhB;IAED;;;;OAIG;IACH,mCAFW,MAAM,QAIhB;CACF"}

package/types/client/StateManager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"StateManager.d.ts","sourceRoot":"","sources":["../../src/client/StateManager.js"],"names":[],"mappings":";;;;;;;AAEA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH;CAA8C;6BAhEjB,+BAA+B"}

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

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

package/types/common/BasePlugin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BasePlugin.d.ts","sourceRoot":"","sources":["../../src/common/BasePlugin.js"],"names":[],"mappings":";AAEA;;GAEG;AACH;IACE,qBAoCC;IAnCC,eAAe;IACf,YAAa;IACb,eAAe;IACf,cAAkC;IAElC;;;;OAIG;IACH,SAFU,MAAM,CAEC;IAEjB;;;;;;;;;;;OAWG;IACH,iBAPU,MAAM,CAOD;IAEf;;;;OAIG;IACH,QAFU,MAAM,CAEI;IAEpB,eAAe;IACf,gCAAwC;IAG1C;;;;;;;OAOG;IACH,0BAEC;IAED;;;;;;;;;OASG;IACH,4BAEC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,uBAAgB;IAEhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,sBAAe;IAEf;;;;;;;;;;;;;OAaG;IACH,4CAGC;IAED;;;;;;;;;;OAUG;IACH,8BANW,MAAM,QAShB;CACF"}

package/types/common/BasePluginManager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BasePluginManager.d.ts","sourceRoot":"","sources":["../../src/common/BasePluginManager.js"],"names":[],"mappings":";AAIA;;;;GAIG;AACH;IACE,uBAcC;IAZC,eAAe;IACf,cAAiB;IACjB,eAAe;IACf,sBAA8B;IAC9B,eAAe;IACf,mBAA2B;IAC3B,eAAe;IACf,+BAAuC;IACvC,eAAe;IACf,gCAAwC;IAExC,eAAoB;IAGtB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,aAfW,MAAM,uBAGN,MAAM,sBA6ChB;IAED;;;;OAIG;IACH,sDAGC;IAED;;;OAGG;IACH,wBAFa,MAAM,EAAE,CAIpB;IAED;;;;OAIG;IACH,cAyBC;IAED,eAAe;IACf,aAIC;IAED;;;;;;OAMG;IACH,kBAqDC;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,4CAGC;IAED,eAAe;IACf,8BAaC;CACF"}

package/types/common/BaseSharedState.d.ts

@@ -1,244 +0,0 @@
-export default BaseSharedState;
-declare class BaseSharedState {
-    constructor(id: any, remoteId: any, schemaName: any, schema: any, client: any, isOwner: any, manager: any, initValues: any, filter: any);
-    /** @private */
-    private _id;
-    /** @private */
-    private _remoteId;
-    /** @private */
-    private _schemaName;
-    /** @private */
-    private _isOwner;
-    /** @private */
-    private _client;
-    /** @private */
-    private _manager;
-    /** @private */
-    private _filter;
-    /**
-     * true is the state has been detached or deleted
-     * @private
-     */
-    private _detached;
-    _promiseStore: PromiseStore;
-    /** @private */
-    private _parameters;
-    /** @private */
-    private _onUpdateCallbacks;
-    /** @private */
-    private _onDetachCallbacks;
-    /** @private */
-    private _onDeleteCallbacks;
-    /**
-     * Id of the state
-     * @type {Number}
-     * @readonly
-     */
-    readonly get id(): number;
-    /**
-     * Unique id of the state for the current node
-     * @readonly
-     * @type {Number}
-     * @private
-     */
-    private readonly get remoteId();
-    /**
-     * Name of the schema
-     * @type {String}
-     * @readonly
-     */
-    readonly get schemaName(): string;
-    /**
-     * Indicates if the node is the owner of the state
-     * @type {Boolean}
-     * @readonly
-     */
-    readonly get isOwner(): boolean;
-    /** @private */
-    private _clearTransport;
-    /** @private */
-    private _commit;
-    /**
-     * Update values of the state.
-     *
-     * The returned `Promise` resolves on the applied updates, when all the `onUpdate`
-     * callbacks have resolved themselves, i.e.:
-     *
-     * ```js
-     * server.stateManager.registerSchema('test', {
-     *   myBool: { type: 'boolean', default: false },
-     * });
-     * const a = await server.stateManager.create('a');
-     * let asyncCallbackCalled = false;
-     *
-     * a.onUpdate(updates => {
-     *   return new Promise(resolve => {
-     *     setTimeout(() => {
-     *       asyncCallbackCalled = true;
-     *       resolve();
-     *     }, 100);
-     *   });
-     * });
-     *
-     * const updates = await a.set({ myBool: true });
-     * assert.equal(asyncCallbackCalled, true);
-     * assert.deepEqual(updates, { myBool: true });
-     * ```
-     *
-     * @param {object} updates - key / value pairs of updates to apply to the state.
-     * @param {mixed} [context=null] - optionnal contextual object that will be propagated
-     *   alongside the updates of the state. The context is valid only for the
-     *   current call and will be passed as third argument to all update listeners.
-     * @returns {Promise<Object>} A promise to the (coerced) updates.
-     * @example
-     * const state = await client.state.attach('globals');
-     * const updates = await state.set({ myParam: Math.random() });
-     */
-    set(updates: object, context?: mixed): Promise<any>;
-    /**
-     * Get the value of a parameter of the state. If the parameter is of `any` type,
-     * a deep copy is returned.
-     *
-     * @param {string} name - Name of the param.
-     * @throws Throws if `name` does not correspond to an existing field
-     *  of the state.
-     * @return {mixed}
-     * @example
-     * const value = state.get('paramName');
-     */
-    get(name: string): mixed;
-    /**
-     * Similar to `get` but returns a reference to the underlying value in case of
-     * `any` type. May be usefull if the underlying value is big (e.g. sensors
-     * recordings, etc.) and deep cloning expensive. Be aware that if changes are
-     * made on the returned object, the state of your application will become
-     * inconsistent.
-     *
-     * @param {string} name - Name of the param.
-     * @throws Throws if `name` does not correspond to an existing field
-     *  of the state.
-     * @return {mixed}
-     * @example
-     * const value = state.getUnsafe('paramName');
-     */
-    getUnsafe(name: string): mixed;
-    /**
-     * Get all the key / value pairs of the state.
-     *
-     * If a parameter is of `any` type, a deep copy is made.
-     *
-     * @return {object}
-     * @example
-     * const values = state.getValues();
-     */
-    getValues(): object;
-    /**
-     * Get all the key / value pairs of the state.
-     *
-     * Similar to `getValues` but returns a reference to the underlying value in
-     * case of `any` type. May be usefull if the underlying value is big (e.g.
-     * sensors recordings, etc.) and deep cloning expensive. Be aware that if
-     * changes are made on the returned object, the state of your application will
-     * become inconsistent.
-     *
-     * @return {object}
-     * @example
-     * const values = state.getValues();
-     */
-    getValuesUnsafe(): object;
-    /**
-     * Definition of schema from which the state has been created.
-     *
-     * @param {string} [name=null] - If given, returns only the definition
-     *  corresponding to the given param name.
-     * @throws Throws if `name` does not correspond to an existing field
-     *  of the schema.
-     * @return {object}
-     * @example
-     * const schema = state.getSchema();
-     */
-    getSchema(name?: string): object;
-    /**
-     * Get the values with which the state has been created. May defer from the
-     * default values declared in the schema.
-     *
-     * @return {object}
-     * @example
-     * const initValues = state.getInitValues();
-     */
-    getInitValues(): object;
-    /**
-     * Get the default values as declared in the schema.
-     *
-     * @return {object}
-     * @example
-     * const defaults = state.getDefaults();
-     */
-    getDefaults(): object;
-    /**
-     * Detach from the state. If the client is the creator of the state, the state
-     * is deleted and all attached nodes get notified.
-     *
-     * @example
-     * const state = await client.state.attach('globals');
-     * // later
-     * await state.detach();
-     */
-    detach(): Promise<any>;
-    /**
-     * Delete the state. Only the creator/owner of the state can use this method.
-     *
-     * All nodes attached to the state will be detached, triggering any registered
-     * `onDetach` callbacks. The creator of the state will also have its own `onDelete`
-     * callback triggered. The local `onDeatch` and `onDelete` callbacks will be
-     * executed *before* the returned Promise resolves
-     *
-     * @throws Throws if the method is called by a node which is not the owner of
-     * the state.
-     * @example
-     * const state = await client.state.create('my-schema-name');
-     * // later
-     * await state.delete();
-     */
-    delete(): Promise<any>;
-    /**
-     * Subscribe to state updates.
-     *
-     * @param {client.SharedState~onUpdateCallback|server.SharedState~onUpdateCallback} callback
-     *  Callback to execute when an update is applied on the state.
-     * @param {Boolean} [executeListener=false] - Execute the callback immediately
-     *  with current state values. (`oldValues` will be set to `{}`, and `context` to `null`)
-     * @returns {client.SharedState~deleteOnUpdateCallback|server.SharedState~deleteOnUpdateCallback}
-     * @example
-     * const unsubscribe = state.onUpdate(async (newValues, oldValues, context) =>  {
-     *   for (let [key, value] of Object.entries(newValues)) {
-     *      switch (key) {
-     *        // do something
-     *      }
-     *   }
-     * });
-     *
-     * // later
-     * unsubscribe();
-     */
-    onUpdate(listener: any, executeListener?: boolean): client.SharedState;
-    /**
-     * Register a function to execute when detaching from the state. The function
-     * will be executed before the `detach` promise resolves.
-     *
-     * @param {Function} callback - Callback to execute when detaching from the state.
-     *   Whether the client as called `detach`, or the state has been deleted by its
-     *   creator.
-     */
-    onDetach(callback: Function): () => boolean;
-    /**
-     * Register a function to execute when the state is deleted. Only called if the
-     * node was the creator of the state. Is called after `onDetach` and executed
-     * before the `delete` Promise resolves.
-     *
-     * @param {Function} callback - Callback to execute when the state is deleted.
-     */
-    onDelete(callback: Function): () => boolean;
-}
-import PromiseStore from './PromiseStore.js';
-//# sourceMappingURL=BaseSharedState.d.ts.map

package/types/common/BaseSharedState.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BaseSharedState.d.ts","sourceRoot":"","sources":["../../src/common/BaseSharedState.js"],"names":[],"mappings":";AAyBA;IACE,yIA8JC;IA7JC,eAAe;IACf,YAAa;IACb,eAAe;IACf,kBAAyB;IACzB,eAAe;IACf,oBAA6B;IAC7B,eAAe;IACf,iBAAuB;IACvB,eAAe;IACf,gBAAqB;IACrB,eAAe;IACf,iBAAuB;IACvB,eAAe;IACf,gBAAqB;IAErB;;;OAGG;IACH,kBAAsB;IAEtB,4BAA4D;IAG1D,eAAe;IACf,oBAAuD;IAQzD,eAAe;IACf,2BAAmC;IACnC,eAAe;IACf,2BAAmC;IACnC,eAAe;IACf,2BAAmC;IAyHrC;;;;OAIG;IACH,0BAEC;IAED;;;;;OAKG;IACH,gCAEC;IAED;;;;OAIG;IACH,kCAEC;IAED;;;;OAIG;IACH,gCAEC;IAED,eAAe;IACf,wBAcC;IAED,eAAe;IACf,gBAoDC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,aATW,MAAM,oBAIJ,YAAe,CA8G3B;IAED;;;;;;;;;;OAUG;IACH,UAPW,MAAM,SAmBhB;IAED;;;;;;;;;;;;;OAaG;IACH,gBAPW,MAAM,SAmBhB;IAED;;;;;;;;OAQG;IACH,aAJY,MAAM,CAgBjB;IAED;;;;;;;;;;;;OAYG;IACH,mBAJY,MAAM,CAgBjB;IAED;;;;;;;;;;OAUG;IACH,iBARW,MAAM,GAIL,MAAM,CAMjB;IAED;;;;;;;OAOG;IACH,iBAJY,MAAM,CAMjB;IAED;;;;;;OAMG;IACH,eAJY,MAAM,CAMjB;IAED;;;;;;;;OAQG;IACH,uBAmBC;IAED;;;;;;;;;;;;;;OAcG;IACH,uBAUC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,uEAaC;IAED;;;;;;;OAOG;IACH,4CAGC;IAED;;;;;;OAMG;IACH,4CAGC;CACF;yBArrBwB,mBAAmB"}

package/types/common/BaseSharedStateCollection.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BaseSharedStateCollection.d.ts","sourceRoot":"","sources":["../../src/common/BaseSharedStateCollection.js"],"names":[],"mappings":";AAAA,eAAe;AACf;IACE,4EAaC;IAZC,mBAAiC;IACjC,iBAA6B;IAC7B,aAAqB;IACrB;;MAA+D;IAE/D,aAAmB;IACnB,eAAiB;IAEjB,6BAAmC;IACnC,6BAAmC;IACnC,6BAAmC;IACnC,gBAAsB;IAGxB,eAAe;IACf,cAiCC;IAED;;;;OAIG;IACH,8BAEC;IAED;;;;OAIG;IACH,4BAEC;IAED;;;;OAIG;IACH,kCAEC;IAED;;;;;;;;;;OAUG;IACH,iBARW,MAAM,GAIL,MAAM,CAUjB;IAED;;;;;;OAMG;IACH,eAJY,MAAM,CAUjB;IAED;;;OAGG;IACH,aAFY,KAAQ,CAInB;IAED;;;;;;;;;;OAUG;IACH,mBAFY,KAAQ,CAInB;IAED;;;;;OAKG;IACH,mBAFY,GAAG,EAAE,CAMhB;IAED;;;;;;;;;OASG;IACH,yBAFY,GAAG,EAAE,CAMhB;IAED;;;;;;OAMG;IACH,aALW,MAAM,mCAUhB;IAED;;;;;;;;;OASG;IACH,6DAcC;IAED;;;;;;;;OAQG;IACH,mEAQC;IAED;;;;;;OAMG;IACH,uCAIC;IAED;;;OAGG;IACH,wBAQC;IAED;;;;;OAKG;IACH,8BAEC;IAED;;;;;;OAMG;IACH,2BAEC;IAED;;;;;;;OAOG;IACH,8BAEC;IAED;;;;OAIG;IACH,2BAEC;IAED;;;;;;;OAOG;IACH,0BAEC;IAED;;OAEG;IACH;;;;;MAYC;CACF"}

package/types/common/BaseStateManager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BaseStateManager.d.ts","sourceRoot":"","sources":["../../src/common/BaseStateManager.js"],"names":[],"mappings":";AAwBA,eAAe;AACf;IAEI,2BAA4B;IAC5B,8BAA+B;IAE/B,4BAAkC;IAClC,wCAAyC;IAEzC,4BAAuC;IAGzC;;;;;OAKG;IACH,eAAe;IACf,aAgIC;IA9HC;;;MAAiD;IAgInD,eAAe;IACf,uBAYC;IAED;;;;;;;OAOG;IACH,4CAYC;IAED;;;;;;;;;;;OAWG;IACH,8CANa,uCAAqC,CAYjD;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,2DATW,QAAM,IAAI,mBAER,uCAAqC,CA8CjD;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;IAIH,yBAfa,iBAAiB,CAsH7B;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,0BAXW,MAAM;QAIY,YAAY,GAA9B,OAAO;wBAEL,2DAAyD,CA2CrE;CACF;yBA/ewB,mBAAmB;6BAFf,uBAAuB"}

package/types/common/BatchedTransport.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BatchedTransport.d.ts","sourceRoot":"","sources":["../../src/common/BatchedTransport.js"],"names":[],"mappings":";AAIA;;;;;;;GAOG;AACH;IACE,4BAkBC;IAjBC,gBAA2B;IAC3B,0BAA2B;IAC3B,cAAgB;IAChB,kBAAqB;IAgBvB,+CAOC;IAED,kDAWC;IAED,kDAKC;IAED,wCAOC;CACF"}

package/types/common/ParameterBag.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ParameterBag.d.ts","sourceRoot":"","sources":["../../src/common/ParameterBag.js"],"names":[],"mappings":";;;;;;;;;;;QAiBoB,kEAMf;;;;;;;QAOe,0EAMf;;;;;;;;QAUe,8CAgBf;QACe,0EAMf;;;;;;;;QAUe,gDAgBf;;QACe,0EAMf;;;;;;;;QAOe,uEAOf;;;;;;;;;QAOe,uEAGf;;;;;AAKL;;;GAGG;AACH;IACE,yCAsBC;IAED,0CAqEC;IA7DC;;;;;;;;OAQG;IACH,gBAAiB;IAEjB;;;;;;;;OAQG;IACH,gBAAiB;IA2CnB;;;;;OAKG;IACH,UAHW,MAAM,WAKhB;IAED;;;;;OAKG;IACH,aAFY,MAAM,CAUjB;IAED;;;;;;;;OAQG;IACH,mBAFY,MAAM,CAUjB;IAED;;;;;;OAMG;IACH,UAHW,MAAM,SAehB;IAED;;;;;;;;;OASG;IACH,gBAHW,MAAM,SAShB;IAED;;;;;;OAMG;IACH,+CAiBC;IAED;;;;;;;;OAQG;IACH,UAJW,MAAM,uBAsBhB;IAED;;;;;;OAMG;IAWH;;;;OAIG;IACH,uBAFY,MAAM,CAYjB;IAGD,oBAQC;IAGD,kBAQC;CACF"}

package/types/common/PromiseStore.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PromiseStore.d.ts","sourceRoot":"","sources":["../../src/common/PromiseStore.js"],"names":[],"mappings":"AAEA;IACE,uBAIC;IAHC,UAAgB;IAChB,qBAAsB;IACtB,uBAAsC;IAGxC,iEAKC;IAED,qCAcC;IAED,mCASC;IAGD,cAOC;CACF"}

package/types/common/SharedStatePrivate.d.ts

@@ -1,21 +0,0 @@
-export default SharedStatePrivate;
-/**
- * The "real" state, this instance is kept private by the server.StateManager.
- * It can only be accessed through a SharedState proxy.
- *
- * @private
- */
-declare class SharedStatePrivate {
-    constructor(id: any, schemaName: any, schema: any, manager: any, initValues?: {});
-    id: any;
-    schemaName: any;
-    _manager: any;
-    _parameters: ParameterBag;
-    _attachedClients: Map<any, any>;
-    _creatorRemoteId: any;
-    _creatorId: any;
-    _attachClient(remoteId: any, client: any, isOwner: any, filter: any): void;
-    _detachClient(remoteId: any, client: any): void;
-}
-import ParameterBag from '../common/ParameterBag.js';
-//# sourceMappingURL=SharedStatePrivate.d.ts.map

package/types/common/SharedStatePrivate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SharedStatePrivate.d.ts","sourceRoot":"","sources":["../../src/common/SharedStatePrivate.js"],"names":[],"mappings":";AAgCA;;;;;GAKG;AACH;IACE,kFAUC;IATC,QAAY;IACZ,gBAA4B;IAE5B,cAAuB;IACvB,0BAAuD;IACvD,gCAAiC;IAEjC,sBAA4B;IAC5B,gBAAsB;IAGxB,2EAwKC;IAED,gDAMC;CACF;yBApOwB,2BAA2B"}

package/types/common/constants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/common/constants.js"],"names":[],"mappings":"AACA,2BAA4B;AAE5B,mCAAuC;AACvC,0CAA2C;AAC3C,oCAAqC;AACrC,oCAAqC;AAGrC,8CAA+C;AAG/C,uCAAwC;AACxC,wCAAyC;AACzC,qCAAsC;AAEtC,wCAAyC;AACzC,yCAA0C;AAC1C,sCAAuC;AACvC,6CAA8C;AAE9C,uCAAwC;AACxC,wCAAyC;AACzC,qCAAsC;AAEtC,wCAAyC;AACzC,yCAA0C;AAC1C,sCAAuC;AAEvC,wCAAyC;AACzC,yCAA0C;AAC1C,sCAAuC;AACvC,6CAA8C;AAE9C,gDAAiD;AAEjD,uCAAwC;AACxC,wCAAyC;AACzC,oCAAqC;AACrC,4CAA6C;AAE7C,oCAAqC;AAErC,2CAA4C;AAC5C,4CAA6C;AAC7C,yCAA0C;AAG1C,+CAAgD;AAChD,gDAAiD;AACjD,6CAA8C;AAE9C,8CAA+C;AAC/C,+CAAgD;AAChD,4CAA6C;AAG7C,kDAAmD;AACnD,mDAAoD;AACpD,gDAAiD;AAGjD,2CAA4C;AAC5C,sCAAiD"}

package/types/common/logger.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/common/logger.js"],"names":[],"mappings":";;;IASE,uCAEC;IAED,+BAOC;IAED,gEAgEC;IAED,0DAMC;IAED,sCAMC;IAED,wCAMC;IAED,sCAMC;IAED,wCAMC;IAED,6BAMC;IAED,8BAMC;IAED,+BAMC"}

package/types/common/sockets-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sockets-utils.d.ts","sourceRoot":"","sources":["../../src/common/sockets-utils.js"],"names":[],"mappings":"AAqBA,eAAe;AACf,4EAqBC;AAED,eAAe;AACf,wDAeC;AAED,eAAe;AACf,wEAEC;AAED,eAAe;AACf,oDAEC"}

package/types/common/version.d.ts.map

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