@inditextech/weave-store-azure-web-pubsub 5.2.0 → 5.2.2

package/dist/client.d.ts

@@ -1,105 +1,814 @@
+/// <reference types="node" />
 import { WeaveStore } from "@inditextech/weave-sdk";
 import { DeepPartial, WeaveStoreOptions } from "@inditextech/weave-types";
 import ReconnectingWebSocket from "reconnecting-websocket";
+import * as Y from "yjs";
 import { Doc } from "yjs";
-import Emittery from "emittery";
-import * as awarenessProtocol from "y-protocols/awareness";
 import { WebSocket } from "ws";
 import { TokenCredential } from "@azure/identity";
-import { Encoder } from "lib0/encoding";
-import { Decoder } from "lib0/decoding";
+import "@azure/web-pubsub";
+import "events";
+import "http";
+//#region ../../node_modules/emittery/index.d.ts
+/**
+Emittery accepts strings, symbols, and numbers as event names.
 
-//#region src/server/event-handler/cloud-events-protocols.d.ts
+Symbol event names are preferred given that they can be used to avoid name collisions when your classes are extended, especially for internal events.
+*/
+type EventName = PropertyKey;
+// Helper type for turning the passed `EventData` type map into a list of string keys that don't require data alongside the event name when emitting. Uses the same trick that `Omit` does internally to filter keys by building a map of keys to keys we want to keep, and then accessing all the keys to return just the list of keys we want to keep.
+type DatalessEventNames<EventData> = { [Key in keyof EventData]: EventData[Key] extends undefined ? Key : never; }[keyof EventData];
+declare const listenerAdded: unique symbol;
+declare const listenerRemoved: unique symbol;
+type OmnipresentEventData = {
+  [listenerAdded]: ListenerChangedData;
+  [listenerRemoved]: ListenerChangedData;
+};
 /**
-* The protocol of Web PubSub Client.
+Emittery can collect and log debug information.
+
+To enable this feature set the `DEBUG` environment variable to `emittery` or `*`. Additionally, you can set the static `isDebugEnabled` variable to true on the Emittery class, or `myEmitter.debug.enabled` on an instance of it for debugging a single instance.
+
+See API for more information on how debugging works.
 */
+type DebugLogger<EventData, Name extends keyof EventData> = (type: string, debugName: string, eventName?: Name, eventData?: EventData[Name]) => void;
+/**
+Configure debug options of an instance.
+*/
+type DebugOptions<EventData> = {
+  /**
+	Define a name for the instance of Emittery to use when outputting debug data.
+
+	@default undefined
+
+	@example
+	```
+	import Emittery from 'emittery';
+
+	Emittery.isDebugEnabled = true;
+
+	const emitter = new Emittery({debug: {name: 'myEmitter'}});
+
+	emitter.on('test', data => {
+		// …
+	});
+
+	emitter.emit('test');
+	//=> [16:43:20.417][emittery:subscribe][myEmitter] Event Name: test
+	//	data: undefined
+	```
+	*/
+  readonly name: string;
+  /**
+	Toggle debug logging just for this instance.
+
+	@default false
+
+	@example
+	```
+	import Emittery from 'emittery';
+
+	const emitter1 = new Emittery({debug: {name: 'emitter1', enabled: true}});
+	const emitter2 = new Emittery({debug: {name: 'emitter2'}});
+
+	emitter1.on('test', data => {
+		// …
+	});
+
+	emitter2.on('test', data => {
+		// …
+	});
+
+	emitter1.emit('test');
+	//=> [16:43:20.417][emittery:subscribe][emitter1] Event Name: test
+	//	data: undefined
+
+	emitter2.emit('test');
+	```
+	*/
+  readonly enabled?: boolean;
+  /**
+	Function that handles debug data.
+
+	@default
+	```
+	(type, debugName, eventName, eventData) => {
+		eventData = JSON.stringify(eventData);
 
+		if (typeof eventName === 'symbol' || typeof eventName === 'number') {
+			eventName = eventName.toString();
+		}
+
+		const currentTime = new Date();
+		const logTime = `${currentTime.getHours()}:${currentTime.getMinutes()}:${currentTime.getSeconds()}.${currentTime.getMilliseconds()}`;
+		console.log(`[${logTime}][emittery:${type}][${debugName}] Event Name: ${eventName}\n\tdata: ${eventData}`);
+	}
+	```
+
+	@example
+	```
+	import Emittery from 'emittery';
+
+	const myLogger = (type, debugName, eventName, eventData) => {
+		console.log(`[${type}]: ${eventName}`);
+	};
+
+	const emitter = new Emittery({
+		debug: {
+			name: 'myEmitter',
+			enabled: true,
+			logger: myLogger
+		}
+	});
+
+	emitter.on('test', data => {
+		// …
+	});
+
+	emitter.emit('test');
+	//=> [subscribe]: test
+	```
+	*/
+  readonly logger?: DebugLogger<EventData, keyof EventData>;
+};
 /**
-* The protocol of Web PubSub Client.
+Configuration options for Emittery.
 */
-type WebPubSubClientProtocol = "default" | "mqtt";
+type Options<EventData> = {
+  readonly debug?: DebugOptions<EventData>;
+};
+/**
+A promise returned from `emittery.once` with an extra `off` method to cancel your subscription.
+*/
+type EmitteryOncePromise<T> = {
+  off(): void;
+} & Promise<T>;
+/**
+Removes an event subscription.
+*/
+type UnsubscribeFunction = () => void;
 /**
-* The connection context representing the client WebSocket connection.
+The data provided as `eventData` when listening for `Emittery.listenerAdded` or `Emittery.listenerRemoved`.
 */
+type ListenerChangedData = {
+  /**
+	The listener that was added or removed.
+	*/
+  listener: (eventData?: unknown) => (void | Promise<void>);
+  /**
+	The name of the event that was added or removed if `.on()` or `.off()` was used, or `undefined` if `.onAny()` or `.offAny()` was used.
+	*/
+  eventName?: EventName;
+};
+/**
+Emittery is a strictly typed, fully async EventEmitter implementation. Event listeners can be registered with `on` or `once`, and events can be emitted with `emit`.
+
+`Emittery` has a generic `EventData` type that can be provided by users to strongly type the list of events and the data passed to the listeners for those events. Pass an interface of {[eventName]: undefined | <eventArg>}, with all the event names as the keys and the values as the type of the argument passed to listeners if there is one, or `undefined` if there isn't.
+
+@example
+```
+import Emittery from 'emittery';
+
+const emitter = new Emittery<
+	// Pass `{[eventName: <string | symbol | number>]: undefined | <eventArg>}` as the first type argument for events that pass data to their listeners.
+	// A value of `undefined` in this map means the event listeners should expect no data, and a type other than `undefined` means the listeners will receive one argument of that type.
+	{
+		open: string,
+		close: undefined
+	}
+>();
+
+// Typechecks just fine because the data type for the `open` event is `string`.
+emitter.emit('open', 'foo\n');
+
+// Typechecks just fine because `close` is present but points to undefined in the event data type map.
+emitter.emit('close');
+
+// TS compilation error because `1` isn't assignable to `string`.
+emitter.emit('open', 1);
+
+// TS compilation error because `other` isn't defined in the event data type map.
+emitter.emit('other');
+```
+*/
+declare class Emittery<EventData = Record<EventName, any> // TODO: Use `unknown` instead of `any`.
+, AllEventData = EventData & OmnipresentEventData, DatalessEvents = DatalessEventNames<EventData>> {
+  /**
+	Toggle debug mode for all instances.
+
+	Default: `true` if the `DEBUG` environment variable is set to `emittery` or `*`, otherwise `false`.
+
+	@example
+	```
+	import Emittery from 'emittery';
+
+	Emittery.isDebugEnabled = true;
+
+	const emitter1 = new Emittery({debug: {name: 'myEmitter1'}});
+	const emitter2 = new Emittery({debug: {name: 'myEmitter2'}});
+
+	emitter1.on('test', data => {
+		// …
+	});
+
+	emitter2.on('otherTest', data => {
+		// …
+	});
+
+	emitter1.emit('test');
+	//=> [16:43:20.417][emittery:subscribe][myEmitter1] Event Name: test
+	//	data: undefined
+
+	emitter2.emit('otherTest');
+	//=> [16:43:20.417][emittery:subscribe][myEmitter2] Event Name: otherTest
+	//	data: undefined
+	```
+	*/
+  static isDebugEnabled: boolean;
+  /**
+	Fires when an event listener was added.
+
+	An object with `listener` and `eventName` (if `on` or `off` was used) is provided as event data.
+
+	@example
+	```
+	import Emittery from 'emittery';
+
+	const emitter = new Emittery();
+
+	emitter.on(Emittery.listenerAdded, ({listener, eventName}) => {
+		console.log(listener);
+		//=> data => {}
+
+		console.log(eventName);
+		//=> '🦄'
+	});
+
+	emitter.on('🦄', data => {
+		// Handle data
+	});
+	```
+	*/
+  static readonly listenerAdded: typeof listenerAdded;
+  /**
+	Fires when an event listener was removed.
+
+	An object with `listener` and `eventName` (if `on` or `off` was used) is provided as event data.
+
+	@example
+	```
+	import Emittery from 'emittery';
+
+	const emitter = new Emittery();
+
+	const off = emitter.on('🦄', data => {
+		// Handle data
+	});
+
+	emitter.on(Emittery.listenerRemoved, ({listener, eventName}) => {
+		console.log(listener);
+		//=> data => {}
+
+		console.log(eventName);
+		//=> '🦄'
+	});
+
+	off();
+	```
+	*/
+  static readonly listenerRemoved: typeof listenerRemoved;
+  /**
+	In TypeScript, it returns a decorator which mixins `Emittery` as property `emitteryPropertyName` and `methodNames`, or all `Emittery` methods if `methodNames` is not defined, into the target class.
+
+	@example
+	```
+	import Emittery from 'emittery';
+
+	@Emittery.mixin('emittery')
+	class MyClass {}
+
+	const instance = new MyClass();
+
+	instance.emit('event');
+	```
+	*/
+  static mixin(emitteryPropertyName: string | symbol, methodNames?: readonly string[]): <T extends {
+    new (...arguments_: readonly any[]): any;
+  }>(klass: T) => T; // eslint-disable-line @typescript-eslint/prefer-function-type
+  /**
+	Debugging options for the current instance.
+	*/
+  debug: DebugOptions<EventData>;
+  /**
+	Create a new Emittery instance with the specified options.
+
+	@returns An instance of Emittery that you can use to listen for and emit events.
+	*/
+  constructor(options?: Options<EventData>);
+  /**
+	Subscribe to one or more events.
+
+	Using the same listener multiple times for the same event will result in only one method call per emitted event.
+
+	@returns An unsubscribe method.
+
+	@example
+	```
+	import Emittery from 'emittery';
+
+	const emitter = new Emittery();
+
+	emitter.on('🦄', data => {
+		console.log(data);
+	});
+
+	emitter.on(['🦄', '🐶'], data => {
+		console.log(data);
+	});
+
+	emitter.emit('🦄', '🌈'); // log => '🌈' x2
+	emitter.emit('🐶', '🍖'); // log => '🍖'
+	```
+	*/
+  on<Name extends keyof AllEventData>(eventName: Name | readonly Name[], listener: (eventData: AllEventData[Name]) => void | Promise<void>, options?: {
+    signal?: AbortSignal;
+  }): UnsubscribeFunction;
+  /**
+	Get an async iterator which buffers data each time an event is emitted.
+
+	Call `return()` on the iterator to remove the subscription.
+
+	@example
+	```
+	import Emittery from 'emittery';
+
+	const emitter = new Emittery();
+	const iterator = emitter.events('🦄');
+
+	emitter.emit('🦄', '🌈1'); // Buffered
+	emitter.emit('🦄', '🌈2'); // Buffered
+
+	iterator
+		.next()
+		.then(({value, done}) => {
+			// done === false
+			// value === '🌈1'
+			return iterator.next();
+		})
+		.then(({value, done}) => {
+			// done === false
+			// value === '🌈2'
+			// Revoke subscription
+			return iterator.return();
+		})
+		.then(({done}) => {
+			// done === true
+		});
+	```
+
+	In practice you would usually consume the events using the [for await](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for-await...of) statement. In that case, to revoke the subscription simply break the loop.
+
+	@example
+	```
+	import Emittery from 'emittery';
+
+	const emitter = new Emittery();
+	const iterator = emitter.events('🦄');
+
+	emitter.emit('🦄', '🌈1'); // Buffered
+	emitter.emit('🦄', '🌈2'); // Buffered
+
+	// In an async context.
+	for await (const data of iterator) {
+		if (data === '🌈2') {
+			break; // Revoke the subscription when we see the value `🌈2`.
+		}
+	}
+	```
+
+	It accepts multiple event names.
+
+	@example
+	```
+	import Emittery from 'emittery';
+
+	const emitter = new Emittery();
+	const iterator = emitter.events(['🦄', '🦊']);
+
+	emitter.emit('🦄', '🌈1'); // Buffered
+	emitter.emit('🦊', '🌈2'); // Buffered
+
+	iterator
+		.next()
+		.then(({value, done}) => {
+			// done === false
+			// value === '🌈1'
+			return iterator.next();
+		})
+		.then(({value, done}) => {
+			// done === false
+			// value === '🌈2'
+			// Revoke subscription
+			return iterator.return();
+		})
+		.then(({done}) => {
+			// done === true
+		});
+	```
+	*/
+  events<Name extends keyof EventData>(eventName: Name | readonly Name[]): AsyncIterableIterator<EventData[Name]>;
+  /**
+	Remove one or more event subscriptions.
+
+	@example
+	```
+	import Emittery from 'emittery';
+
+	const emitter = new Emittery();
+
+	const listener = data => {
+		console.log(data);
+	};
+
+	emitter.on(['🦄', '🐶', '🦊'], listener);
+	await emitter.emit('🦄', 'a');
+	await emitter.emit('🐶', 'b');
+	await emitter.emit('🦊', 'c');
+	emitter.off('🦄', listener);
+	emitter.off(['🐶', '🦊'], listener);
+	await emitter.emit('🦄', 'a'); // nothing happens
+	await emitter.emit('🐶', 'b'); // nothing happens
+	await emitter.emit('🦊', 'c'); // nothing happens
+	```
+	*/
+  off<Name extends keyof AllEventData>(eventName: Name | readonly Name[], listener: (eventData: AllEventData[Name]) => void | Promise<void>): void;
+  /**
+	Subscribe to one or more events only once. It will be unsubscribed after the first
+	event.
+
+	@returns The promise of event data when `eventName` is emitted. This promise is extended with an `off` method.
+
+	@example
+	```
+	import Emittery from 'emittery';
+
+	const emitter = new Emittery();
+
+	emitter.once('🦄').then(data => {
+		console.log(data);
+		//=> '🌈'
+	});
+
+	emitter.once(['🦄', '🐶']).then(data => {
+		console.log(data);
+	});
+
+	emitter.emit('🦄', '🌈'); // Logs `🌈` twice
+	emitter.emit('🐶', '🍖'); // Nothing happens
+	```
+	*/
+  once<Name extends keyof AllEventData>(eventName: Name | readonly Name[]): EmitteryOncePromise<AllEventData[Name]>;
+  /**
+	Trigger an event asynchronously, optionally with some data. Listeners are called in the order they were added, but executed concurrently.
+
+	@returns A promise that resolves when all the event listeners are done. *Done* meaning executed if synchronous or resolved when an async/promise-returning function. You usually wouldn't want to wait for this, but you could for example catch possible errors. If any of the listeners throw/reject, the returned promise will be rejected with the error, but the other listeners will not be affected.
+	*/
+  emit<Name extends DatalessEvents>(eventName: Name): Promise<void>;
+  emit<Name extends keyof EventData>(eventName: Name, eventData: EventData[Name]): Promise<void>;
+  /**
+	Same as `emit()`, but it waits for each listener to resolve before triggering the next one. This can be useful if your events depend on each other. Although ideally they should not. Prefer `emit()` whenever possible.
+
+	If any of the listeners throw/reject, the returned promise will be rejected with the error and the remaining listeners will *not* be called.
+
+	@returns A promise that resolves when all the event listeners are done.
+	*/
+  emitSerial<Name extends DatalessEvents>(eventName: Name): Promise<void>;
+  emitSerial<Name extends keyof EventData>(eventName: Name, eventData: EventData[Name]): Promise<void>;
+  /**
+	Subscribe to be notified about any event.
+
+	@returns A method to unsubscribe.
+	*/
+  onAny(listener: (eventName: keyof EventData, eventData: EventData[keyof EventData]) => void | Promise<void>, options?: {
+    signal?: AbortSignal;
+  }): UnsubscribeFunction;
+  /**
+	Get an async iterator which buffers a tuple of an event name and data each time an event is emitted.
+
+	Call `return()` on the iterator to remove the subscription.
+
+	In the same way as for `events`, you can subscribe by using the `for await` statement.
+
+	@example
+	```
+	import Emittery from 'emittery';
+
+	const emitter = new Emittery();
+	const iterator = emitter.anyEvent();
+
+	emitter.emit('🦄', '🌈1'); // Buffered
+	emitter.emit('🌟', '🌈2'); // Buffered
+
+	iterator.next()
+		.then(({value, done}) => {
+			// done is false
+			// value is ['🦄', '🌈1']
+			return iterator.next();
+		})
+		.then(({value, done}) => {
+			// done is false
+			// value is ['🌟', '🌈2']
+			// revoke subscription
+			return iterator.return();
+		})
+		.then(({done}) => {
+			// done is true
+		});
+	```
+	*/
+  anyEvent(): AsyncIterableIterator<[keyof EventData, EventData[keyof EventData]]>;
+  /**
+	Remove an `onAny` subscription.
+	*/
+  offAny(listener: (eventName: keyof EventData, eventData: EventData[keyof EventData]) => void | Promise<void>): void;
+  /**
+	Clear all event listeners on the instance.
+
+	If `eventName` is given, only the listeners for that event are cleared.
+	*/
+  clearListeners<Name extends keyof EventData>(eventName?: Name | readonly Name[]): void;
+  /**
+	The number of listeners for the `eventName` or all events if not specified.
+	*/
+  listenerCount<Name extends keyof EventData>(eventName?: Name | readonly Name[]): number;
+  /**
+	Bind the given `methodNames`, or all `Emittery` methods if `methodNames` is not defined, into the `target` object.
+
+	@example
+	```
+	import Emittery from 'emittery';
+
+	const object = {};
+
+	new Emittery().bindMethods(object);
+
+	object.emit('event');
+	```
+	*/
+  bindMethods(target: Record<string, unknown>, methodNames?: readonly string[]): void;
+}
+//#endregion
+//#region ../../node_modules/lib0/observable.d.ts
+/**
+ * Handles named events.
+ *
+ * @deprecated
+ * @template N
+ */
+declare class Observable<N> {
+  /**
+   * Some desc.
+   * @type {Map<N, any>}
+   */
+  _observers: Map<N, any>;
+  /**
+   * @param {N} name
+   * @param {function} f
+   */
+  on(name: N, f: Function): void;
+  /**
+   * @param {N} name
+   * @param {function} f
+   */
+  once(name: N, f: Function): void;
+  /**
+   * @param {N} name
+   * @param {function} f
+   */
+  off(name: N, f: Function): void;
+  /**
+   * Emit a named event. All registered event listeners that listen to the
+   * specified name will receive the event.
+   *
+   * @todo This should catch exceptions
+   *
+   * @param {N} name The event name.
+   * @param {Array<any>} args The arguments that are applied to the event listener.
+   */
+  emit(name: N, args: Array<any>): void;
+  destroy(): void;
+}
+//#endregion
+//#region ../../node_modules/y-protocols/awareness.d.ts
+/**
+ * @typedef {Object} MetaClientState
+ * @property {number} MetaClientState.clock
+ * @property {number} MetaClientState.lastUpdated unix timestamp
+ */
+/**
+ * The Awareness class implements a simple shared state protocol that can be used for non-persistent data like awareness information
+ * (cursor, username, status, ..). Each client can update its own local state and listen to state changes of
+ * remote clients. Every client may set a state of a remote peer to `null` to mark the client as offline.
+ *
+ * Each client is identified by a unique client id (something we borrow from `doc.clientID`). A client can override
+ * its own state by propagating a message with an increasing timestamp (`clock`). If such a message is received, it is
+ * applied if the known state of that client is older than the new state (`clock < newClock`). If a client thinks that
+ * a remote client is offline, it may propagate a message with
+ * `{ clock: currentClientClock, state: null, client: remoteClient }`. If such a
+ * message is received, and the known clock of that client equals the received clock, it will override the state with `null`.
+ *
+ * Before a client disconnects, it should propagate a `null` state with an updated clock.
+ *
+ * Awareness states must be updated every 30 seconds. Otherwise the Awareness instance will delete the client state.
+ *
+ * @extends {Observable<string>}
+ */
+declare class Awareness extends Observable<string> {
+  /**
+   * @param {Y.Doc} doc
+   */
+  constructor(doc: Y.Doc);
+  doc: Y.Doc;
+  /**
+   * @type {number}
+   */
+  clientID: number;
+  /**
+   * Maps from client id to client state
+   * @type {Map<number, Object<string, any>>}
+   */
+  states: Map<number, {
+    [x: string]: any;
+  }>;
+  /**
+   * @type {Map<number, MetaClientState>}
+   */
+  meta: Map<number, MetaClientState>;
+  _checkInterval: any;
+  /**
+   * @return {Object<string,any>|null}
+   */
+  getLocalState(): {
+    [x: string]: any;
+  } | null;
+  /**
+   * @param {Object<string,any>|null} state
+   */
+  setLocalState(state: {
+    [x: string]: any;
+  } | null): void;
+  /**
+   * @param {string} field
+   * @param {any} value
+   */
+  setLocalStateField(field: string, value: any): void;
+  /**
+   * @return {Map<number,Object<string,any>>}
+   */
+  getStates(): Map<number, {
+    [x: string]: any;
+  }>;
+}
+type MetaClientState = {
+  clock: number;
+  /**
+   * unix timestamp
+   */
+  lastUpdated: number;
+};
+//#endregion
+//#region ../../node_modules/@types/express-serve-static-core/index.d.ts
+declare global {
+  namespace Express {
+    // These open interfaces may be extended in an application-specific manner via declaration merging.
+    // See for example method-override.d.ts (https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/method-override/index.d.ts)
+    interface Request {}
+    interface Response {}
+    interface Locals {}
+    interface Application {}
+  }
+}
+//#endregion
+//#region src/server/event-handler/cloud-events-protocols.d.ts
+/**
+ * The protocol of Web PubSub Client.
+ */
+type WebPubSubClientProtocol = "default" | "mqtt";
+/**
+ * The connection context representing the client WebSocket connection.
+ */
 interface ConnectionContext {
   /**
-  * The unique identifier generated by the service of the network connection.
-  */
+   * The unique identifier generated by the service of the network connection.
+   */
   signature: string;
   /**
-  * The hub the connection belongs to.
-  */
+   * The hub the connection belongs to.
+   */
   hub: string;
   /**
-  * The Id of the connection.
-  */
+   * The Id of the connection.
+   */
   connectionId: string;
   /**
-  * The event name of this CloudEvents request.
-  */
+   * The event name of this CloudEvents request.
+   */
   eventName: string;
   /**
-  * The origin this CloudEvents request comes from.
-  */
+   * The origin this CloudEvents request comes from.
+   */
   origin: string;
   /**
-  * The user id of the connection.
-  */
+   * The user id of the connection.
+   */
   userId?: string;
   /**
-  * The subprotocol of this connection.
-  */
+   * The subprotocol of this connection.
+   */
   subprotocol?: string;
   /**
-  * Get the additional states for the connection, such states are perserved throughout the lifetime of the connection.
-  */
+   * Get the additional states for the connection, such states are perserved throughout the lifetime of the connection.
+   */
   states: Record<string, any>;
   /**
-  * The type of client protocol.
-  */
+   * The type of client protocol.
+   */
   clientProtocol: WebPubSubClientProtocol;
   /**
-  * The MQTT properties that the client WebSocket connection has when it connects (For MQTT connection only).
-  */
+   * The MQTT properties that the client WebSocket connection has when it connects (For MQTT connection only).
+   */
   mqtt?: MqttConnectionContextProperties;
 }
 /**
-* The connection context properties representing the MQTT client WebSocket connection.
-*/
+ * The connection context properties representing the MQTT client WebSocket connection.
+ */
 interface MqttConnectionContextProperties {
   /**
-  * The unique identifier generated by the service of the network connection.
-  */
+   * The unique identifier generated by the service of the network connection.
+   */
   physicalConnectionId: string;
   /**
-  * The unique identifier generated by the service of the MQTT session.
-  */
+   * The unique identifier generated by the service of the MQTT session.
+   */
   sessionId?: string;
-} //#endregion
+}
+//#endregion
 //#region src/constants.d.ts
-
-/**
-* Request for the connect event.
-*/
 declare const WEAVE_STORE_AZURE_WEB_PUBSUB = "store-azure-web-pubsub";
 declare const WEAVE_STORE_AZURE_WEB_PUBSUB_CONNECTION_STATUS: {
-  "CONNECTING": string;
-  "CONNECTED": string;
-  "DISCONNECTED": string;
-  "ERROR": string;
+  CONNECTING: string;
+  CONNECTED: string;
+  DISCONNECTED: string;
+  ERROR: string;
 };
 declare const WEAVE_STORE_HORIZONTAL_SYNC_HANDLER_CLIENT_TYPE: {
-  "PUB": string;
-  "SUB": string;
+  PUB: string;
+  SUB: string;
 };
 declare const WEAVE_STORE_AZURE_WEB_PUBSUB_DESTROY_ROOM_STATUS: {
-  "NOT_FOUND": string;
-  "NOT_CONNECTED": string;
-  "DESTROYED": string;
+  NOT_FOUND: string;
+  NOT_CONNECTED: string;
+  DESTROYED: string;
 };
 declare const WEAVE_STORE_AZURE_WEB_PUBSUB_SYNC_CLIENT_DEFAULT_OPTIONS: WeaveStoreAzureWebPubSubSyncClientOptions;
 declare const WEAVE_STORE_AZURE_WEB_PUBSUB_SYNC_HOST_DEFAULT_OPTIONS: WeaveStoreAzureWebPubsubSyncHostOptions;
-
+//#endregion
+//#region ../../node_modules/lib0/encoding.d.ts
+/**
+ * A BinaryEncoder handles the encoding to an Uint8Array.
+ */
+declare class Encoder {
+  cpos: number;
+  cbuf: Uint8Array<ArrayBuffer>;
+  /**
+   * @type {Array<Uint8Array>}
+   */
+  bufs: Array<Uint8Array>;
+}
+//#endregion
+//#region ../../node_modules/lib0/decoding.d.ts
+/**
+ * A Decoder handles the decoding of an Uint8Array.
+ * @template {ArrayBufferLike} [Buf=ArrayBufferLike]
+ */
+declare class Decoder<Buf extends ArrayBufferLike = ArrayBufferLike> {
+  /**
+   * @param {Uint8Array<Buf>} uint8Array Binary data to decode
+   */
+  constructor(uint8Array: Uint8Array<Buf>);
+  /**
+   * Decoding target.
+   *
+   * @type {Uint8Array<Buf>}
+   */
+  arr: Uint8Array<Buf>;
+  /**
+   * Current decoding position.
+   *
+   * @type {number}
+   */
+  pos: number;
+}
 //#endregion
 //#region src/types.d.ts
 type WeaveStoreAzureWebPubsubConfig = {
@@ -124,9 +833,9 @@ type IndexedDbOptions = {
   /** Enable IndexedDB offline persistence for faster initial load. Default: false. */
   enabled: boolean;
   /**
-  * IndexedDB database name. Defaults to the roomId when omitted.
-  * Override to namespace databases in multi-tenant applications.
-  */
+   * IndexedDB database name. Defaults to the roomId when omitted.
+   * Override to namespace databases in multi-tenant applications.
+   */
   dbName?: string;
 };
 type WeaveStoreAzureWebPubsubOptions = {
@@ -199,12 +908,12 @@ type WeaveStoreAzureWebPubSubSyncClientConnectionStatus = (typeof WEAVE_STORE_AZ
 declare enum MessageType {
   System = "system",
   JoinGroup = "joinGroup",
-  SendToGroup = "sendToGroup",
+  SendToGroup = "sendToGroup"
 }
 declare enum MessageDataType {
   Init = "init",
   Sync = "sync",
-  Awareness = "awareness",
+  Awareness = "awareness"
 }
 interface MessageData {
   payloadId?: string;
@@ -243,7 +952,8 @@ type WeaveStoreAzureWebPubsubSyncHostOptions = {
     checkIntervalMs: number;
     attemptsLimit: number;
   };
-}; //#endregion
+};
+//#endregion
 //#region src/client.d.ts
 declare class WeaveStoreAzureWebPubSubSyncClient extends Emittery {
   doc: Doc;
@@ -267,14 +977,14 @@ declare class WeaveStoreAzureWebPubSubSyncClient extends Emittery {
   private _updateHandler;
   private _awarenessUpdateHandler;
   /**
-  * @param {string} url
-  * @param {string} topic
-  * @param {Doc} doc
-  * @param {number} [options.resyncInterval] Request server state every `resyncInterval` milliseconds.
-  * @param {number} [options.tokenProvider] token generator for negotiation.
-  */
+   * @param {string} url
+   * @param {string} topic
+   * @param {Doc} doc
+   * @param {number} [options.resyncInterval] Request server state every `resyncInterval` milliseconds.
+   * @param {number} [options.tokenProvider] token generator for negotiation.
+   */
   constructor(instance: WeaveStoreAzureWebPubsub, url: string, topic: string, doc: Doc, options?: DeepPartial<WeaveStoreAzureWebPubSubSyncClientOptions>);
-  get awareness(): awarenessProtocol.Awareness;
+  get awareness(): Awareness;
   get synced(): boolean;
   set synced(state: boolean);
   get ws(): ReconnectingWebSocket | null;
@@ -291,7 +1001,6 @@ declare class WeaveStoreAzureWebPubSubSyncClient extends Emittery {
   private destroyCheckHeartbeat;
   connect(connectionUrlExtraParams?: Record<string, string>): Promise<void>;
 }
-
 //#endregion
 //#region src/store-azure-web-pubsub.d.ts
 declare class WeaveStoreAzureWebPubsub extends WeaveStore {
@@ -322,6 +1031,5 @@ declare class WeaveStoreAzureWebPubsub extends WeaveStore {
   handleAwarenessChange(emit?: boolean): void;
   setAwarenessInfo<T>(field: string, value: T): void;
 }
-
 //#endregion
 export { FetchClient, FetchInitialState, FetchRoom, IndexedDbOptions, Message, MessageData, MessageDataType, MessageHandler, MessageType, PersistRoom, WEAVE_STORE_AZURE_WEB_PUBSUB, WEAVE_STORE_AZURE_WEB_PUBSUB_CONNECTION_STATUS, WEAVE_STORE_AZURE_WEB_PUBSUB_DESTROY_ROOM_STATUS, WEAVE_STORE_AZURE_WEB_PUBSUB_SYNC_CLIENT_DEFAULT_OPTIONS, WEAVE_STORE_AZURE_WEB_PUBSUB_SYNC_HOST_DEFAULT_OPTIONS, WEAVE_STORE_HORIZONTAL_SYNC_HANDLER_CLIENT_TYPE, WeaveAzureWebPubsubSyncHandlerOptions, WeaveRoomData, WeaveStoreAzureWebPubSubSyncClientConnectionStatus, WeaveStoreAzureWebPubSubSyncClientConnectionStatusKeys, WeaveStoreAzureWebPubSubSyncClientOptions, WeaveStoreAzureWebPubSubSyncHostClientConnectOptions, WeaveStoreAzureWebPubsub, WeaveStoreAzureWebPubsubConfig, WeaveStoreAzureWebPubsubEvents, WeaveStoreAzureWebPubsubOnConnectEvent, WeaveStoreAzureWebPubsubOnConnectedEvent, WeaveStoreAzureWebPubsubOnDisconnectedEvent, WeaveStoreAzureWebPubsubOnStoreFetchConnectionUrlEvent, WeaveStoreAzureWebPubsubOnWebsocketCloseEvent, WeaveStoreAzureWebPubsubOnWebsocketErrorEvent, WeaveStoreAzureWebPubsubOnWebsocketJoinGroupEvent, WeaveStoreAzureWebPubsubOnWebsocketMessageEvent, WeaveStoreAzureWebPubsubOnWebsocketOpenEvent, WeaveStoreAzureWebPubsubOnWebsocketReconnectEvent, WeaveStoreAzureWebPubsubOptions, WeaveStoreAzureWebPubsubSyncHandlerDestroyRoomStatus, WeaveStoreAzureWebPubsubSyncHandlerDestroyRoomStatusKeys, WeaveStoreAzureWebPubsubSyncHostOptions };