@soundworks/core 4.0.0-alpha.7 → 5.0.0

package/types/common/SharedState.d.ts

@@ -0,0 +1,291 @@
+export const kSharedStatePromiseStore: unique symbol;
+export default SharedState;
+/**
+ * Callback executed when updates are applied on a {@link SharedState}.
+ */
+export type sharedStateOnUpdateCallback = (newValues: any, oldValues: any) => any;
+/**
+ * Delete the registered {@link sharedStateOnUpdateCallback}.
+ */
+export type sharedStateDeleteOnUpdateCallback = () => any;
+/**
+ * Callback executed when updates are applied on a {@link SharedState}.
+ *
+ * @callback sharedStateOnUpdateCallback
+ * @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.
+ */
+/**
+ * Delete the registered {@link sharedStateOnUpdateCallback}.
+ *
+ * @callback sharedStateDeleteOnUpdateCallback
+ */
+/**
+ * The `SharedState` is one of the most important and versatile abstraction provided
+ * by `soundworks`. It represents a set of parameters that are synchronized across
+ * every nodes of the application (clients and server) that declared some interest
+ * to the shared state.
+ *
+ * A `SharedState` instance is created according to a shared state class definition
+ * which is composed of a {@link SharedStateClassName} and of a {@link SharedStateClassDescription}
+ * registered in the {@link ServerStateManager}. Any number of `SharedState`s
+ * can be created from a single class definition.
+ *
+ * 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);
+ * // define a shared state class
+ * server.stateManager.defineClass('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);
+ * ```
+ */
+declare class SharedState {
+    constructor({ stateId, instanceId, className, classDescription, isOwner, manager, initValues, filter, }: {
+        stateId: any;
+        instanceId: any;
+        className: any;
+        classDescription: any;
+        isOwner: any;
+        manager: any;
+        initValues: any;
+        filter: any;
+    });
+    /**
+     * Id of the state
+     * @type {Number}
+     */
+    get id(): number;
+    /**
+     * Name of the underlying {@link SharedState} class.
+     * @type {String}
+     */
+    get className(): string;
+    /**
+     * @deprecated Use {@link SharedState#className} instead.
+     */
+    get schemaName(): string;
+    /**
+     * Indicates if the node is the owner of the state, i.e. if it created the state.
+     * @type {Boolean}
+     */
+    get isOwner(): boolean;
+    /**
+     * Return the underlying {@link SharedStateClassDescription} or the
+     * {@link SharedStateParameterDescription} if `paramName` is given.
+     *
+     * @param {string} [paramName=null] - If defined, returns the parameter
+     *  description of the given parameter name rather than the full class description.
+     * @return {SharedStateClassDescription|SharedStateParameterDescription}
+     * @throws Throws if `paramName` is not null and does not exists.
+     * @example
+     * const classDescription = state.getDescription();
+     * const paramDescription = state.getDescription('my-param');
+     */
+    getDescription(paramName?: string): SharedStateClassDescription | SharedStateParameterDescription;
+    /**
+     * @deprecated Use {@link SharedState#getDescription} instead.
+     */
+    getSchema(paramName?: any): any;
+    /**
+     * Update the values of the state.
+     *
+     * The returned `Promise` resolves on an object that contains the applied updates,
+     * and resolves after all the `onUpdate` callbacks have resolved themselves
+     *
+     * @overload
+     * @param {object} updates - Key / value pairs of updates to apply to the state.
+     * @returns {Promise<Object>} - Promise to the (coerced) updates.
+     */
+    set(updates: object): Promise<any>;
+    /**
+     * Update the values of the state.
+     *
+     * The returned `Promise` resolves on an object that contains the applied updates,
+     * and resolves after all the `onUpdate` callbacks have resolved themselves
+     *
+     * @overload
+     * @param {SharedStateParameterName} name - Name of the parameter.
+     * @param {*} value - Value of the parameter.
+     * @returns {Promise<Object>} - Promise to the (coerced) updates.
+     */
+    set(name: SharedStateParameterName, value: any): Promise<any>;
+    /**
+     * Get the value of a parameter of the state.
+     *
+     * Be aware that in case of 'any' type, the returned value is deeply copied.
+     * While this prevents from pollution of the state by mutating the reference,
+     * this can also lead to performance issues when the parameter contains large
+     * data. In such cases you should use the {@link SharedState#getUnsafe} method
+     * and make sure to treat the returned object as readonly.
+     *
+     * @param {SharedStateParameterName} name - Name of the param.
+     * @return {any}
+     * @throws Throws if `name` does not exists.
+     * @example
+     * const value = state.get('paramName');
+     */
+    get(name: SharedStateParameterName): any;
+    /**
+     * Get an unsafe reference to the value of a parameter of the state.
+     *
+     * Similar to `get` but returns a reference to the underlying value in case of
+     * `any` type. Can be useful if the underlying value is large (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 {SharedStateParameterName} name - Name of the param.
+     * @return {any}
+     * @throws Throws if `name` does not exists.
+     * @example
+     * const value = state.getUnsafe('paramName');
+     */
+    getUnsafe(name: SharedStateParameterName): any;
+    /**
+     * 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. Can be useful 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;
+    /**
+     * Get the values with which the state has been created. May defer from the
+     * default values declared in the class description.
+     *
+     * @return {object}
+     * @example
+     * const initValues = state.getInitValues();
+     */
+    getInitValues(): object;
+    /**
+     * Get the default values as declared in the class description.
+     *
+     * @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 `onDetach` 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.stateManager.create('my-class-name');
+     * // later
+     * await state.delete();
+     */
+    delete(): Promise<any>;
+    /**
+     * Subscribe to state updates.
+     *
+     * @param {sharedStateOnUpdateCallback} callback
+     *  Callback to execute when an update is applied on the state.
+     * @param {Boolean} [executeListener=false] - Execute the callback immediately
+     *  with current state values. Note that `oldValues` will be set to `{}`.
+     * @returns {sharedStateDeleteOnUpdateCallback}
+     * @example
+     * const unsubscribe = state.onUpdate(async (newValues, oldValues) =>  {
+     *   for (let [key, value] of Object.entries(newValues)) {
+     *      switch (key) {
+     *        // do something
+     *      }
+     *   }
+     * });
+     *
+     * // later
+     * unsubscribe();
+     */
+    onUpdate(listener: any, executeListener?: boolean): sharedStateDeleteOnUpdateCallback;
+    /**
+     * 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;
+    /** @private */
+    private [kSharedStatePromiseStore];
+    #private;
+}

package/types/common/SharedStateCollection.d.ts

@@ -0,0 +1,311 @@
+/**
+ * Callback to execute when an update is triggered on one of the shared states
+ * of the collection.
+ *
+ * @callback sharedStateCollectionOnUpdateCallback
+ * @param {SharedState} state - The shared state instance 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.
+ */
+/**
+ * Delete the registered {@link sharedStateCollectionOnUpdateCallback} when executed.
+ *
+ * @callback sharedStateCollectionDeleteOnUpdateCallback
+ */
+/**
+ * Callback to execute when an new shared state is added to the collection
+ *
+ * @callback sharedStateCollectionOnAttachCallback
+ * @param {SharedState} state - The newly shared state instance added to the collection.
+ */
+/**
+ * Delete the registered {@link sharedStateCollectionOnAttachCallback} when executed.
+ *
+ * @callback sharedStateCollectionDeleteOnAttachCallback
+ */
+/**
+ * Callback to execute when an shared state is removed from the collection, i.e.
+ * has been deleted by its owner.
+ *
+ * @callback sharedStateCollectionOnDetachCallback
+ * @param {SharedState} state - The shared state instance removed from the collection.
+ */
+/**
+ * Delete the registered {@link sharedStateCollectionOnDetachCallback} when executed.
+ *
+ * @callback sharedStateCollectionDeleteOnDetachCallback
+ */
+/**
+ * Callback to execute when any state of the collection is attached, removed, or updated.
+ *
+ * @callback sharedStateCollectionOnChangeCallback
+ */
+/**
+ * Delete the registered {@link sharedStateCollectionOnChangeCallback}.
+ *
+ * @callback sharedStateCollectionDeleteOnChangeCallback
+ */
+export const kSharedStateCollectionInit: unique symbol;
+export default SharedStateCollection;
+/**
+ * Callback to execute when an update is triggered on one of the shared states
+ * of the collection.
+ */
+export type sharedStateCollectionOnUpdateCallback = (state: SharedState, newValues: any, oldValues: any) => any;
+/**
+ * Delete the registered {@link sharedStateCollectionOnUpdateCallback} when executed.
+ */
+export type sharedStateCollectionDeleteOnUpdateCallback = () => any;
+/**
+ * Callback to execute when an new shared state is added to the collection
+ */
+export type sharedStateCollectionOnAttachCallback = (state: SharedState) => any;
+/**
+ * Delete the registered {@link sharedStateCollectionOnAttachCallback} when executed.
+ */
+export type sharedStateCollectionDeleteOnAttachCallback = () => any;
+/**
+ * Callback to execute when an shared state is removed from the collection, i.e.
+ * has been deleted by its owner.
+ */
+export type sharedStateCollectionOnDetachCallback = (state: SharedState) => any;
+/**
+ * Delete the registered {@link sharedStateCollectionOnDetachCallback} when executed.
+ */
+export type sharedStateCollectionDeleteOnDetachCallback = () => any;
+/**
+ * Callback to execute when any state of the collection is attached, removed, or updated.
+ */
+export type sharedStateCollectionOnChangeCallback = () => any;
+/**
+ * Delete the registered {@link sharedStateCollectionOnChangeCallback}.
+ */
+export type sharedStateCollectionDeleteOnChangeCallback = () => any;
+/**
+ * The `SharedStateCollection` interface represent a collection of all states
+ * created from a given class name on the network.
+ *
+ * It can optionally exclude the states created by the current node.
+ *
+ * See {@link ClientStateManager#getCollection} and
+ * {@link ServerStateManager#getCollection} for factory methods API
+ *
+ * ```
+ * const collection = await client.stateManager.getCollection('my-class');
+ * const allValues = collection.getValues();
+ * collection.onUpdate((state, newValues, oldValues) => {
+ *   // do something
+ * });
+ * ```
+ * @hideconstructor
+ */
+declare class SharedStateCollection {
+    constructor(stateManager: any, className: any, filter?: any, options?: {});
+    /**
+     * Size of the collection, alias `size`
+     * @type {number}
+     * @readonly
+     */
+    readonly get length(): number;
+    /**
+     * Size of the collection, , alias `length`
+     * @type {number}
+     */
+    get size(): number;
+    /**
+     * Name of the class from which the collection has been created.
+     * @type {String}
+     */
+    get className(): string;
+    /**
+     * @deprecated Use {@link SharedStateCollection#className} instead.
+     */
+    get schemaName(): string;
+    /**
+     * @deprecated Use {@link SharedStateCollection#getDescription} instead.
+     */
+    getSchema(paramName?: any): any;
+    /**
+     * Return the underlying {@link SharedStateClassDescription} or the
+     * {@link SharedStateParameterDescription} if `paramName` is given.
+     *
+     * @param {string} [paramName=null] - If defined, returns the parameter
+     *  description of the given parameter name rather than the full class description.
+     * @return {SharedStateClassDescription|SharedStateParameterDescription}
+     * @throws Throws if `paramName` is not null and does not exists.
+     * @example
+     * const classDescription = collection.getDescription();
+     * const paramDescription = collection.getDescription('my-param');
+     */
+    getDescription(paramName?: string): SharedStateClassDescription | SharedStateParameterDescription;
+    /**
+     * Get the default values as declared in the class description.
+     *
+     * @return {object}
+     * @example
+     * const defaults = state.getDefaults();
+     */
+    getDefaults(): object;
+    /**
+     * Return the current values of all the states in the collection.
+     * @return {Object[]}
+     */
+    getValues(): any[];
+    /**
+     * Return the current values of all the states in the collection.
+     *
+     * Similar to `getValues` but returns a reference to the underlying value in
+     * case of `any` type. May be useful 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[]}
+     */
+    getValuesUnsafe(): any[];
+    /**
+     * Return the current param value of all the states in the collection.
+     *
+     * @param {String} name - Name of the parameter
+     * @return {any[]}
+     */
+    get(name: string): any[];
+    /**
+     * Similar to `get` but returns a reference to the underlying value in case of
+     * `any` type. May be useful 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 parameter
+     * @return {any[]}
+     */
+    getUnsafe(name: string): any[];
+    /**
+     * Update all states of the collection with given values.
+     *
+     * The returned `Promise` resolves on a list of objects that contains the applied updates,
+     * and resolves after all the `onUpdate` callbacks have resolved themselves
+     *
+     * @overload
+     * @param {object} updates - key / value pairs of updates to apply to the collection.
+     * @returns {Promise<Array<Object>>} - Promise to the list of (coerced) updates.
+     */
+    set(updates: object): Promise<Array<any>>;
+    /**
+     * Update all states of the collection with given values.
+     *
+     * The returned `Promise` resolves on a list of objects that contains the applied updates,
+     * and resolves after all the `onUpdate` callbacks have resolved themselves
+     *
+     * @overload
+     * @param {SharedStateParameterName} name - Name of the parameter.
+     * @param {*} value - Value of the parameter.
+     * @returns {Promise<Array<Object>>} - Promise to the list of (coerced) updates.
+     */
+    set(name: SharedStateParameterName, value: any): Promise<Array<any>>;
+    /**
+     * Register a function to execute when any shared state of the collection is updated.
+     *
+     * @param {sharedStateCollectionOnUpdateCallback}
+     *  callback - Callback to execute when an update is applied on a state.
+     * @param {Boolean} [executeListener=false] - Execute the callback immediately
+     *  with current state values. Note that `oldValues` will be set to `{}`.
+     * @returns {sharedStateCollectionDeleteOnUpdateCallback} - Function that delete
+     *  the registered listener when executed.
+     */
+    onUpdate(callback: sharedStateCollectionOnUpdateCallback, executeListener?: boolean): sharedStateCollectionDeleteOnUpdateCallback;
+    /**
+     * Register a function to execute when a shared state is attached to the collection,
+     * i.e. when a node creates a new state from same {@link SharedState} class.
+     *
+     * @param {sharedStateCollectionOnAttachCallback} callback - callback to execute
+     *   when a state is added to the collection.
+     * @param {boolean} executeListener - execute the callback with the states
+     *   already present in the collection.
+     * @returns {sharedStateCollectionDeleteOnAttachCallback} - Function that delete
+     *   the registered listener when executed.
+     */
+    onAttach(callback: sharedStateCollectionOnAttachCallback, executeListener?: boolean): sharedStateCollectionDeleteOnAttachCallback;
+    /**
+     * Register a function to execute when a shared state is removed from the collection,
+     * i.e. when it is deleted by its owner.
+     *
+     * @param {sharedStateCollectionOnDetachCallback} callback - callback to execute
+     *   when a state is removed from the collection.
+     * @returns {sharedStateCollectionDeleteOnDetachCallback} - Function that delete
+     *   the registered listener when executed.
+     */
+    onDetach(callback: sharedStateCollectionOnDetachCallback): sharedStateCollectionDeleteOnDetachCallback;
+    /**
+     * Register a function to execute when any state of the collection is either attached,
+     * removed, or updated.
+     *
+     * @param {sharedStateCollectionOnChangeCallback} callback - callback to execute
+     *   when any state of the collection is either attached, updated, or detached.
+     * @returns {sharedStateCollectionDeleteOnChangeCallback} - Function that delete
+     *   the registered listener when executed.
+     * @example
+     * const collection = await client.stateManager.getCollection('player');
+     * collection.onChange(() => renderApp(), true);
+     */
+    onChange(callback: sharedStateCollectionOnChangeCallback, executeListener?: boolean): sharedStateCollectionDeleteOnChangeCallback;
+    /**
+     * Detach from the collection, i.e. detach all underlying shared states.
+     * @type {number}
+     */
+    detach(): Promise<void>;
+    /**
+     * Execute the given function once for each states of the collection (see `Array.forEach`).
+     *
+     * @param {Function} func - A function to execute for each element in the array.
+     *  Its return value is discarded.
+     */
+    forEach(func: Function): void;
+    /**
+     * Creates a new array populated with the results of calling a provided function
+     * on every state of the collection (see `Array.map`).
+     *
+     * @param {Function} func - A function to execute for each element in the array.
+     *  Its return value is added as a single element in the new array.
+     */
+    map(func: Function): any[];
+    /**
+     * Creates a shallow copy of a portion of the collection, filtered down to just
+     * the estates that pass the test implemented by the provided function (see `Array.filter`).
+     *
+     * @param {Function} func - A function to execute for each element in the array.
+     *  It should return a truthy to keep the element in the resulting array, and a
+     *  falsy value otherwise.
+     */
+    filter(func: Function): any[];
+    /**
+     * Sort the elements of the collection in place (see `Array.sort`).
+     *
+     * @param {Function} func - Function that defines the sort order.
+     */
+    sort(func: Function): void;
+    /**
+     * Returns the first element of the collection that satisfies the provided testing
+     * function. If no values satisfy the testing function, undefined is returned.
+     *
+     * @param {Function} func - Function to execute for each element in the array.
+     *  It should return a truthy value to indicate a matching element has been found.
+     * @return {}
+     */
+    find(func: Function): any;
+    /** @private */
+    private [kSharedStateCollectionInit];
+    /**
+     * Iterable API, e.g. for use in `for .. of` loops
+     */
+    [Symbol.iterator](): {
+        next: () => {
+            value: any;
+            done: boolean;
+        };
+    };
+    #private;
+}

package/types/common/constants.d.ts

@@ -1,4 +1,8 @@
 export const SERVER_ID: -1;
+export const PING_INTERVAL: number;
+export const PING_MESSAGE: "h:ping";
+export const PONG_MESSAGE: "h:pong";
+export const BATCHED_TRANSPORT_CHANNEL: "b:t";
 export const CREATE_REQUEST: "s:c:req";
 export const CREATE_RESPONSE: "s:c:res";
 export const CREATE_ERROR: "s:c:err";
@@ -14,13 +18,17 @@ export const DETACH_RESPONSE: "s:dt:res";
 export const DETACH_ERROR: "s:dt:err";
 export const OBSERVE_REQUEST: "s:o:req";
 export const OBSERVE_RESPONSE: "s:o:res";
+export const OBSERVE_ERROR: "s:o:err";
 export const OBSERVE_NOTIFICATION: "s:o:not";
 export const UNOBSERVE_NOTIFICATION: "s:uo:not";
 export const UPDATE_REQUEST: "s:u:req";
 export const UPDATE_RESPONSE: "s:u:res";
 export const UPDATE_ABORT: "s:u:ab";
 export const UPDATE_NOTIFICATION: "s:u:not";
-export const DELETE_SCHEMA: "s:d:s";
+export const DELETE_SHARED_STATE_CLASS: "s:d:s";
+export const GET_CLASS_DESCRIPTION_REQUEST: "s:s:req";
+export const GET_CLASS_DESCRIPTION_RESPONSE: "s:s:res";
+export const GET_CLASS_DESCRIPTION_ERROR: "s:s:err";
 export const CONTEXT_ENTER_REQUEST: "c:en:req";
 export const CONTEXT_ENTER_RESPONSE: "c:en:res";
 export const CONTEXT_ENTER_ERROR: "c:en:err";
@@ -30,6 +38,5 @@ export const CONTEXT_EXIT_ERROR: "c:ex:err";
 export const CLIENT_HANDSHAKE_REQUEST: "cl:h:req";
 export const CLIENT_HANDSHAKE_RESPONSE: "cl:h:res";
 export const CLIENT_HANDSHAKE_ERROR: "cl:h:err";
-export const AUDIT_STATE_NAME: "s:c:audit";
+export const AUDIT_STATE_NAME: "p:s:audit";
 export const PRIVATE_STATES: string[];
-//# sourceMappingURL=constants.d.ts.map

package/types/common/logger.d.ts

@@ -1,16 +1,18 @@
 export default logger;
 declare namespace logger {
-    const verbose: boolean;
+    let verbose: boolean;
     function configure(verbose: any): void;
     function title(msg: any): void;
-    function clientConfigAndRouting(routes: any, config: any): void;
+    function log(msg: any): void;
+    function warn(msg: any): void;
+    function error(msg: any): void;
     function ip(protocol: any, address: any, port: any): void;
     function pluginStart(name: any): void;
     function pluginStarted(name: any): void;
     function pluginReady(name: any): void;
     function pluginErrored(name: any): void;
-    function log(msg: any): void;
-    function warn(msg: any): void;
-    function error(msg: any): void;
+    function warnVersionDiscrepancies(clientRole: any, clientVersion: any, serverVersion: any): void;
+    function deprecated(oldAPI: any, newAPI: any, lastSupportedVersion: any): void;
+    function removed(oldAPI: any, hint: any, lastSupportedVersion: any): never;
+    function httpsCertsInfos(httpsCertsInfos: any): void;
 }
-//# sourceMappingURL=logger.d.ts.map