@rc-ex/ws 1.4.3 → 1.5.1

package/dist/index.d.mts

@@ -0,0 +1,47 @@
+import { ConnectionDetails, WebSocketOptions, WsToken, Wsc } from "./types.mjs";
+import { request } from "./rest.mjs";
+import Subscription from "./subscription.mjs";
+import { EventEmitter } from "node:events";
+import SdkExtension from "@rc-ex/core/SdkExtension";
+import WS from "isomorphic-ws";
+import RingCentral from "@rc-ex/core";
+import SubscriptionInfo from "@rc-ex/core/definitions/SubscriptionInfo";
+
+//#region src/index.d.ts
+declare enum Events {
+  autoRecoverSuccess = "autoRecoverSuccess",
+  autoRecoverFailed = "autoRecoverFailed",
+  autoRecoverError = "autoRecoverError",
+  newWebSocketObject = "newWebSocketObject",
+  newWsc = "newWsc",
+  connectionReady = "connectionReady"
+}
+declare class WebSocketExtension extends SdkExtension {
+  eventEmitter: EventEmitter<any>;
+  options: WebSocketOptions;
+  rc: RingCentral;
+  wsToken?: WsToken;
+  wsTokenExpiresAt: number;
+  ws: WS;
+  connectionDetails: ConnectionDetails;
+  wsc?: Wsc;
+  subscription?: Subscription;
+  intervalHandle?: NodeJS.Timeout;
+  recoverTimestamp?: number;
+  pingServerHandle?: NodeJS.Timeout;
+  _recoverPromise?: Promise<void>;
+  _connectPromise?: Promise<void>;
+  request: typeof request;
+  constructor(options?: WebSocketOptions);
+  disable(): void;
+  install(rc: RingCentral): Promise<void>;
+  recover(): Promise<void>;
+  _recover(): Promise<void>;
+  pingServer(): Promise<void>;
+  connect(recoverSession?: boolean): Promise<void>;
+  _connect(recoverSession?: boolean): Promise<void>;
+  revoke(keepInterval?: boolean): Promise<void>;
+  subscribe(eventFilters: string[], callback: (event: {}) => void, cache?: SubscriptionInfo | undefined | null): Promise<Subscription>;
+}
+//#endregion
+export { Events, WebSocketExtension as default };

package/dist/index.mjs

@@ -0,0 +1,229 @@
+import Utils from "./utils.mjs";
+import ConnectionException from "./exceptions/ConnectionException.mjs";
+import { request } from "./rest.mjs";
+import Subscription from "./subscription.mjs";
+import { EventEmitter } from "node:events";
+import RestException from "@rc-ex/core/RestException";
+import SdkExtension from "@rc-ex/core/SdkExtension";
+import hyperid from "hyperid";
+import WS from "isomorphic-ws";
+import waitFor from "wait-for-async";
+//#region src/index.ts
+const CONNECTING = 0;
+const OPEN = 1;
+const uuid = hyperid();
+let Events = /* @__PURE__ */ function(Events) {
+	Events["autoRecoverSuccess"] = "autoRecoverSuccess";
+	Events["autoRecoverFailed"] = "autoRecoverFailed";
+	Events["autoRecoverError"] = "autoRecoverError";
+	Events["newWebSocketObject"] = "newWebSocketObject";
+	Events["newWsc"] = "newWsc";
+	Events["connectionReady"] = "connectionReady";
+	return Events;
+}({});
+var WebSocketExtension = class extends SdkExtension {
+	eventEmitter = new EventEmitter();
+	options;
+	rc;
+	wsToken;
+	wsTokenExpiresAt = 0;
+	ws;
+	connectionDetails;
+	wsc;
+	subscription;
+	intervalHandle;
+	recoverTimestamp;
+	pingServerHandle;
+	_recoverPromise;
+	_connectPromise;
+	request = request;
+	constructor(options = {}) {
+		super();
+		this.options = options;
+		this.options.restOverWebSocket ??= false;
+		this.options.debugMode ??= false;
+		this.options.autoRecover ??= { enabled: true };
+		this.options.autoRecover.checkInterval ??= (retriesAttempted) => {
+			const interval = 2e3 + 2e3 * retriesAttempted;
+			return Math.min(8e3, interval);
+		};
+		this.options.autoRecover.pingServerInterval ??= 6e4;
+	}
+	disable() {
+		super.disable();
+		if (this.subscription) this.subscription.enabled = false;
+	}
+	async install(rc) {
+		this.rc = rc;
+		if (this.options.restOverWebSocket) {
+			const request = rc.request.bind(rc);
+			rc.request = async (method, endpoint, content, queryParams, config) => {
+				if (!this.enabled || !this.options.restOverWebSocket) return request(method, endpoint, content, queryParams, config);
+				if (config?.headers?.getContentType?.toString()?.includes("multipart/form-data") || config?.responseType === "arraybuffer" || endpoint.startsWith("/restapi/oauth/")) return request(method, endpoint, content, queryParams, config);
+				return this.request(method, endpoint, content, queryParams, config);
+			};
+		}
+		let connectMethod = this.connect.bind(this);
+		if (this.options.wscToken) {
+			this.wsc = {
+				token: this.options.wscToken,
+				sequence: 0
+			};
+			connectMethod = this.recover.bind(this);
+		}
+		if (!this.options.autoRecover.enabled) {
+			await connectMethod();
+			return;
+		}
+		try {
+			await connectMethod();
+		} catch (e) {
+			if (e instanceof RestException) throw e;
+			if (this.options.debugMode) console.debug("Initial connect failed:", e);
+		}
+		let retriesAttempted = 0;
+		let checking = false;
+		const check = async () => {
+			if (!this.enabled) return;
+			if (this.options.autoRecover?.enabled !== true) return;
+			if (checking) return;
+			checking = true;
+			if (this.ws?.readyState !== OPEN && this.ws?.readyState !== CONNECTING) {
+				clearInterval(this.intervalHandle);
+				try {
+					await this.recover();
+					retriesAttempted = 0;
+					if (this.options.debugMode) console.debug(`Auto recover done, recoveryState: ${this.connectionDetails.recoveryState}`);
+					this.eventEmitter.emit(this.connectionDetails.recoveryState === "Successful" ? "autoRecoverSuccess" : "autoRecoverFailed", this.ws);
+				} catch (e) {
+					if (e instanceof RestException) throw e;
+					retriesAttempted += 1;
+					if (this.options.debugMode) console.debug("Auto recover error:", e);
+					this.eventEmitter.emit("autoRecoverError", e);
+				}
+				this.intervalHandle = setInterval(check, this.options.autoRecover.checkInterval(retriesAttempted));
+			}
+			checking = false;
+		};
+		this.intervalHandle = setInterval(check, this.options.autoRecover.checkInterval(retriesAttempted));
+		if (typeof globalThis.window !== "undefined" && globalThis.window.addEventListener) {
+			globalThis.window.addEventListener("offline", () => {
+				if (this.pingServerHandle) clearTimeout(this.pingServerHandle);
+				this.ws?.close();
+			});
+			globalThis.window.addEventListener("online", () => {
+				check();
+			});
+		}
+	}
+	async recover() {
+		if (this._recoverPromise) return this._recoverPromise;
+		this._recoverPromise = this._recover();
+		try {
+			await this._recoverPromise;
+		} finally {
+			this._recoverPromise = void 0;
+		}
+	}
+	async _recover() {
+		if (this.ws?.readyState === OPEN || this.ws?.readyState === CONNECTING) return;
+		if (!this.wsc?.token) {
+			await this.connect(false);
+			return;
+		}
+		if (this.recoverTimestamp === void 0) this.recoverTimestamp = Date.now();
+		if (this.connectionDetails !== void 0 && Date.now() - this.recoverTimestamp > this.connectionDetails.recoveryTimeout * 1e3) {
+			if (this.options.debugMode) console.debug("connect to WSG but do not recover");
+			await this.connect(false);
+		} else {
+			if (this.options.debugMode) console.debug("connect to WSG and recover");
+			await this.connect(true);
+		}
+		this.recoverTimestamp = void 0;
+		this.enable();
+	}
+	async pingServer() {
+		if (this.options.autoRecover?.enabled !== true) return;
+		if (this.ws?.readyState !== OPEN) return;
+		try {
+			await this.ws.send(JSON.stringify([{
+				type: "Heartbeat",
+				messageId: uuid()
+			}]));
+		} catch (_e) {
+			this.ws.close();
+		}
+	}
+	async connect(recoverSession) {
+		if (this._connectPromise) return this._connectPromise;
+		this._connectPromise = this._connect(recoverSession);
+		try {
+			await this._connectPromise;
+		} finally {
+			this._connectPromise = void 0;
+		}
+	}
+	async _connect(recoverSession = false) {
+		if (!this.wsToken || Date.now() > this.wsTokenExpiresAt) {
+			const r = await this.rc.post("/restapi/oauth/wstoken");
+			this.wsToken = r.data;
+			this.wsTokenExpiresAt = Date.now() + this.wsToken.expires_in * .8 * 1e3;
+		}
+		let wsUri = `${this.wsToken.uri}?access_token=${this.wsToken.ws_access_token}`;
+		if (recoverSession && this.wsc) wsUri += `&wsc=${this.wsc.token}`;
+		this.ws = new WS(wsUri);
+		this.eventEmitter.emit("newWebSocketObject", this.ws);
+		const send = this.ws.send.bind(this.ws);
+		this.ws.send = async (s) => {
+			if (this.ws.readyState === CONNECTING) await waitFor({
+				interval: 100,
+				condition: () => this.ws.readyState !== CONNECTING
+			});
+			await send(s);
+		};
+		if (this.options.autoRecover?.enabled) this.ws.addEventListener("message", () => {
+			if (this.pingServerHandle) clearTimeout(this.pingServerHandle);
+			this.pingServerHandle = setTimeout(() => this.pingServer(), this.options.autoRecover.pingServerInterval);
+		});
+		if (this.options.debugMode) Utils.debugWebSocket(this.ws);
+		this.ws.addEventListener("message", (mEvent) => {
+			const event = mEvent;
+			const [meta, body] = Utils.splitWsgData(event.data);
+			if (meta.wsc && (!this.wsc || meta.type === "ConnectionDetails" && body.recoveryState || this.wsc.sequence < meta.wsc.sequence)) {
+				this.wsc = meta.wsc;
+				this.eventEmitter.emit("newWsc", this.wsc);
+			}
+		});
+		const [meta, body, event] = await Utils.waitForWebSocketMessage(this.ws, (meta) => meta.type === "ConnectionDetails" || meta.type === "Error");
+		if (meta.type === "Error") throw new ConnectionException(event);
+		this.connectionDetails = body;
+		this.eventEmitter.emit("connectionReady", this.ws);
+		if (this.subscription?.enabled) {
+			this.subscription.setupWsEventListener();
+			if (!recoverSession || this.connectionDetails.recoveryState === "Failed") await this.subscription.subscribe();
+		}
+	}
+	async revoke(keepInterval = false) {
+		await this.subscription?.revoke();
+		this.subscription = void 0;
+		if (!keepInterval && this.intervalHandle) clearInterval(this.intervalHandle);
+		if (this.pingServerHandle) clearTimeout(this.pingServerHandle);
+		this.ws?.close();
+		this.wsc = void 0;
+		this.wsToken = void 0;
+		this.wsTokenExpiresAt = 0;
+		this.disable();
+	}
+	async subscribe(eventFilters, callback, cache = void 0) {
+		const subscription = new Subscription(this, eventFilters, callback);
+		if (cache === void 0 || cache === null) await subscription.subscribe();
+		else {
+			subscription.subscriptionInfo = cache;
+			await subscription.refresh();
+		}
+		this.subscription = subscription;
+		return subscription;
+	}
+};
+//#endregion
+export { Events, WebSocketExtension as default };

package/dist/rest.cjs

@@ -1,87 +1,48 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var rest_exports = {};
-__export(rest_exports, {
-  request: () => request
-});
-module.exports = __toCommonJS(rest_exports);
-var import_RestException = __toESM(require("@rc-ex/core/RestException"), 1);
-var import_http_status_codes = require("http-status-codes");
-var import_hyperid = __toESM(require("hyperid"), 1);
-var import_utils = __toESM(require("./utils.js"), 1);
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+const require_utils = require("./utils.cjs");
+let _rc_ex_core_RestException = require("@rc-ex/core/RestException");
+_rc_ex_core_RestException = require_runtime.__toESM(_rc_ex_core_RestException, 1);
+let hyperid = require("hyperid");
+hyperid = require_runtime.__toESM(hyperid, 1);
+let http_status_codes = require("http-status-codes");
+//#region src/rest.ts
 const version = "0.16";
-const uuid = (0, import_hyperid.default)();
+const uuid = (0, hyperid.default)();
 async function request(method, endpoint, content, queryParams, config) {
-  const newConfig = {
-    method,
-    baseURL: this.wsToken?.uri,
-    url: endpoint,
-    data: content,
-    params: queryParams,
-    ...config
-  };
-  newConfig.headers = {
-    ...newConfig.headers,
-    "X-User-Agent": `${this.rc.rest.appName}/${this.rc.rest.appVersion} ringcentral-extensible/ws/${version}`
-  };
-  const messageId = uuid();
-  const requestBody = [
-    {
-      type: "ClientRequest",
-      messageId,
-      method: newConfig.method,
-      path: newConfig.url,
-      headers: newConfig.headers,
-      query: newConfig.params
-    }
-  ];
-  if (newConfig.data) {
-    requestBody.push(newConfig.data);
-  }
-  await this.ws.send(JSON.stringify(requestBody));
-  const [meta, body] = await import_utils.default.waitForWebSocketMessage(
-    this.ws,
-    (_meta) => _meta.messageId === messageId
-  );
-  const response = {
-    data: body,
-    status: meta.status,
-    statusText: (0, import_http_status_codes.getReasonPhrase)(meta.status),
-    headers: meta.headers,
-    config: newConfig
-  };
-  if (meta.type === "ClientRequest" && meta.status >= 200 && meta.status < 300) {
-    return response;
-  }
-  throw new import_RestException.default(response);
+	const newConfig = {
+		method,
+		baseURL: this.wsToken?.uri,
+		url: endpoint,
+		data: content,
+		params: queryParams,
+		...config
+	};
+	newConfig.headers = {
+		...newConfig.headers,
+		"X-User-Agent": `${this.rc.rest.appName}/${this.rc.rest.appVersion} ringcentral-extensible/ws/${version}`
+	};
+	const messageId = uuid();
+	const requestBody = [{
+		type: "ClientRequest",
+		messageId,
+		method: newConfig.method,
+		path: newConfig.url,
+		headers: newConfig.headers,
+		query: newConfig.params
+	}];
+	if (newConfig.data) requestBody.push(newConfig.data);
+	await this.ws.send(JSON.stringify(requestBody));
+	const [meta, body] = await require_utils.default.waitForWebSocketMessage(this.ws, (_meta) => _meta.messageId === messageId);
+	const response = {
+		data: body,
+		status: meta.status,
+		statusText: (0, http_status_codes.getReasonPhrase)(meta.status),
+		headers: meta.headers,
+		config: newConfig
+	};
+	if (meta.type === "ClientRequest" && meta.status >= 200 && meta.status < 300) return response;
+	throw new _rc_ex_core_RestException.default(response);
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  request
-});
-//# sourceMappingURL=rest.cjs.map
+//#endregion
+exports.request = request;

package/dist/rest.d.cts

@@ -0,0 +1,7 @@
+import { WebSocketExtensionInterface } from "./types.cjs";
+import { RestMethod, RestRequestConfig, RestResponse } from "@rc-ex/core/types";
+
+//#region src/rest.d.ts
+declare function request<T>(this: WebSocketExtensionInterface, method: RestMethod, endpoint: string, content?: {}, queryParams?: {}, config?: RestRequestConfig): Promise<RestResponse<T>>;
+//#endregion
+export { request };

package/dist/rest.d.mts

@@ -0,0 +1,7 @@
+import { WebSocketExtensionInterface } from "./types.mjs";
+import { RestMethod, RestRequestConfig, RestResponse } from "@rc-ex/core/types";
+
+//#region src/rest.d.ts
+declare function request<T>(this: WebSocketExtensionInterface, method: RestMethod, endpoint: string, content?: {}, queryParams?: {}, config?: RestRequestConfig): Promise<RestResponse<T>>;
+//#endregion
+export { request };

package/dist/rest.mjs

@@ -0,0 +1,44 @@
+import Utils from "./utils.mjs";
+import RestException from "@rc-ex/core/RestException";
+import hyperid from "hyperid";
+import { getReasonPhrase } from "http-status-codes";
+//#region src/rest.ts
+const version = "0.16";
+const uuid = hyperid();
+async function request(method, endpoint, content, queryParams, config) {
+	const newConfig = {
+		method,
+		baseURL: this.wsToken?.uri,
+		url: endpoint,
+		data: content,
+		params: queryParams,
+		...config
+	};
+	newConfig.headers = {
+		...newConfig.headers,
+		"X-User-Agent": `${this.rc.rest.appName}/${this.rc.rest.appVersion} ringcentral-extensible/ws/${version}`
+	};
+	const messageId = uuid();
+	const requestBody = [{
+		type: "ClientRequest",
+		messageId,
+		method: newConfig.method,
+		path: newConfig.url,
+		headers: newConfig.headers,
+		query: newConfig.params
+	}];
+	if (newConfig.data) requestBody.push(newConfig.data);
+	await this.ws.send(JSON.stringify(requestBody));
+	const [meta, body] = await Utils.waitForWebSocketMessage(this.ws, (_meta) => _meta.messageId === messageId);
+	const response = {
+		data: body,
+		status: meta.status,
+		statusText: getReasonPhrase(meta.status),
+		headers: meta.headers,
+		config: newConfig
+	};
+	if (meta.type === "ClientRequest" && meta.status >= 200 && meta.status < 300) return response;
+	throw new RestException(response);
+}
+//#endregion
+export { request };

package/dist/subscription.cjs

@@ -1,128 +1,71 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var subscription_exports = {};
-__export(subscription_exports, {
-  default: () => subscription_default
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
 });
-module.exports = __toCommonJS(subscription_exports);
-var import_utils = __toESM(require("./utils.js"), 1);
-class Subscription {
-  subscriptionInfo;
-  wse;
-  eventFilters;
-  eventListener;
-  timeout;
-  enabled = true;
-  constructor(wse, eventFilters, callback) {
-    this.wse = wse;
-    this.eventFilters = eventFilters;
-    this.eventListener = (mEvent) => {
-      const event = mEvent;
-      const [meta, body] = import_utils.default.splitWsgData(event.data);
-      if (this.enabled && meta.type === "ServerNotification" && body.subscriptionId === this.subscriptionInfo.id) {
-        callback(body);
-      }
-    };
-    this.setupWsEventListener();
-  }
-  setupWsEventListener() {
-    this.wse.ws.addEventListener("message", this.eventListener);
-  }
-  get requestBody() {
-    return {
-      deliveryMode: { transportType: "WebSocket" },
-      // because WebSocket is not in spec
-      eventFilters: this.eventFilters
-    };
-  }
-  async subscribe() {
-    this.subscriptionInfo = (await this.wse.request(
-      "POST",
-      "/restapi/v1.0/subscription",
-      this.requestBody
-    )).data;
-  }
-  async refresh() {
-    if (!this.subscriptionInfo) {
-      return;
-    }
-    try {
-      this.subscriptionInfo = (await this.wse.request(
-        "PUT",
-        `/restapi/v1.0/subscription/${this.subscriptionInfo.id}`,
-        this.requestBody
-      )).data;
-    } catch (e) {
-      const re = e;
-      if (re.response && re.response.status === 404) {
-        await this.subscribe();
-      }
-    }
-  }
-  async revoke() {
-    if (!this.subscriptionInfo) {
-      return;
-    }
-    try {
-      await this.wse.request(
-        "DELETE",
-        `/restapi/v1.0/subscription/${this.subscriptionInfo.id}`
-      );
-    } catch (e) {
-      const re = e;
-      if (re.response && re.response.status === 404) {
-        if (this.wse.options.debugMode) {
-          console.debug(
-            `Subscription ${this.subscriptionInfo.id} doesn't exist on server side`
-          );
-        }
-      } else if (re.response && re.response.status === 401) {
-        if (this.wse.options.debugMode) {
-          console.debug("Token invalid when trying to revoke subscription");
-        }
-      } else {
-        throw e;
-      }
-    }
-    this.remove();
-  }
-  remove() {
-    if (this.timeout) {
-      global.clearTimeout(this.timeout);
-      this.timeout = void 0;
-    }
-    this.enabled = false;
-    this.subscriptionInfo = void 0;
-    if (this.wse.ws) {
-      this.wse.ws.removeEventListener("message", this.eventListener);
-    }
-    this.wse.subscription = void 0;
-  }
-}
-var subscription_default = Subscription;
-//# sourceMappingURL=subscription.cjs.map
+const require_utils = require("./utils.cjs");
+//#region src/subscription.ts
+var Subscription = class {
+	subscriptionInfo;
+	wse;
+	eventFilters;
+	eventListener;
+	timeout;
+	enabled = true;
+	constructor(wse, eventFilters, callback) {
+		this.wse = wse;
+		this.eventFilters = eventFilters;
+		this.eventListener = (mEvent) => {
+			const event = mEvent;
+			const [meta, body] = require_utils.default.splitWsgData(event.data);
+			if (this.enabled && meta.type === "ServerNotification" && body.subscriptionId === this.subscriptionInfo.id) callback(body);
+		};
+		this.setupWsEventListener();
+	}
+	setupWsEventListener() {
+		this.wse.ws.addEventListener("message", this.eventListener);
+	}
+	get requestBody() {
+		return {
+			deliveryMode: { transportType: "WebSocket" },
+			eventFilters: this.eventFilters
+		};
+	}
+	async subscribe() {
+		this.subscriptionInfo = (await this.wse.request("POST", "/restapi/v1.0/subscription", this.requestBody)).data;
+	}
+	async refresh() {
+		if (!this.subscriptionInfo) return;
+		try {
+			this.subscriptionInfo = (await this.wse.request("PUT", `/restapi/v1.0/subscription/${this.subscriptionInfo.id}`, this.requestBody)).data;
+		} catch (e) {
+			const re = e;
+			if (re.response && re.response.status === 404) await this.subscribe();
+		}
+	}
+	async revoke() {
+		if (!this.subscriptionInfo) return;
+		try {
+			await this.wse.request("DELETE", `/restapi/v1.0/subscription/${this.subscriptionInfo.id}`);
+		} catch (e) {
+			const re = e;
+			if (re.response && re.response.status === 404) {
+				if (this.wse.options.debugMode) console.debug(`Subscription ${this.subscriptionInfo.id} doesn't exist on server side`);
+			} else if (re.response && re.response.status === 401) {
+				if (this.wse.options.debugMode) console.debug("Token invalid when trying to revoke subscription");
+			} else throw e;
+		}
+		this.remove();
+	}
+	remove() {
+		if (this.timeout) {
+			global.clearTimeout(this.timeout);
+			this.timeout = void 0;
+		}
+		this.enabled = false;
+		this.subscriptionInfo = void 0;
+		if (this.wse.ws) this.wse.ws.removeEventListener("message", this.eventListener);
+		this.wse.subscription = void 0;
+	}
+};
+//#endregion
+exports.default = Subscription;