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

package/dist/server.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import { WebPubSubServiceClient } from "@azure/web-pubsub";
 import { TokenCredential } from "@azure/identity";
 import * as Y from "yjs";
@@ -5,36 +6,701 @@ import { Doc } from "yjs";
 import { WebSocket } from "ws";
 import { WeaveStore } from "@inditextech/weave-sdk";
 import koa from "koa";
-import Emittery from "emittery";
 import ReconnectingWebSocket from "reconnecting-websocket";
-import * as awarenessProtocol$1 from "y-protocols/awareness";
-import * as awarenessProtocol from "y-protocols/awareness";
 import { DeepPartial, WeaveStoreOptions } from "@inditextech/weave-types";
-import { Encoder } from "lib0/encoding";
-import { Decoder } from "lib0/decoding";
-import express from "express-serve-static-core";
+import { SendOptions } from "send";
+import { EventEmitter } from "events";
+import * as http from "http";
+import { ParsedQs } from "qs";
+import { Options, Ranges, Result } from "range-parser";
 import { RequestHandler } from "express";
+//#region ../../node_modules/emittery/index.d.ts
+/**
+Emittery accepts strings, symbols, and numbers as event names.
+
+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;
+};
+/**
+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>;
+};
+/**
+Configuration options for Emittery.
+*/
+type Options$1<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 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$1<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 src/constants.d.ts
 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/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 src/store-azure-web-pubsub.d.ts
 declare class WeaveStoreAzureWebPubsub extends WeaveStore {
@@ -65,7 +731,6 @@ declare class WeaveStoreAzureWebPubsub extends WeaveStore {
   handleAwarenessChange(emit?: boolean): void;
   setAwarenessInfo<T>(field: string, value: T): void;
 }
-
 //#endregion
 //#region src/client.d.ts
 declare class WeaveStoreAzureWebPubSubSyncClient extends Emittery {
@@ -90,14 +755,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$1.Awareness;
+  get awareness(): Awareness;
   get synced(): boolean;
   set synced(state: boolean);
   get ws(): ReconnectingWebSocket | null;
@@ -114,7 +779,43 @@ declare class WeaveStoreAzureWebPubSubSyncClient extends Emittery {
   private destroyCheckHeartbeat;
   connect(connectionUrlExtraParams?: Record<string, string>): Promise<void>;
 }
-
+//#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 = {
@@ -139,9 +840,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 = {
@@ -214,12 +915,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;
@@ -259,810 +960,1793 @@ type WeaveStoreAzureWebPubsubSyncHostOptions = {
     attemptsLimit: 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 {}
+  }
+}
+interface NextFunction {
+  (err?: any): void;
+  /**
+   * "Break-out" of a router by calling {next('router')};
+   * @see {https://expressjs.com/en/guide/using-middleware.html#middleware.router}
+   */
+  (deferToNext: "router"): void;
+  /**
+   * "Break-out" of a route by calling {next('route')};
+   * @see {https://expressjs.com/en/guide/using-middleware.html#middleware.application}
+   */
+  (deferToNext: "route"): void;
+}
+interface ParamsDictionary {
+  [key: string]: string | string[];
+  [key: number]: string;
+}
+interface ParamsFlatDictionary {
+  [key: string | number]: string;
+}
+interface Locals extends Express.Locals {}
+interface RequestHandler$1<P = ParamsDictionary, ResBody = any, ReqBody = any, ReqQuery = ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>> {
+  // tslint:disable-next-line callable-types (This is extended from and can't extend from a type alias in ts<2.2)
+  (req: Request<P, ResBody, ReqBody, ReqQuery, LocalsObj>, res: Response$1<ResBody, LocalsObj>, next: NextFunction): unknown;
+}
+type ErrorRequestHandler<P = ParamsDictionary, ResBody = any, ReqBody = any, ReqQuery = ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>> = (err: any, req: Request<P, ResBody, ReqBody, ReqQuery, LocalsObj>, res: Response$1<ResBody, LocalsObj>, next: NextFunction) => unknown;
+type PathParams = string | RegExp | Array<string | RegExp>;
+type RequestHandlerParams<P = ParamsDictionary, ResBody = any, ReqBody = any, ReqQuery = ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>> = RequestHandler$1<P, ResBody, ReqBody, ReqQuery, LocalsObj> | ErrorRequestHandler<P, ResBody, ReqBody, ReqQuery, LocalsObj> | Array<RequestHandler$1<P> | ErrorRequestHandler<P>>;
+type RemoveTail<S extends string, Tail extends string> = S extends `${infer P}${Tail}` ? P : S;
+type GetRouteParameter<S extends string> = RemoveTail<RemoveTail<RemoveTail<S, `/${string}`>, `-${string}`>, `.${string}`>;
+// dprint-ignore
+type RouteParameters<Route extends string | RegExp> = Route extends string ? Route extends `${infer Required}{${infer Optional}}${infer Next}` ? ParseRouteParameters<Required> & Partial<ParseRouteParameters<Optional>> & RouteParameters<Next> : ParseRouteParameters<Route> : ParamsFlatDictionary;
+type ParseRouteParameters<Route extends string> = string extends Route ? ParamsDictionary : Route extends `${string}:${infer Rest}` ? (GetRouteParameter<Rest> extends never ? ParamsDictionary : { [P in GetRouteParameter<Rest>]: string; }) & (Rest extends `${GetRouteParameter<Rest>}${infer Next}` ? RouteParameters<Next> : unknown) : Route extends `${string}*${infer Rest}` ? (GetRouteParameter<Rest> extends never ? ParamsDictionary : { [P in GetRouteParameter<Rest>]: string[]; }) & (Rest extends `${GetRouteParameter<Rest>}${infer Next}` ? RouteParameters<Next> : unknown) : {};
+/* eslint-disable @definitelytyped/no-unnecessary-generics */
+interface IRouterMatcher<T, Method extends "all" | "get" | "post" | "put" | "delete" | "patch" | "options" | "head" | "query" = any> {
+  <Route extends string | RegExp, P = RouteParameters<Route>, ResBody = any, ReqBody = any, ReqQuery = ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>>(
+  // (it's used as the default type parameter for P)
+  path: Route,
+  // (This generic is meant to be passed explicitly.)
+  ...handlers: Array<RequestHandler$1<P, ResBody, ReqBody, ReqQuery, LocalsObj>>): T;
+  <Path extends string | RegExp, P = RouteParameters<Path>, ResBody = any, ReqBody = any, ReqQuery = ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>>(
+  // (it's used as the default type parameter for P)
+  path: Path,
+  // (This generic is meant to be passed explicitly.)
+  ...handlers: Array<RequestHandlerParams<P, ResBody, ReqBody, ReqQuery, LocalsObj>>): T;
+  <P = ParamsDictionary, ResBody = any, ReqBody = any, ReqQuery = ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>>(path: PathParams,
+  // (This generic is meant to be passed explicitly.)
+  ...handlers: Array<RequestHandler$1<P, ResBody, ReqBody, ReqQuery, LocalsObj>>): T;
+  <P = ParamsDictionary, ResBody = any, ReqBody = any, ReqQuery = ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>>(path: PathParams,
+  // (This generic is meant to be passed explicitly.)
+  ...handlers: Array<RequestHandlerParams<P, ResBody, ReqBody, ReqQuery, LocalsObj>>): T;
+  (path: PathParams, subApplication: Application): T;
+}
+interface IRouterHandler<T, Route extends string | RegExp = string> {
+  (...handlers: Array<RequestHandler$1<RouteParameters<Route>>>): T;
+  (...handlers: Array<RequestHandlerParams<RouteParameters<Route>>>): T;
+  <P = RouteParameters<Route>, ResBody = any, ReqBody = any, ReqQuery = ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>>(
+  // (This generic is meant to be passed explicitly.)
+  // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+  ...handlers: Array<RequestHandler$1<P, ResBody, ReqBody, ReqQuery, LocalsObj>>): T;
+  <P = RouteParameters<Route>, ResBody = any, ReqBody = any, ReqQuery = ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>>(
+  // (This generic is meant to be passed explicitly.)
+  // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+  ...handlers: Array<RequestHandlerParams<P, ResBody, ReqBody, ReqQuery, LocalsObj>>): T;
+  <P = ParamsDictionary, ResBody = any, ReqBody = any, ReqQuery = ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>>(
+  // (This generic is meant to be passed explicitly.)
+  // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+  ...handlers: Array<RequestHandler$1<P, ResBody, ReqBody, ReqQuery, LocalsObj>>): T;
+  <P = ParamsDictionary, ResBody = any, ReqBody = any, ReqQuery = ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>>(
+  // (This generic is meant to be passed explicitly.)
+  // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+  ...handlers: Array<RequestHandlerParams<P, ResBody, ReqBody, ReqQuery, LocalsObj>>): T;
+}
+/* eslint-enable @definitelytyped/no-unnecessary-generics */
+interface IRouter extends RequestHandler$1 {
+  /**
+   * Map the given param placeholder `name`(s) to the given callback(s).
+   *
+   * Parameter mapping is used to provide pre-conditions to routes
+   * which use normalized placeholders. For example a _:user_id_ parameter
+   * could automatically load a user's information from the database without
+   * any additional code,
+   *
+   * The callback uses the samesignature as middleware, the only differencing
+   * being that the value of the placeholder is passed, in this case the _id_
+   * of the user. Once the `next()` function is invoked, just like middleware
+   * it will continue on to execute the route, or subsequent parameter functions.
+   *
+   *      app.param('user_id', function(req, res, next, id){
+   *        User.find(id, function(err, user){
+   *          if (err) {
+   *            next(err);
+   *          } else if (user) {
+   *            req.user = user;
+   *            next();
+   *          } else {
+   *            next(new Error('failed to load user'));
+   *          }
+   *        });
+   *      });
+   */
+  param(name: string, handler: RequestParamHandler): this;
+  /**
+   * Special-cased "all" method, applying the given route `path`,
+   * middleware, and callback to _every_ HTTP method.
+   */
+  all: IRouterMatcher<this, "all">;
+  get: IRouterMatcher<this, "get">;
+  post: IRouterMatcher<this, "post">;
+  put: IRouterMatcher<this, "put">;
+  delete: IRouterMatcher<this, "delete">;
+  patch: IRouterMatcher<this, "patch">;
+  options: IRouterMatcher<this, "options">;
+  head: IRouterMatcher<this, "head">;
+  /**
+   * Requires Node.js >=20.19.3 <21 || >=22.2.0
+   * @see https://expressjs.com/en/5x/api/application/#appquery
+   */
+  query?: IRouterMatcher<this, "query">;
+  checkout: IRouterMatcher<this>;
+  connect: IRouterMatcher<this>;
+  copy: IRouterMatcher<this>;
+  lock: IRouterMatcher<this>;
+  merge: IRouterMatcher<this>;
+  mkactivity: IRouterMatcher<this>;
+  mkcol: IRouterMatcher<this>;
+  move: IRouterMatcher<this>;
+  "m-search": IRouterMatcher<this>;
+  notify: IRouterMatcher<this>;
+  propfind: IRouterMatcher<this>;
+  proppatch: IRouterMatcher<this>;
+  purge: IRouterMatcher<this>;
+  report: IRouterMatcher<this>;
+  search: IRouterMatcher<this>;
+  subscribe: IRouterMatcher<this>;
+  trace: IRouterMatcher<this>;
+  unlock: IRouterMatcher<this>;
+  unsubscribe: IRouterMatcher<this>;
+  link: IRouterMatcher<this>;
+  unlink: IRouterMatcher<this>;
+  use: IRouterHandler<this> & IRouterMatcher<this>;
+  route<T extends string | RegExp>(prefix: T): IRoute<T>;
+  route(prefix: PathParams): IRoute;
+  /**
+   * Stack of configured routes
+   */
+  stack: ILayer[];
+}
+interface ILayer {
+  route?: IRoute;
+  name: string | "<anonymous>";
+  params?: Record<string, any>;
+  keys: string[];
+  path?: string;
+  method: string;
+  regexp: RegExp;
+  handle: (req: Request, res: Response$1, next: NextFunction) => any;
+}
+interface IRoute<Route extends string | RegExp = string> {
+  path: string;
+  stack: ILayer[];
+  all: IRouterHandler<this, Route>;
+  get: IRouterHandler<this, Route>;
+  post: IRouterHandler<this, Route>;
+  put: IRouterHandler<this, Route>;
+  delete: IRouterHandler<this, Route>;
+  patch: IRouterHandler<this, Route>;
+  options: IRouterHandler<this, Route>;
+  head: IRouterHandler<this, Route>;
+  checkout: IRouterHandler<this, Route>;
+  copy: IRouterHandler<this, Route>;
+  lock: IRouterHandler<this, Route>;
+  merge: IRouterHandler<this, Route>;
+  mkactivity: IRouterHandler<this, Route>;
+  mkcol: IRouterHandler<this, Route>;
+  move: IRouterHandler<this, Route>;
+  "m-search": IRouterHandler<this, Route>;
+  notify: IRouterHandler<this, Route>;
+  purge: IRouterHandler<this, Route>;
+  report: IRouterHandler<this, Route>;
+  search: IRouterHandler<this, Route>;
+  subscribe: IRouterHandler<this, Route>;
+  trace: IRouterHandler<this, Route>;
+  unlock: IRouterHandler<this, Route>;
+  unsubscribe: IRouterHandler<this, Route>;
+}
+interface Router extends IRouter {}
+/**
+ * Options passed down into `res.cookie`
+ * @link https://expressjs.com/en/api.html#res.cookie
+ */
+interface CookieOptions {
+  /** Convenient option for setting the expiry time relative to the current time in **milliseconds**. */
+  maxAge?: number | undefined;
+  /** Indicates if the cookie should be signed. */
+  signed?: boolean | undefined;
+  /** Expiry date of the cookie in GMT. If not specified (undefined), creates a session cookie. */
+  expires?: Date | undefined;
+  /** Flags the cookie to be accessible only by the web server. */
+  httpOnly?: boolean | undefined;
+  /** Path for the cookie. Defaults to “/”. */
+  path?: string | undefined;
+  /** Domain name for the cookie. Defaults to the domain name of the app. */
+  domain?: string | undefined;
+  /** Marks the cookie to be used with HTTPS only. */
+  secure?: boolean | undefined;
+  /** A synchronous function used for cookie value encoding. Defaults to encodeURIComponent. */
+  encode?: ((val: string) => string) | undefined;
+  /**
+   * Value of the “SameSite” Set-Cookie attribute.
+   * @link https://tools.ietf.org/html/draft-ietf-httpbis-cookie-same-site-00#section-4.1.1.
+   */
+  sameSite?: boolean | "lax" | "strict" | "none" | undefined;
+  /**
+   * Value of the “Priority” Set-Cookie attribute.
+   * @link https://datatracker.ietf.org/doc/html/draft-west-cookie-priority-00#section-4.3
+   */
+  priority?: "low" | "medium" | "high";
+  /** Marks the cookie to use partioned storage. */
+  partitioned?: boolean | undefined;
+}
+type Errback = (err?: Error) => void;
+/**
+ * @param P  For most requests, this should be `ParamsDictionary`, but if you're
+ * using this in a route handler for a route that uses a `RegExp`, then `req.params`
+ * will only contains strings, in which case you should use `ParamsFlatDictionary` instead.
+ *
+ * @example
+ *     app.get('/user/:id', (req, res) => res.send(req.params.id)); // implicitly `ParamsDictionary`, parameter is string
+ *     app.get('/user/*id', (req, res) => res.send(req.params.id)); // implicitly `ParamsDictionary`, parameter is string[]
+ *     app.get(/user\/(?<id>.*)/, (req, res) => res.send(req.params.id)); // implicitly `ParamsFlatDictionary`, parameter is string
+ *     app.get(/user\/(.*)/, (req, res) => res.send(req.params[0])); // implicitly `ParamsFlatDictionary`, parameter is string
+ */
+interface Request<P = ParamsDictionary, ResBody = any, ReqBody = any, ReqQuery = ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>> extends http.IncomingMessage, Express.Request {
+  /**
+   * Return request header.
+   *
+   * The `Referrer` header field is special-cased,
+   * both `Referrer` and `Referer` are interchangeable.
+   *
+   * Examples:
+   *
+   *     req.get('Content-Type');
+   *     // => "text/plain"
+   *
+   *     req.get('content-type');
+   *     // => "text/plain"
+   *
+   *     req.get('Something');
+   *     // => undefined
+   *
+   * Aliased as `req.header()`.
+   */
+  get(name: "set-cookie"): string[] | undefined;
+  get(name: string): string | undefined;
+  header(name: "set-cookie"): string[] | undefined;
+  header(name: string): string | undefined;
+  /**
+   * Check if the given `type(s)` is acceptable, returning
+   * the best match when true, otherwise `undefined`, in which
+   * case you should respond with 406 "Not Acceptable".
+   *
+   * The `type` value may be a single mime type string
+   * such as "application/json", the extension name
+   * such as "json", a comma-delimted list such as "json, html, text/plain",
+   * or an array `["json", "html", "text/plain"]`. When a list
+   * or array is given the _best_ match, if any is returned.
+   *
+   * Examples:
+   *
+   *     // Accept: text/html
+   *     req.accepts('html');
+   *     // => "html"
+   *
+   *     // Accept: text/*, application/json
+   *     req.accepts('html');
+   *     // => "html"
+   *     req.accepts('text/html');
+   *     // => "text/html"
+   *     req.accepts('json, text');
+   *     // => "json"
+   *     req.accepts('application/json');
+   *     // => "application/json"
+   *
+   *     // Accept: text/*, application/json
+   *     req.accepts('image/png');
+   *     req.accepts('png');
+   *     // => false
+   *
+   *     // Accept: text/*;q=.5, application/json
+   *     req.accepts(['html', 'json']);
+   *     req.accepts('html, json');
+   *     // => "json"
+   */
+  accepts(): string[];
+  accepts(type: string): string | false;
+  accepts(type: string[]): string | false;
+  accepts(...type: string[]): string | false;
+  /**
+   * Returns the first accepted charset of the specified character sets,
+   * based on the request's Accept-Charset HTTP header field.
+   * If none of the specified charsets is accepted, returns false.
+   *
+   * For more information, or if you have issues or concerns, see accepts.
+   */
+  acceptsCharsets(): string[];
+  acceptsCharsets(charset: string): string | false;
+  acceptsCharsets(charset: string[]): string | false;
+  acceptsCharsets(...charset: string[]): string | false;
+  /**
+   * Returns the first accepted encoding of the specified encodings,
+   * based on the request's Accept-Encoding HTTP header field.
+   * If none of the specified encodings is accepted, returns false.
+   *
+   * For more information, or if you have issues or concerns, see accepts.
+   */
+  acceptsEncodings(): string[];
+  acceptsEncodings(encoding: string): string | false;
+  acceptsEncodings(encoding: string[]): string | false;
+  acceptsEncodings(...encoding: string[]): string | false;
+  /**
+   * Returns the first accepted language of the specified languages,
+   * based on the request's Accept-Language HTTP header field.
+   * If none of the specified languages is accepted, returns false.
+   *
+   * For more information, or if you have issues or concerns, see accepts.
+   */
+  acceptsLanguages(): string[];
+  acceptsLanguages(lang: string): string | false;
+  acceptsLanguages(lang: string[]): string | false;
+  acceptsLanguages(...lang: string[]): string | false;
+  /**
+   * Parse Range header field, capping to the given `size`.
+   *
+   * Unspecified ranges such as "0-" require knowledge of your resource length. In
+   * the case of a byte range this is of course the total number of bytes.
+   * If the Range header field is not given `undefined` is returned.
+   * If the Range header field is given, return value is a result of range-parser.
+   * See more ./types/range-parser/index.d.ts
+   *
+   * NOTE: remember that ranges are inclusive, so for example "Range: users=0-3"
+   * should respond with 4 users when available, not 3.
+   */
+  range(size: number, options?: Options): Ranges | Result | undefined;
+  /**
+   * Return an array of Accepted media types
+   * ordered from highest quality to lowest.
+   */
+  accepted: MediaType[];
+  /**
+   * Check if the incoming request contains the "Content-Type"
+   * header field, and it contains the give mime `type`.
+   *
+   * Examples:
+   *
+   *      // With Content-Type: text/html; charset=utf-8
+   *      req.is('html');
+   *      req.is('text/html');
+   *      req.is('text/*');
+   *      // => true
+   *
+   *      // When Content-Type is application/json
+   *      req.is('json');
+   *      req.is('application/json');
+   *      req.is('application/*');
+   *      // => true
+   *
+   *      req.is('html');
+   *      // => false
+   */
+  is(type: string | string[]): string | false | null;
+  /**
+   * Return the protocol string "http" or "https"
+   * when requested with TLS. When the "trust proxy"
+   * setting is enabled the "X-Forwarded-Proto" header
+   * field will be trusted. If you're running behind
+   * a reverse proxy that supplies https for you this
+   * may be enabled.
+   */
+  readonly protocol: string;
+  /**
+   * Short-hand for:
+   *
+   *    req.protocol == 'https'
+   */
+  readonly secure: boolean;
+  /**
+   * Return the remote address, or when
+   * "trust proxy" is `true` return
+   * the upstream addr.
+   *
+   * Value may be undefined if the `req.socket` is destroyed
+   * (for example, if the client disconnected).
+   */
+  readonly ip: string | undefined;
+  /**
+   * When "trust proxy" is `true`, parse
+   * the "X-Forwarded-For" ip address list.
+   *
+   * For example if the value were "client, proxy1, proxy2"
+   * you would receive the array `["client", "proxy1", "proxy2"]`
+   * where "proxy2" is the furthest down-stream.
+   */
+  readonly ips: string[];
+  /**
+   * Return subdomains as an array.
+   *
+   * Subdomains are the dot-separated parts of the host before the main domain of
+   * the app. By default, the domain of the app is assumed to be the last two
+   * parts of the host. This can be changed by setting "subdomain offset".
+   *
+   * For example, if the domain is "tobi.ferrets.example.com":
+   * If "subdomain offset" is not set, req.subdomains is `["ferrets", "tobi"]`.
+   * If "subdomain offset" is 3, req.subdomains is `["tobi"]`.
+   */
+  readonly subdomains: string[];
+  /**
+   * Short-hand for `url.parse(req.url).pathname`.
+   */
+  readonly path: string;
+  /**
+   * Contains the hostname derived from the `Host` HTTP header.
+   */
+  readonly hostname: string;
+  /**
+   * Contains the host derived from the `Host` HTTP header.
+   */
+  readonly host: string;
+  /**
+   * Check if the request is fresh, aka
+   * Last-Modified and/or the ETag
+   * still match.
+   */
+  readonly fresh: boolean;
+  /**
+   * Check if the request is stale, aka
+   * "Last-Modified" and / or the "ETag" for the
+   * resource has changed.
+   */
+  readonly stale: boolean;
+  /**
+   * Check if the request was an _XMLHttpRequest_.
+   */
+  readonly xhr: boolean;
+  // body: { username: string; password: string; remember: boolean; title: string; };
+  body: ReqBody;
+  // cookies: { string; remember: boolean; };
+  cookies: any;
+  method: string;
+  params: P;
+  query: ReqQuery;
+  route: any;
+  signedCookies: any;
+  originalUrl: string;
+  url: string;
+  baseUrl: string;
+  app: Application;
+  /**
+   * After middleware.init executed, Request will contain res and next properties
+   * See: express/lib/middleware/init.js
+   */
+  res?: Response$1<ResBody, LocalsObj> | undefined;
+  next?: NextFunction | undefined;
+}
+interface MediaType {
+  value: string;
+  quality: number;
+  type: string;
+  subtype: string;
+}
+type Send<ResBody = any, T = Response$1<ResBody>> = (body?: ResBody) => T;
+interface SendFileOptions extends SendOptions {
+  /** Object containing HTTP headers to serve with the file. */
+  headers?: Record<string, unknown>;
+}
+interface DownloadOptions extends SendOptions {
+  /** Object containing HTTP headers to serve with the file. The header `Content-Disposition` will be overridden by the filename argument. */
+  headers?: Record<string, unknown>;
+}
+interface Response$1<ResBody = any, LocalsObj extends Record<string, any> = Record<string, any>, StatusCode extends number = number> extends http.ServerResponse, Express.Response {
+  /**
+   * Set status `code`.
+   */
+  status(code: StatusCode): this;
+  /**
+   * Set the response HTTP status code to `statusCode` and send its string representation as the response body.
+   * @link http://expressjs.com/4x/api.html#res.sendStatus
+   *
+   * Examples:
+   *
+   *    res.sendStatus(200); // equivalent to res.status(200).send('OK')
+   *    res.sendStatus(403); // equivalent to res.status(403).send('Forbidden')
+   *    res.sendStatus(404); // equivalent to res.status(404).send('Not Found')
+   *    res.sendStatus(500); // equivalent to res.status(500).send('Internal Server Error')
+   */
+  sendStatus(code: StatusCode): this;
+  /**
+   * Set Link header field with the given `links`.
+   *
+   * Examples:
+   *
+   *    res.links({
+   *      next: 'http://api.example.com/users?page=2',
+   *      last: 'http://api.example.com/users?page=5'
+   *    });
+   */
+  links(links: any): this;
+  /**
+   * Send a response.
+   *
+   * Examples:
+   *
+   *     res.send(new Buffer('wahoo'));
+   *     res.send({ some: 'json' });
+   *     res.send('<p>some html</p>');
+   *     res.status(404).send('Sorry, cant find that');
+   */
+  send: Send<ResBody, this>;
+  /**
+   * Send JSON response.
+   *
+   * Examples:
+   *
+   *     res.json(null);
+   *     res.json({ user: 'tj' });
+   *     res.status(500).json('oh noes!');
+   *     res.status(404).json('I dont have that');
+   */
+  json: Send<ResBody, this>;
+  /**
+   * Send JSON response with JSONP callback support.
+   *
+   * Examples:
+   *
+   *     res.jsonp(null);
+   *     res.jsonp({ user: 'tj' });
+   *     res.status(500).jsonp('oh noes!');
+   *     res.status(404).jsonp('I dont have that');
+   */
+  jsonp: Send<ResBody, this>;
+  /**
+   * Transfer the file at the given `path`.
+   *
+   * Automatically sets the _Content-Type_ response header field.
+   * The callback `fn(err)` is invoked when the transfer is complete
+   * or when an error occurs. Be sure to check `res.headersSent`
+   * if you wish to attempt responding, as the header and some data
+   * may have already been transferred.
+   *
+   * Options:
+   *
+   *   - `maxAge`   defaulting to 0 (can be string converted by `ms`)
+   *   - `root`     root directory for relative filenames
+   *   - `headers`  object of headers to serve with file
+   *   - `dotfiles` serve dotfiles, defaulting to false; can be `"allow"` to send them
+   *
+   * Other options are passed along to `send`.
+   *
+   * Examples:
+   *
+   *  The following example illustrates how `res.sendFile()` may
+   *  be used as an alternative for the `static()` middleware for
+   *  dynamic situations. The code backing `res.sendFile()` is actually
+   *  the same code, so HTTP cache support etc is identical.
+   *
+   *     app.get('/user/:uid/photos/:file', function(req, res){
+   *       var uid = req.params.uid
+   *         , file = req.params.file;
+   *
+   *       req.user.mayViewFilesFrom(uid, function(yes){
+   *         if (yes) {
+   *           res.sendFile('/uploads/' + uid + '/' + file);
+   *         } else {
+   *           res.send(403, 'Sorry! you cant see that.');
+   *         }
+   *       });
+   *     });
+   *
+   * @api public
+   */
+  sendFile(path: string, fn?: Errback): void;
+  sendFile(path: string, options: SendFileOptions, fn?: Errback): void;
+  /**
+   * Transfer the file at the given `path` as an attachment.
+   *
+   * Optionally providing an alternate attachment `filename`,
+   * and optional callback `fn(err)`. The callback is invoked
+   * when the data transfer is complete, or when an error has
+   * ocurred. Be sure to check `res.headersSent` if you plan to respond.
+   *
+   * The optional options argument passes through to the underlying
+   * res.sendFile() call, and takes the exact same parameters.
+   *
+   * This method uses `res.sendFile()`.
+   */
+  download(path: string, fn?: Errback): void;
+  download(path: string, filename: string, fn?: Errback): void;
+  download(path: string, filename: string, options: DownloadOptions, fn?: Errback): void;
+  /**
+   * Set _Content-Type_ response header with `type` through `mime.lookup()`
+   * when it does not contain "/", or set the Content-Type to `type` otherwise.
+   *
+   * Examples:
+   *
+   *     res.type('.html');
+   *     res.type('html');
+   *     res.type('json');
+   *     res.type('application/json');
+   *     res.type('png');
+   */
+  contentType(type: string): this;
+  /**
+   * Set _Content-Type_ response header with `type` through `mime.lookup()`
+   * when it does not contain "/", or set the Content-Type to `type` otherwise.
+   *
+   * Examples:
+   *
+   *     res.type('.html');
+   *     res.type('html');
+   *     res.type('json');
+   *     res.type('application/json');
+   *     res.type('png');
+   */
+  type(type: string): this;
+  /**
+   * Respond to the Acceptable formats using an `obj`
+   * of mime-type callbacks.
+   *
+   * This method uses `req.accepted`, an array of
+   * acceptable types ordered by their quality values.
+   * When "Accept" is not present the _first_ callback
+   * is invoked, otherwise the first match is used. When
+   * no match is performed the server responds with
+   * 406 "Not Acceptable".
+   *
+   * Content-Type is set for you, however if you choose
+   * you may alter this within the callback using `res.type()`
+   * or `res.set('Content-Type', ...)`.
+   *
+   *    res.format({
+   *      'text/plain': function(){
+   *        res.send('hey');
+   *      },
+   *
+   *      'text/html': function(){
+   *        res.send('<p>hey</p>');
+   *      },
+   *
+   *      'appliation/json': function(){
+   *        res.send({ message: 'hey' });
+   *      }
+   *    });
+   *
+   * In addition to canonicalized MIME types you may
+   * also use extnames mapped to these types:
+   *
+   *    res.format({
+   *      text: function(){
+   *        res.send('hey');
+   *      },
+   *
+   *      html: function(){
+   *        res.send('<p>hey</p>');
+   *      },
+   *
+   *      json: function(){
+   *        res.send({ message: 'hey' });
+   *      }
+   *    });
+   *
+   * By default Express passes an `Error`
+   * with a `.status` of 406 to `next(err)`
+   * if a match is not made. If you provide
+   * a `.default` callback it will be invoked
+   * instead.
+   */
+  format(obj: any): this;
+  /**
+   * Set _Content-Disposition_ header to _attachment_ with optional `filename`.
+   */
+  attachment(filename?: string): this;
+  /**
+   * Set header `field` to `val`, or pass
+   * an object of header fields.
+   *
+   * Examples:
+   *
+   *    res.set('Foo', ['bar', 'baz']);
+   *    res.set('Accept', 'application/json');
+   *    res.set({ Accept: 'text/plain', 'X-API-Key': 'tobi' });
+   *
+   * Aliased as `res.header()`.
+   */
+  set(field: any): this;
+  set(field: string, value?: string | string[]): this;
+  header(field: any): this;
+  header(field: string, value?: string | string[]): this;
+  // Property indicating if HTTP headers has been sent for the response.
+  headersSent: boolean;
+  /** Get value for header `field`. */
+  get(field: string): string | undefined;
+  /** Clear cookie `name`. */
+  clearCookie(name: string, options?: CookieOptions): this;
+  /**
+   * Set cookie `name` to `val`, with the given `options`.
+   *
+   * Options:
+   *
+   *    - `maxAge`   max-age in milliseconds, converted to `expires`
+   *    - `signed`   sign the cookie
+   *    - `path`     defaults to "/"
+   *
+   * Examples:
+   *
+   *    // "Remember Me" for 15 minutes
+   *    res.cookie('rememberme', '1', { expires: new Date(Date.now() + 900000), httpOnly: true });
+   *
+   *    // save as above
+   *    res.cookie('rememberme', '1', { maxAge: 900000, httpOnly: true })
+   */
+  cookie(name: string, val: string, options: CookieOptions): this;
+  cookie(name: string, val: any, options: CookieOptions): this;
+  cookie(name: string, val: any): this;
+  /**
+   * Set the location header to `url`.
+   *
+   * Examples:
+   *
+   *    res.location('/foo/bar').;
+   *    res.location('http://example.com');
+   *    res.location('../login'); // /blog/post/1 -> /blog/login
+   *
+   * Mounting:
+   *
+   *   When an application is mounted and `res.location()`
+   *   is given a path that does _not_ lead with "/" it becomes
+   *   relative to the mount-point. For example if the application
+   *   is mounted at "/blog", the following would become "/blog/login".
+   *
+   *      res.location('login');
+   *
+   *   While the leading slash would result in a location of "/login":
+   *
+   *      res.location('/login');
+   */
+  location(url: string): this;
+  /**
+   * Redirect to the given `url` with optional response `status`
+   * defaulting to 302.
+   *
+   * The resulting `url` is determined by `res.location()`, so
+   * it will play nicely with mounted apps, relative paths, etc.
+   *
+   * Examples:
+   *
+   *    res.redirect('/foo/bar');
+   *    res.redirect('http://example.com');
+   *    res.redirect(301, 'http://example.com');
+   *    res.redirect('../login'); // /blog/post/1 -> /blog/login
+   */
+  redirect(url: string): void;
+  redirect(status: number, url: string): void;
+  /**
+   * Render `view` with the given `options` and optional callback `fn`.
+   * When a callback function is given a response will _not_ be made
+   * automatically, otherwise a response of _200_ and _text/html_ is given.
+   *
+   * Options:
+   *
+   *  - `cache`     boolean hinting to the engine it should cache
+   *  - `filename`  filename of the view being rendered
+   */
+  render(view: string, options?: object, callback?: (err: Error, html: string) => void): void;
+  render(view: string, callback?: (err: Error, html: string) => void): void;
+  locals: LocalsObj & Locals;
+  charset: string;
+  /**
+   * Adds the field to the Vary response header, if it is not there already.
+   * Examples:
+   *
+   *     res.vary('User-Agent').render('docs');
+   */
+  vary(field: string): this;
+  app: Application;
+  /**
+   * Appends the specified value to the HTTP response header field.
+   * If the header is not already set, it creates the header with the specified value.
+   * The value parameter can be a string or an array.
+   *
+   * Note: calling res.set() after res.append() will reset the previously-set header value.
+   *
+   * @since 4.11.0
+   */
+  append(field: string, value?: string[] | string): this;
+  /**
+   * After middleware.init executed, Response will contain req property
+   * See: express/lib/middleware/init.js
+   */
+  req: Request;
+}
+type RequestParamHandler = (req: Request, res: Response$1, next: NextFunction, value: any, name: string) => any;
+type ApplicationRequestHandler<T> = IRouterHandler<T> & IRouterMatcher<T> & ((...handlers: RequestHandlerParams[]) => T);
+interface Application<LocalsObj extends Record<string, any> = Record<string, any>> extends EventEmitter, IRouter, Express.Application {
+  /**
+   * Express instance itself is a request handler, which could be invoked without
+   * third argument.
+   */
+  (req: Request | http.IncomingMessage, res: Response$1 | http.ServerResponse): any;
+  /**
+   * Initialize the server.
+   *
+   *   - setup default configuration
+   *   - setup default middleware
+   *   - setup route reflection methods
+   */
+  init(): void;
+  /**
+   * Initialize application configuration.
+   */
+  defaultConfiguration(): void;
+  /**
+   * Register the given template engine callback `fn`
+   * as `ext`.
+   *
+   * By default will `require()` the engine based on the
+   * file extension. For example if you try to render
+   * a "foo.jade" file Express will invoke the following internally:
+   *
+   *     app.engine('jade', require('jade').__express);
+   *
+   * For engines that do not provide `.__express` out of the box,
+   * or if you wish to "map" a different extension to the template engine
+   * you may use this method. For example mapping the EJS template engine to
+   * ".html" files:
+   *
+   *     app.engine('html', require('ejs').renderFile);
+   *
+   * In this case EJS provides a `.renderFile()` method with
+   * the same signature that Express expects: `(path, options, callback)`,
+   * though note that it aliases this method as `ejs.__express` internally
+   * so if you're using ".ejs" extensions you dont need to do anything.
+   *
+   * Some template engines do not follow this convention, the
+   * [Consolidate.js](https://github.com/visionmedia/consolidate.js)
+   * library was created to map all of node's popular template
+   * engines to follow this convention, thus allowing them to
+   * work seamlessly within Express.
+   */
+  engine(ext: string, fn: (path: string, options: object, callback: (e: any, rendered?: string) => void) => void): this;
+  /**
+   * Assign `setting` to `val`, or return `setting`'s value.
+   *
+   *    app.set('foo', 'bar');
+   *    app.get('foo');
+   *    // => "bar"
+   *    app.set('foo', ['bar', 'baz']);
+   *    app.get('foo');
+   *    // => ["bar", "baz"]
+   *
+   * Mounted servers inherit their parent server's settings.
+   */
+  set(setting: string, val: any): this;
+  get: ((name: string) => any) & IRouterMatcher<this>;
+  param(name: string | string[], handler: RequestParamHandler): this;
+  /**
+   * Return the app's absolute pathname
+   * based on the parent(s) that have
+   * mounted it.
+   *
+   * For example if the application was
+   * mounted as "/admin", which itself
+   * was mounted as "/blog" then the
+   * return value would be "/blog/admin".
+   */
+  path(): string;
+  /**
+   * Check if `setting` is enabled (truthy).
+   *
+   *    app.enabled('foo')
+   *    // => false
+   *
+   *    app.enable('foo')
+   *    app.enabled('foo')
+   *    // => true
+   */
+  enabled(setting: string): boolean;
+  /**
+   * Check if `setting` is disabled.
+   *
+   *    app.disabled('foo')
+   *    // => true
+   *
+   *    app.enable('foo')
+   *    app.disabled('foo')
+   *    // => false
+   */
+  disabled(setting: string): boolean;
+  /** Enable `setting`. */
+  enable(setting: string): this;
+  /** Disable `setting`. */
+  disable(setting: string): this;
+  /**
+   * Render the given view `name` name with `options`
+   * and a callback accepting an error and the
+   * rendered template string.
+   *
+   * Example:
+   *
+   *    app.render('email', { name: 'Tobi' }, function(err, html){
+   *      // ...
+   *    })
+   */
+  render(name: string, options?: object, callback?: (err: Error, html: string) => void): void;
+  render(name: string, callback: (err: Error, html: string) => void): void;
+  /**
+   * Listen for connections.
+   *
+   * A node `http.Server` is returned, with this
+   * application (which is a `Function`) as its
+   * callback. If you wish to create both an HTTP
+   * and HTTPS server you may do so with the "http"
+   * and "https" modules as shown here:
+   *
+   *    var http = require('http')
+   *      , https = require('https')
+   *      , express = require('express')
+   *      , app = express();
+   *
+   *    http.createServer(app).listen(80);
+   *    https.createServer({ ... }, app).listen(443);
+   */
+  listen(port: number, hostname: string, backlog: number, callback?: (error?: Error) => void): http.Server;
+  listen(port: number, hostname: string, callback?: (error?: Error) => void): http.Server;
+  listen(port: number, callback?: (error?: Error) => void): http.Server;
+  listen(callback?: (error?: Error) => void): http.Server;
+  listen(path: string, callback?: (error?: Error) => void): http.Server;
+  listen(handle: any, listeningListener?: (error?: Error) => void): http.Server;
+  router: Router;
+  settings: any;
+  resource: any;
+  map: any;
+  locals: LocalsObj & Locals;
+  /**
+   * The app.routes object houses all of the routes defined mapped by the
+   * associated HTTP verb. This object may be used for introspection
+   * capabilities, for example Express uses this internally not only for
+   * routing but to provide default OPTIONS behaviour unless app.options()
+   * is used. Your application or framework may also remove routes by
+   * simply by removing them from this object.
+   */
+  routes: any;
+  /**
+   * Used to get all registered routes in Express Application
+   */
+  _router: any;
+  use: ApplicationRequestHandler<this>;
+  /**
+   * The mount event is fired on a sub-app, when it is mounted on a parent app.
+   * The parent app is passed to the callback function.
+   *
+   * NOTE:
+   * Sub-apps will:
+   *  - Not inherit the value of settings that have a default value. You must set the value in the sub-app.
+   *  - Inherit the value of settings with no default value.
+   */
+  on: (event: "mount", callback: (parent: Application) => void) => this;
+  /**
+   * The app.mountpath property contains one or more path patterns on which a sub-app was mounted.
+   */
+  mountpath: string | string[];
+}
+interface Express extends Application {
+  request: Request;
+  response: Response$1;
+}
 //#endregion
 //#region src/server/event-handler/enum/mqtt-error-codes/mqtt-disconnect-reason-code.d.ts
 /**
-* MQTT 5.0 Disconnect Reason Codes.
-*/
+ * MQTT 5.0 Disconnect Reason Codes.
+ */
 declare enum MqttDisconnectReasonCode {
   /**
-  * 0x00 - Normal disconnection
-  * Sent by: Client or Server
-  * Description: Close the connection normally. Do not send the Will Message.
-  */
+   * 0x00 - Normal disconnection
+   * Sent by: Client or Server
+   * Description: Close the connection normally. Do not send the Will Message.
+   */
   NormalDisconnection = 0,
   /**
-  * 0x04 - Disconnect with Will Message
-  * Sent by: Client
-  * Description: The Client wishes to disconnect but requires that the Server also publishes its Will Message.
-  */
+   * 0x04 - Disconnect with Will Message
+   * Sent by: Client
+   * Description: The Client wishes to disconnect but requires that the Server also publishes its Will Message.
+   */
   DisconnectWithWillMessage = 4,
   /**
-  * 0x80 - Unspecified error
-  * Sent by: Client or Server
-  * Description: The Connection is closed but the sender either does not wish to reveal the reason, or none of the other Reason Codes apply.
-  */
+   * 0x80 - Unspecified error
+   * Sent by: Client or Server
+   * Description: The Connection is closed but the sender either does not wish to reveal the reason, or none of the other Reason Codes apply.
+   */
   UnspecifiedError = 128,
   /**
-  * 0x81 - Malformed Packet
-  * Sent by: Client or Server
-  * Description: The received packet does not conform to this specification.
-  */
+   * 0x81 - Malformed Packet
+   * Sent by: Client or Server
+   * Description: The received packet does not conform to this specification.
+   */
   MalformedPacket = 129,
   /**
-  * 0x82 - Protocol Error
-  * Sent by: Client or Server
-  * Description: An unexpected or out of order packet was received.
-  */
+   * 0x82 - Protocol Error
+   * Sent by: Client or Server
+   * Description: An unexpected or out of order packet was received.
+   */
   ProtocolError = 130,
   /**
-  * 0x83 - Implementation specific error
-  * Sent by: Client or Server
-  * Description: The packet received is valid but cannot be processed by this implementation.
-  */
+   * 0x83 - Implementation specific error
+   * Sent by: Client or Server
+   * Description: The packet received is valid but cannot be processed by this implementation.
+   */
   ImplementationSpecificError = 131,
   /**
-  * 0x87 - Not authorized
-  * Sent by: Server
-  * Description: The request is not authorized.
-  */
+   * 0x87 - Not authorized
+   * Sent by: Server
+   * Description: The request is not authorized.
+   */
   NotAuthorized = 135,
   /**
-  * 0x89 - Server busy
-  * Sent by: Server
-  * Description: The Server is busy and cannot continue processing requests from this Client.
-  */
+   * 0x89 - Server busy
+   * Sent by: Server
+   * Description: The Server is busy and cannot continue processing requests from this Client.
+   */
   ServerBusy = 137,
   /**
-  * 0x8B - Server shutting down
-  * Sent by: Server
-  * Description: The Server is shutting down.
-  */
+   * 0x8B - Server shutting down
+   * Sent by: Server
+   * Description: The Server is shutting down.
+   */
   ServerShuttingDown = 139,
   /**
-  * 0x8D - Keep Alive timeout
-  * Sent by: Server
-  * Description: The Connection is closed because no packet has been received for 1.5 times the Keepalive time.
-  */
+   * 0x8D - Keep Alive timeout
+   * Sent by: Server
+   * Description: The Connection is closed because no packet has been received for 1.5 times the Keepalive time.
+   */
   KeepAliveTimeout = 141,
   /**
-  * 0x8E - Session taken over
-  * Sent by: Server
-  * Description: Another Connection using the same ClientID has connected causing this Connection to be closed.
-  */
+   * 0x8E - Session taken over
+   * Sent by: Server
+   * Description: Another Connection using the same ClientID has connected causing this Connection to be closed.
+   */
   SessionTakenOver = 142,
   /**
-  * 0x8F - Topic Filter invalid
-  * Sent by: Server
-  * Description: The Topic Filter is correctly formed, but is not accepted by this Server.
-  */
+   * 0x8F - Topic Filter invalid
+   * Sent by: Server
+   * Description: The Topic Filter is correctly formed, but is not accepted by this Server.
+   */
   TopicFilterInvalid = 143,
   /**
-  * 0x90 - Topic Name invalid
-  * Sent by: Client or Server
-  * Description: The Topic Name is correctly formed, but is not accepted by this Client or Server.
-  */
+   * 0x90 - Topic Name invalid
+   * Sent by: Client or Server
+   * Description: The Topic Name is correctly formed, but is not accepted by this Client or Server.
+   */
   TopicNameInvalid = 144,
   /**
-  * 0x93 - Receive Maximum exceeded
-  * Sent by: Client or Server
-  * Description: The Client or Server has received more than Receive Maximum publication for which it has not sent PUBACK or PUBCOMP.
-  */
+   * 0x93 - Receive Maximum exceeded
+   * Sent by: Client or Server
+   * Description: The Client or Server has received more than Receive Maximum publication for which it has not sent PUBACK or PUBCOMP.
+   */
   ReceiveMaximumExceeded = 147,
   /**
-  * 0x94 - Topic Alias invalid
-  * Sent by: Client or Server
-  * Description: The Client or Server has received a PUBLISH packet containing a Topic Alias which is greater than the Maximum Topic Alias it sent in the CONNECT or CONNACK packet.
-  */
+   * 0x94 - Topic Alias invalid
+   * Sent by: Client or Server
+   * Description: The Client or Server has received a PUBLISH packet containing a Topic Alias which is greater than the Maximum Topic Alias it sent in the CONNECT or CONNACK packet.
+   */
   TopicAliasInvalid = 148,
   /**
-  * 0x95 - Packet too large
-  * Sent by: Client or Server
-  * Description: The packet size is greater than Maximum Packet Size for this Client or Server.
-  */
+   * 0x95 - Packet too large
+   * Sent by: Client or Server
+   * Description: The packet size is greater than Maximum Packet Size for this Client or Server.
+   */
   PacketTooLarge = 149,
   /**
-  * 0x96 - Message rate too high
-  * Sent by: Client or Server
-  * Description: The received data rate is too high.
-  */
+   * 0x96 - Message rate too high
+   * Sent by: Client or Server
+   * Description: The received data rate is too high.
+   */
   MessageRateTooHigh = 150,
   /**
-  * 0x97 - Quota exceeded
-  * Sent by: Client or Server
-  * Description: An implementation or administrative imposed limit has been exceeded.
-  */
+   * 0x97 - Quota exceeded
+   * Sent by: Client or Server
+   * Description: An implementation or administrative imposed limit has been exceeded.
+   */
   QuotaExceeded = 151,
   /**
-  * 0x98 - Administrative action
-  * Sent by: Client or Server
-  * Description: The Connection is closed due to an administrative action.
-  */
+   * 0x98 - Administrative action
+   * Sent by: Client or Server
+   * Description: The Connection is closed due to an administrative action.
+   */
   AdministrativeAction = 152,
   /**
-  * 0x99 - Payload format invalid
-  * Sent by: Client or Server
-  * Description: The payload format does not match the one specified by the Payload Format Indicator.
-  */
+   * 0x99 - Payload format invalid
+   * Sent by: Client or Server
+   * Description: The payload format does not match the one specified by the Payload Format Indicator.
+   */
   PayloadFormatInvalid = 153,
   /**
-  * 0x9A - Retain not supported
-  * Sent by: Server
-  * Description: The Server does not support retained messages.
-  */
+   * 0x9A - Retain not supported
+   * Sent by: Server
+   * Description: The Server does not support retained messages.
+   */
   RetainNotSupported = 154,
   /**
-  * 0x9B - QoS not supported
-  * Sent by: Server
-  * Description: The Client specified a QoS greater than the QoS specified in a Maximum QoS in the CONNACK.
-  */
+   * 0x9B - QoS not supported
+   * Sent by: Server
+   * Description: The Client specified a QoS greater than the QoS specified in a Maximum QoS in the CONNACK.
+   */
   QosNotSupported = 155,
   /**
-  * 0x9C - Use another server
-  * Sent by: Server
-  * Description: The Client should temporarily change its Server.
-  */
+   * 0x9C - Use another server
+   * Sent by: Server
+   * Description: The Client should temporarily change its Server.
+   */
   UseAnotherServer = 156,
   /**
-  * 0x9D - Server moved
-  * Sent by: Server
-  * Description: The Server is moved and the Client should permanently change its server location.
-  */
+   * 0x9D - Server moved
+   * Sent by: Server
+   * Description: The Server is moved and the Client should permanently change its server location.
+   */
   ServerMoved = 157,
   /**
-  * 0x9E - Shared Subscriptions not supported
-  * Sent by: Server
-  * Description: The Server does not support Shared Subscriptions.
-  */
+   * 0x9E - Shared Subscriptions not supported
+   * Sent by: Server
+   * Description: The Server does not support Shared Subscriptions.
+   */
   SharedSubscriptionsNotSupported = 158,
   /**
-  * 0x9F - Connection rate exceeded
-  * Sent by: Server
-  * Description: This connection is closed because the connection rate is too high.
-  */
+   * 0x9F - Connection rate exceeded
+   * Sent by: Server
+   * Description: This connection is closed because the connection rate is too high.
+   */
   ConnectionRateExceeded = 159,
   /**
-  * 0xA0 - Maximum connect time
-  * Sent by: Server
-  * Description: The maximum connection time authorized for this connection has been exceeded.
-  */
+   * 0xA0 - Maximum connect time
+   * Sent by: Server
+   * Description: The maximum connection time authorized for this connection has been exceeded.
+   */
   MaximumConnectTime = 160,
   /**
-  * 0xA1 - Subscription Identifiers not supported
-  * Sent by: Server
-  * Description: The Server does not support Subscription Identifiers; the subscription is not accepted.
-  */
+   * 0xA1 - Subscription Identifiers not supported
+   * Sent by: Server
+   * Description: The Server does not support Subscription Identifiers; the subscription is not accepted.
+   */
   SubscriptionIdentifiersNotSupported = 161,
   /**
-  * 0xA2 - Wildcard Subscriptions not supported
-  * Sent by: Server
-  * Description: The Server does not support Wildcard Subscriptions; the subscription is not accepted.
-  */
-  WildcardSubscriptionsNotSupported = 162,
+   * 0xA2 - Wildcard Subscriptions not supported
+   * Sent by: Server
+   * Description: The Server does not support Wildcard Subscriptions; the subscription is not accepted.
+   */
+  WildcardSubscriptionsNotSupported = 162
 }
-
 //#endregion
 //#region src/server/event-handler/enum/mqtt-error-codes/mqtt-v311-connect-return-code.d.ts
 /**
-* MQTT 3.1.1 Connect Return Codes.
-*/
+ * MQTT 3.1.1 Connect Return Codes.
+ */
 declare enum MqttV311ConnectReturnCode {
   /**
-  * 0x01: Connection refused, unacceptable protocol version
-  * The Server does not support the level of the MQTT protocol requested by the Client.
-  */
+   * 0x01: Connection refused, unacceptable protocol version
+   * The Server does not support the level of the MQTT protocol requested by the Client.
+   */
   UnacceptableProtocolVersion = 1,
   /**
-  * 0x02: Connection refused, identifier rejected
-  * The Client identifier is correct UTF-8 but not allowed by the Server.
-  */
+   * 0x02: Connection refused, identifier rejected
+   * The Client identifier is correct UTF-8 but not allowed by the Server.
+   */
   IdentifierRejected = 2,
   /**
-  * 0x03: Connection refused, server unavailable
-  * The Network Connection has been made but the MQTT service is unavailable.
-  */
+   * 0x03: Connection refused, server unavailable
+   * The Network Connection has been made but the MQTT service is unavailable.
+   */
   ServerUnavailable = 3,
   /**
-  * 0x04: Connection refused, bad user name or password
-  * The data in the user name or password is malformed.
-  */
+   * 0x04: Connection refused, bad user name or password
+   * The data in the user name or password is malformed.
+   */
   BadUsernameOrPassword = 4,
   /**
-  * 0x05: Connection refused, not authorized
-  * The Client is not authorized to connect.
-  */
-  NotAuthorized = 5,
+   * 0x05: Connection refused, not authorized
+   * The Client is not authorized to connect.
+   */
+  NotAuthorized = 5
 }
-
 //#endregion
 //#region src/server/event-handler/enum/mqtt-error-codes/mqtt-v500-connect-reason-code.d.ts
 /**
-* MQTT Connect Reason Codes
-* These codes represent the reasons for the outcome of an MQTT CONNECT packet as per MQTT 5.0 specification.
-*/
+ * MQTT Connect Reason Codes
+ * These codes represent the reasons for the outcome of an MQTT CONNECT packet as per MQTT 5.0 specification.
+ */
 declare enum MqttV500ConnectReasonCode {
   /**
-  * 0x80 - Unspecified error
-  * Description: The Server does not wish to reveal the reason for the failure, or none of the other Reason Codes apply.
-  */
+   * 0x80 - Unspecified error
+   * Description: The Server does not wish to reveal the reason for the failure, or none of the other Reason Codes apply.
+   */
   UnspecifiedError = 128,
   /**
-  * 0x81 - Malformed Packet
-  * Description: Data within the CONNECT packet could not be correctly parsed.
-  */
+   * 0x81 - Malformed Packet
+   * Description: Data within the CONNECT packet could not be correctly parsed.
+   */
   MalformedPacket = 129,
   /**
-  * 0x82 - Protocol Error
-  * Description: Data in the CONNECT packet does not conform to this specification.
-  */
+   * 0x82 - Protocol Error
+   * Description: Data in the CONNECT packet does not conform to this specification.
+   */
   ProtocolError = 130,
   /**
-  * 0x83 - Implementation specific error
-  * Description: The CONNECT is valid but is not accepted by this Server.
-  */
+   * 0x83 - Implementation specific error
+   * Description: The CONNECT is valid but is not accepted by this Server.
+   */
   ImplementationSpecificError = 131,
   /**
-  * 0x84 - Unsupported Protocol Version
-  * Description: The Server does not support the version of the MQTT protocol requested by the Client.
-  */
+   * 0x84 - Unsupported Protocol Version
+   * Description: The Server does not support the version of the MQTT protocol requested by the Client.
+   */
   UnsupportedProtocolVersion = 132,
   /**
-  * 0x85 - Client Identifier not valid
-  * Description: The Client Identifier is a valid string but is not allowed by the Server.
-  */
+   * 0x85 - Client Identifier not valid
+   * Description: The Client Identifier is a valid string but is not allowed by the Server.
+   */
   ClientIdentifierNotValid = 133,
   /**
-  * 0x86 - Bad User Name or Password
-  * Description: The Server does not accept the User Name or Password specified by the Client.
-  */
+   * 0x86 - Bad User Name or Password
+   * Description: The Server does not accept the User Name or Password specified by the Client.
+   */
   BadUserNameOrPassword = 134,
   /**
-  * 0x87 - Not authorized
-  * Description: The Client is not authorized to connect.
-  */
+   * 0x87 - Not authorized
+   * Description: The Client is not authorized to connect.
+   */
   NotAuthorized = 135,
   /**
-  * 0x88 - Server unavailable
-  * Description: The MQTT Server is not available.
-  */
+   * 0x88 - Server unavailable
+   * Description: The MQTT Server is not available.
+   */
   ServerUnavailable = 136,
   /**
-  * 0x89 - Server busy
-  * Description: The Server is busy. Try again later.
-  */
+   * 0x89 - Server busy
+   * Description: The Server is busy. Try again later.
+   */
   ServerBusy = 137,
   /**
-  * 0x8A - Banned
-  * Description: This Client has been banned by administrative action. Contact the server administrator.
-  */
+   * 0x8A - Banned
+   * Description: This Client has been banned by administrative action. Contact the server administrator.
+   */
   Banned = 138,
   /**
-  * 0x8C - Bad authentication method
-  * Description: The authentication method is not supported or does not match the authentication method currently in use.
-  */
+   * 0x8C - Bad authentication method
+   * Description: The authentication method is not supported or does not match the authentication method currently in use.
+   */
   BadAuthenticationMethod = 140,
   /**
-  * 0x90 - Topic Name invalid
-  * Description: The Will Topic Name is not malformed, but is not accepted by this Server.
-  */
+   * 0x90 - Topic Name invalid
+   * Description: The Will Topic Name is not malformed, but is not accepted by this Server.
+   */
   TopicNameInvalid = 144,
   /**
-  * 0x95 - Packet too large
-  * Description: The CONNECT packet exceeded the maximum permissible size.
-  */
+   * 0x95 - Packet too large
+   * Description: The CONNECT packet exceeded the maximum permissible size.
+   */
   PacketTooLarge = 149,
   /**
-  * 0x97 - Quota exceeded
-  * Description: An implementation or administrative imposed limit has been exceeded.
-  */
+   * 0x97 - Quota exceeded
+   * Description: An implementation or administrative imposed limit has been exceeded.
+   */
   QuotaExceeded = 151,
   /**
-  * 0x99 - Payload format invalid
-  * Description: The Will Payload does not match the specified Payload Format Indicator.
-  */
+   * 0x99 - Payload format invalid
+   * Description: The Will Payload does not match the specified Payload Format Indicator.
+   */
   PayloadFormatInvalid = 153,
   /**
-  * 0x9A - Retain not supported
-  * Description: The Server does not support retained messages, and Will Retain was set to 1.
-  */
+   * 0x9A - Retain not supported
+   * Description: The Server does not support retained messages, and Will Retain was set to 1.
+   */
   RetainNotSupported = 154,
   /**
-  * 0x9B - QoS not supported
-  * Description: The Server does not support the QoS set in Will QoS.
-  */
+   * 0x9B - QoS not supported
+   * Description: The Server does not support the QoS set in Will QoS.
+   */
   QosNotSupported = 155,
   /**
-  * 0x9C - Use another server
-  * Description: The Client should temporarily use another server.
-  */
+   * 0x9C - Use another server
+   * Description: The Client should temporarily use another server.
+   */
   UseAnotherServer = 156,
   /**
-  * 0x9D - Server moved
-  * Description: The Client should permanently use another server.
-  */
+   * 0x9D - Server moved
+   * Description: The Client should permanently use another server.
+   */
   ServerMoved = 157,
   /**
-  * 0x9F - Connection rate exceeded
-  * Description: The connection rate limit has been exceeded.
-  */
-  ConnectionRateExceeded = 159,
+   * 0x9F - Connection rate exceeded
+   * Description: The connection rate limit has been exceeded.
+   */
+  ConnectionRateExceeded = 159
 }
-
 //#endregion
 //#region src/server/event-handler/cloud-events-protocols.d.ts
 /**
-* Response of the connect event.
-*/
+ * Response of the connect event.
+ */
 interface ConnectResponse {
   /**
-  * Set the groups the connection would like to join.
-  */
+   * Set the groups the connection would like to join.
+   */
   groups?: string[];
   /**
-  * Set the roles the connection belongs to.
-  */
+   * Set the roles the connection belongs to.
+   */
   roles?: string[];
   /**
-  * Set the userId for the connection.
-  */
+   * Set the userId for the connection.
+   */
   userId?: string;
   /**
-  * Set the subprotocol for the connection to complete WebSocket handshake.
-  */
+   * Set the subprotocol for the connection to complete WebSocket handshake.
+   */
   subprotocol?: string;
 }
 /**
-* Success respones of the connect event.
-*/
+ * Success respones of the connect event.
+ */
 interface MqttConnectResponse extends ConnectResponse {
   /**
-  * The MQTT specific properties in a successful MQTT connection event response.
-  */
+   * The MQTT specific properties in a successful MQTT connection event response.
+   */
   mqtt?: MqttConnectResponseProperties;
 }
 /**
-* Response of a failed connect event.
-*/
+ * Response of a failed connect event.
+ */
 interface ConnectErrorResponse {
   /**
-  * The error code.
-  */
+   * The error code.
+   */
   code: 400 | 401 | 500;
   /**
-  * The error detail.
-  */
+   * The error detail.
+   */
   detail?: string;
 }
 /**
-* Response of an MQTT connection failure.
-*/
+ * Response of an MQTT connection failure.
+ */
 interface MqttConnectErrorResponse {
   /**
-  * The properties of the MQTT connection failure response.
-  */
+   * The properties of the MQTT connection failure response.
+   */
   mqtt: MqttConnectErrorResponseProperties;
 }
 /**
-* The properties of an MQTT connection failure response.
-*/
+ * The properties of an MQTT connection failure response.
+ */
 interface MqttConnectErrorResponseProperties {
   /**
-  * The MQTT connect return code.
-  */
+   * The MQTT connect return code.
+   */
   code: MqttV311ConnectReturnCode | MqttV500ConnectReasonCode;
   /**
-  * The reason string for the connection failure.
-  */
+   * The reason string for the connection failure.
+   */
   reason?: string;
   /**
-  * The user properties in the response.
-  */
+   * The user properties in the response.
+   */
   userProperties?: MqttUserProperty[];
 }
 /**
-* The protocol of Web PubSub Client.
-*/
+ * The protocol of Web PubSub Client.
+ */
 type WebPubSubClientProtocol = "default" | "mqtt";
 /**
-* The connection context representing the client WebSocket connection.
-*/
+ * 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;
 }
 /**
-* Request for the connect event.
-*/
+ * Request for the connect event.
+ */
 interface ConnectRequest {
   /**
-  * The context of current CloudEvents request.
-  */
+   * The context of current CloudEvents request.
+   */
   context: ConnectionContext;
   /**
-  * The claims that the client WebSocket connection has when it connects.
-  */
+   * The claims that the client WebSocket connection has when it connects.
+   */
   claims?: Record<string, string[]>;
   /**
-  * The query that the client WebSocket connection has when it connects.
-  * @deprecated Please use queries instead.
-  */
+   * The query that the client WebSocket connection has when it connects.
+   * @deprecated Please use queries instead.
+   */
   query?: Record<string, string[]>;
   /**
-  * The queries that the client WebSocket connection has when it connects.
-  */
+   * The queries that the client WebSocket connection has when it connects.
+   */
   queries?: Record<string, string[]>;
   /**
-  * The headers that the client WebSocket connection has when it connects.
-  */
+   * The headers that the client WebSocket connection has when it connects.
+   */
   headers?: Record<string, string[]>;
   /**
-  * The subprotocols that the client WebSocket connection uses to do handshake.
-  */
+   * The subprotocols that the client WebSocket connection uses to do handshake.
+   */
   subprotocols?: string[];
   /**
-  * The client certificate info that the client WebSocket connection uses to connect.
-  */
+   * The client certificate info that the client WebSocket connection uses to connect.
+   */
   clientCertificates?: Certificate[];
 }
 /**
-* Request for the MQTT connect event.
-*/
+ * Request for the MQTT connect event.
+ */
 interface MqttConnectRequest extends ConnectRequest {
   /**
-  * The MQTT specific properties in the MQTT connect event request.
-  */
+   * The MQTT specific properties in the MQTT connect event request.
+   */
   mqtt: MqttConnectProperties;
 }
 /**
-* The properties of the MQTT CONNECT packet.
-*/
+ * The properties of the MQTT CONNECT packet.
+ */
 interface MqttConnectProperties {
   /**
-  * MQTT protocol version.
-  */
+   * MQTT protocol version.
+   */
   protocolVersion: number;
   /**
-  * The username field in the MQTT CONNECT packet.
-  */
+   * The username field in the MQTT CONNECT packet.
+   */
   username?: string;
   /**
-  * The password field in the MQTT CONNECT packet.
-  */
+   * The password field in the MQTT CONNECT packet.
+   */
   password?: string;
   /**
-  * The user properties in the MQTT CONNECT packet.
-  */
+   * The user properties in the MQTT CONNECT packet.
+   */
   userProperties?: MqttUserProperty[];
 }
 /**
-* The properties of a successful MQTT connection event response
-*/
+ * The properties of a successful MQTT connection event response
+ */
 interface MqttConnectResponseProperties {
   /**
-  * Additional diagnostic or other information provided by upstream server
-  * Now only MQTT 5.0 supports user properties
-  */
+   * Additional diagnostic or other information provided by upstream server
+   * Now only MQTT 5.0 supports user properties
+   */
   userProperties?: MqttUserProperty[];
 }
 /**
-* The properties of a user in MQTT.
-*/
+ * The properties of a user in MQTT.
+ */
 interface MqttUserProperty {
   /**
-  * The name of the property.
-  */
+   * The name of the property.
+   */
   name: string;
   /**
-  * The value of the property.
-  */
+   * The value of the property.
+   */
   value: string;
 }
 /**
-* The client certificate.
-*/
+ * The client certificate.
+ */
 interface Certificate {
   /**
-  * The thumbprint of the certificate.
-  */
+   * The thumbprint of the certificate.
+   */
   thumbprint: string;
 }
 /**
-* Request for the connected event.
-*/
+ * Request for the connected event.
+ */
 interface ConnectedRequest {
   /**
-  * The context of current CloudEvents request.
-  */
+   * The context of current CloudEvents request.
+   */
   context: ConnectionContext;
 }
 /**
-* Request for the user event.
-*/
+ * Request for the user event.
+ */
 type UserEventRequest = {
   /**
-  * The context of current CloudEvents request.
-  */
+   * The context of current CloudEvents request.
+   */
   context: ConnectionContext;
   /**
-  * The content data.
-  */
+   * The content data.
+   */
   data: string;
   /**
-  * The type of the data.
-  */
+   * The type of the data.
+   */
   dataType: "text";
 } | {
   /**
-  * The context of current CloudEvents request.
-  */
+   * The context of current CloudEvents request.
+   */
   context: ConnectionContext;
   /**
-  * The content data, when data type is `json`, the data is the result of JSON.parse, so the type of the data depends on user scenarios
-  */
+   * The content data, when data type is `json`, the data is the result of JSON.parse, so the type of the data depends on user scenarios
+   */
   data: unknown;
   /**
-  * The type of the data.
-  */
+   * The type of the data.
+   */
   dataType: "json";
 } | {
   /**
-  * The context of current CloudEvents request.
-  */
+   * The context of current CloudEvents request.
+   */
   context: ConnectionContext;
   /**
-  * The content data.
-  */
+   * The content data.
+   */
   data: ArrayBuffer;
   /**
-  * The type of the data.
-  */
+   * The type of the data.
+   */
   dataType: "binary";
 };
 /**
-* Request for the disconnected event.
-*/
+ * Request for the disconnected event.
+ */
 interface DisconnectedRequest {
   /**
-  * The context of current CloudEvents request.
-  */
+   * The context of current CloudEvents request.
+   */
   context: ConnectionContext;
   /**
-  * The reason that the connection disconnects.
-  */
+   * The reason that the connection disconnects.
+   */
   reason?: string;
 }
 /**
-* Request for the disconnected event.
-*/
+ * Request for the disconnected event.
+ */
 interface MqttDisconnectedRequest extends DisconnectedRequest {
   /**
-  * The MQTT specific properties in the MQTT disconnected event request.
-  */
+   * The MQTT specific properties in the MQTT disconnected event request.
+   */
   mqtt: MqttDisconnectedProperties;
 }
 /**
-* The properties of an MQTT disconnected event.
-*/
+ * The properties of an MQTT disconnected event.
+ */
 interface MqttDisconnectedProperties {
   /**
-  * The MQTT disconnect packet.
-  */
+   * The MQTT disconnect packet.
+   */
   disconnectPacket: MqttDisconnectPacket;
   /**
-  * Whether the disconnection is initiated by the client.
-  */
+   * Whether the disconnection is initiated by the client.
+   */
   initiatedByClient: boolean;
 }
 /**
-* The properties of the MQTT DISCONNECT packet.
-*/
+ * The properties of the MQTT DISCONNECT packet.
+ */
 interface MqttDisconnectPacket {
   /**
-  * The MQTT disconnect return code.
-  */
+   * The MQTT disconnect return code.
+   */
   code: MqttDisconnectReasonCode;
   /**
-  * The user properties in the MQTT disconnect packet.
-  */
+   * The user properties in the MQTT disconnect packet.
+   */
   userProperties?: MqttUserProperty[];
 }
 /**
-* The handler to set connect event response
-*/
+ * The handler to set connect event response
+ */
 interface ConnectResponseHandler {
   /**
-  * Set the state of the connection
-  * @param name - The name of the state
-  * @param value - The value of the state
-  */
+   * Set the state of the connection
+   * @param name - The name of the state
+   * @param value - The value of the state
+   */
   setState(name: string, value: unknown): void;
   /**
-  * Return success response to the service.
-  * @param response - The response for the connect event.
-  */
+   * Return success response to the service.
+   * @param response - The response for the connect event.
+   */
   success(response?: ConnectResponse | MqttConnectResponse): void;
   /**
-  * Return failed response and the service will reject the client WebSocket connection.
-  * @param code - Code can be 400 user error, 401 unauthorized and 500 server error.
-  * @param detail - The detail of the error.
-  */
+   * Return failed response and the service will reject the client WebSocket connection.
+   * @param code - Code can be 400 user error, 401 unauthorized and 500 server error.
+   * @param detail - The detail of the error.
+   */
   fail(code: 400 | 401 | 500, detail?: string): void;
   /**
-  * Return failed response with MQTT response properties and the service will reject the client WebSocket connection.
-  * @param response - The response for the connect event which contains either default WebPubSub or MQTT response properties.
-  */
+   * Return failed response with MQTT response properties and the service will reject the client WebSocket connection.
+   * @param response - The response for the connect event which contains either default WebPubSub or MQTT response properties.
+   */
   failWith(response: ConnectErrorResponse | MqttConnectErrorResponse): void;
 }
 /**
-* The handler to set user event response
-*/
+ * The handler to set user event response
+ */
 interface UserEventResponseHandler {
   /**
-  * Set the state of the connection
-  * @param name - The name of the state
-  * @param value - The value of the state
-  */
+   * Set the state of the connection
+   * @param name - The name of the state
+   * @param value - The value of the state
+   */
   setState(name: string, value: unknown): void;
   /**
-  * Return success response with data to be delivered to the client WebSocket connection.
-  * @param data - The payload data to be returned to the client. Stringify the message if it is a JSON object.
-  * @param dataType - The type of the payload data.
-  */
+   * Return success response with data to be delivered to the client WebSocket connection.
+   * @param data - The payload data to be returned to the client. Stringify the message if it is a JSON object.
+   * @param dataType - The type of the payload data.
+   */
   success(data?: string | ArrayBuffer, dataType?: "binary" | "text" | "json"): void;
   /**
-  * Return failed response and the service will close the client WebSocket connection.
-  * @param code - Code can be 400 user error, 401 unauthorized and 500 server error.
-  * @param detail - The detail of the error.
-  */
+   * Return failed response and the service will close the client WebSocket connection.
+   * @param code - Code can be 400 user error, 401 unauthorized and 500 server error.
+   * @param detail - The detail of the error.
+   */
   fail(code: 400 | 401 | 500, detail?: string): void;
 }
 /**
-* The options for the CloudEvents handler.
-*/
+ * The options for the CloudEvents handler.
+ */
 interface WebPubSubEventHandlerOptions {
   /**
-  * Custom serving path for the path of the CloudEvents handler.
-  */
+   * Custom serving path for the path of the CloudEvents handler.
+   */
   path?: string;
   /**
-  * Handle 'connect' event, the service waits for the response to proceed.
-  */
+   * Handle 'connect' event, the service waits for the response to proceed.
+   */
   handleConnect?: (connectRequest: ConnectRequest, connectResponse: ConnectResponseHandler) => void;
   /**
-  * Handle user events, the service waits for the response to proceed.
-  */
+   * Handle user events, the service waits for the response to proceed.
+   */
   handleUserEvent?: (userEventRequest: UserEventRequest, userEventResponse: UserEventResponseHandler) => void;
   /**
-  * Event trigger for "connected" unblocking event. This is an unblocking event and the service does not wait for the response.
-  */
+   * Event trigger for "connected" unblocking event. This is an unblocking event and the service does not wait for the response.
+   */
   onConnected?: (connectedRequest: ConnectedRequest) => void;
   /**
-  *
-  * Event triggers for "disconnected" unblocking event. This is an unblocking event and the service does not wait for the response.
-  */
+   *
+   * Event triggers for "disconnected" unblocking event. This is an unblocking event and the service does not wait for the response.
+   */
   onDisconnected?: (disconnectedRequest: DisconnectedRequest) => void;
   /**
-  * If not specified, by default allow all the endpoints, otherwise only allow specified endpoints
-  */
+   * If not specified, by default allow all the endpoints, otherwise only allow specified endpoints
+   */
   allowedEndpoints?: string[];
   /**
-  * The Azure Web PubSub access key (or an array of [primary, secondary] keys to support key
-  * rotation) used to verify the HMAC-SHA256 signature on every incoming CloudEvents POST.
-  *
-  * The Azure service signs each event as:
-  *   `sha256=Hex(HMAC-SHA256(accessKey, connectionId))`
-  * and includes both the primary and secondary signatures in the `ce-signature` header.
-  *
-  * When set, requests whose `ce-signature` does not match are rejected with HTTP 401.
-  * When omitted, signature verification is skipped and a warning is logged — use this only
-  * when combined with network-level ingress restriction to Azure Web PubSub IP ranges.
-  *
-  * For managed identity / DefaultAzureCredential deployments that have no static key,
-  * provide the service access key separately (e.g. from `WEAVE_AZURE_WEB_PUBSUB_KEY`).
-  */
+   * The Azure Web PubSub access key (or an array of [primary, secondary] keys to support key
+   * rotation) used to verify the HMAC-SHA256 signature on every incoming CloudEvents POST.
+   *
+   * The Azure service signs each event as:
+   *   `sha256=Hex(HMAC-SHA256(accessKey, connectionId))`
+   * and includes both the primary and secondary signatures in the `ce-signature` header.
+   *
+   * When set, requests whose `ce-signature` does not match are rejected with HTTP 401.
+   * When omitted, signature verification is skipped and a warning is logged — use this only
+   * when combined with network-level ingress restriction to Azure Web PubSub IP ranges.
+   *
+   * For managed identity / DefaultAzureCredential deployments that have no static key,
+   * provide the service access key separately (e.g. from `WEAVE_AZURE_WEB_PUBSUB_KEY`).
+   */
   accessKey?: string | string[];
-} //#endregion
+}
+//#endregion
 //#region src/server/event-handler/web-pubsub-event-handler.d.ts
 /**
-* The handler to handle incoming CloudEvents messages
-*/
+ * The handler to handle incoming CloudEvents messages
+ */
 declare class WebPubSubEventHandler {
-  private hub;
+  private readonly hub;
   /**
-  * The path this CloudEvents handler listens to
-  */
+   * The path this CloudEvents handler listens to
+   */
   readonly path: string;
-  private _cloudEventsHandler;
-  /**
-  * Creates an instance of a WebPubSubEventHandler for handling incoming CloudEvents messages.
-  *
-  * Example usage:
-  * ```ts snippet:WebPubSubEventHandlerHandleMessages
-  * import { WebPubSubEventHandler } from "@azure/web-pubsub-express";
-  *
-  * const endpoint = "https://xxxx.webpubsubdev.azure.com";
-  * const handler = new WebPubSubEventHandler("chat", {
-  *   handleConnect: (req, res) => {
-  *     console.log(JSON.stringify(req));
-  *     return {};
-  *   },
-  *   onConnected: (req) => {
-  *     console.log(JSON.stringify(req));
-  *   },
-  *   handleUserEvent: (req, res) => {
-  *     console.log(JSON.stringify(req));
-  *     res.success("Hey " + req.data, req.dataType);
-  *   },
-  *   allowedEndpoints: [endpoint],
-  * });
-  * ```
-  *
-  * @param hub - The name of the hub to listen to
-  * @param options - Options to configure the event handler
-  */
+  private readonly _cloudEventsHandler;
+  /**
+   * Creates an instance of a WebPubSubEventHandler for handling incoming CloudEvents messages.
+   *
+   * Example usage:
+   * ```ts snippet:WebPubSubEventHandlerHandleMessages
+   * import { WebPubSubEventHandler } from "@azure/web-pubsub-express";
+   *
+   * const endpoint = "https://xxxx.webpubsubdev.azure.com";
+   * const handler = new WebPubSubEventHandler("chat", {
+   *   handleConnect: (req, res) => {
+   *     console.log(JSON.stringify(req));
+   *     return {};
+   *   },
+   *   onConnected: (req) => {
+   *     console.log(JSON.stringify(req));
+   *   },
+   *   handleUserEvent: (req, res) => {
+   *     console.log(JSON.stringify(req));
+   *     res.success("Hey " + req.data, req.dataType);
+   *   },
+   *   allowedEndpoints: [endpoint],
+   * });
+   * ```
+   *
+   * @param hub - The name of the hub to listen to
+   * @param options - Options to configure the event handler
+   */
   constructor(hub: string, options?: WebPubSubEventHandlerOptions);
   /**
-  * Get the middleware to process the CloudEvents requests for Koa.js
-  */
+   * Get the middleware to process the CloudEvents requests for Koa.js
+   */
   getKoaMiddleware(): (ctx: koa.Context, next: koa.Next) => Promise<void>;
   /**
-  * Get the middleware to process the CloudEvents requests for Express.js
-  */
-  getExpressJsMiddleware(): express.RequestHandler;
+   * Get the middleware to process the CloudEvents requests for Express.js
+   */
+  getExpressJsMiddleware(): RequestHandler$1;
 }
-
 //#endregion
 //#region src/server/azure-web-pubsub-host.d.ts
 declare class WeaveStoreAzureWebPubSubSyncHost {
@@ -1085,7 +2769,7 @@ declare class WeaveStoreAzureWebPubSubSyncHost {
   private _updateHandler;
   private _awarenessUpdateHandler;
   constructor(server: WeaveAzureWebPubsubServer, syncHandler: WeaveAzureWebPubsubSyncHandler, client: WebPubSubServiceClient, topic: string, doc: Y.Doc, syncHostOptions?: DeepPartial<WeaveStoreAzureWebPubsubSyncHostOptions>);
-  get awareness(): awarenessProtocol.Awareness | undefined;
+  get awareness(): Awareness | undefined;
   sendInitAwarenessInfo(origin: string): void;
   private setupHeartbeat;
   createWebSocket(): Promise<void>;
@@ -1105,7 +2789,6 @@ declare class WeaveStoreAzureWebPubSubSyncHost {
   private onAwareness;
   private negotiate;
 }
-
 //#endregion
 //#region src/server/azure-web-pubsub-sync-handler.d.ts
 declare class WeaveAzureWebPubsubSyncHandler extends WebPubSubEventHandler {
@@ -1135,7 +2818,6 @@ declare class WeaveAzureWebPubsubSyncHandler extends WebPubSubEventHandler {
   clientTransportConnect(roomId: string): Promise<void>;
   clientTransportDisconnect(roomId: string): void;
 }
-
 //#endregion
 //#region src/server/azure-web-pubsub-server.d.ts
 type WeaveAzureWebPubsubServerParams = {
@@ -1151,14 +2833,7 @@ declare class WeaveAzureWebPubsubServer extends Emittery {
   private syncHandler;
   persistRoom: PersistRoom | undefined;
   fetchRoom: FetchRoom | undefined;
-  constructor({
-    pubSubConfig,
-    eventsHandlerConfig,
-    initialState,
-    persistRoom,
-    fetchRoom,
-    syncHostConfig
-  }: WeaveAzureWebPubsubServerParams);
+  constructor({ pubSubConfig, eventsHandlerConfig, initialState, persistRoom, fetchRoom, syncHostConfig }: WeaveAzureWebPubsubServerParams);
   getKoaMiddleware(): koa.Middleware;
   getExpressJsMiddleware(): RequestHandler;
   getSyncHandler(): WeaveAzureWebPubsubSyncHandler;
@@ -1171,6 +2846,5 @@ declare class WeaveAzureWebPubsubServer extends Emittery {
   clientTransportConnect(roomId: string): Promise<void>;
   clientTransportDisconnect(roomId: string): void;
 }
-
 //#endregion
 export { Certificate, ConnectErrorResponse, ConnectRequest, ConnectResponse, ConnectResponseHandler, ConnectedRequest, ConnectionContext, DisconnectedRequest, FetchClient, FetchInitialState, FetchRoom, IndexedDbOptions, Message, MessageData, MessageDataType, MessageHandler, MessageType, MqttConnectErrorResponse, MqttConnectErrorResponseProperties, MqttConnectProperties, MqttConnectRequest, MqttConnectResponse, MqttConnectResponseProperties, MqttConnectionContextProperties, MqttDisconnectPacket, MqttDisconnectReasonCode, MqttDisconnectedProperties, MqttDisconnectedRequest, MqttUserProperty, MqttV311ConnectReturnCode, MqttV500ConnectReasonCode, PersistRoom, UserEventRequest, UserEventResponseHandler, 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, WeaveAzureWebPubsubServer, WeaveAzureWebPubsubSyncHandlerOptions, WeaveRoomData, WeaveStoreAzureWebPubSubSyncClientConnectionStatus, WeaveStoreAzureWebPubSubSyncClientConnectionStatusKeys, WeaveStoreAzureWebPubSubSyncClientOptions, WeaveStoreAzureWebPubSubSyncHost, WeaveStoreAzureWebPubSubSyncHostClientConnectOptions, WeaveStoreAzureWebPubsubConfig, WeaveStoreAzureWebPubsubEvents, WeaveStoreAzureWebPubsubOnConnectEvent, WeaveStoreAzureWebPubsubOnConnectedEvent, WeaveStoreAzureWebPubsubOnDisconnectedEvent, WeaveStoreAzureWebPubsubOnStoreFetchConnectionUrlEvent, WeaveStoreAzureWebPubsubOnWebsocketCloseEvent, WeaveStoreAzureWebPubsubOnWebsocketErrorEvent, WeaveStoreAzureWebPubsubOnWebsocketJoinGroupEvent, WeaveStoreAzureWebPubsubOnWebsocketMessageEvent, WeaveStoreAzureWebPubsubOnWebsocketOpenEvent, WeaveStoreAzureWebPubsubOnWebsocketReconnectEvent, WeaveStoreAzureWebPubsubOptions, WeaveStoreAzureWebPubsubSyncHandlerDestroyRoomStatus, WeaveStoreAzureWebPubsubSyncHandlerDestroyRoomStatusKeys, WeaveStoreAzureWebPubsubSyncHostOptions, WebPubSubClientProtocol, WebPubSubEventHandler, WebPubSubEventHandlerOptions };