@rc-ex/ws 1.5.0 → 1.5.1

package/dist/subscription.d.cts

@@ -0,0 +1,23 @@
+import { WebSocketExtensionInterface } from "./types.cjs";
+import SubscriptionInfo from "@rc-ex/core/definitions/SubscriptionInfo";
+import CreateSubscriptionRequest from "@rc-ex/core/definitions/CreateSubscriptionRequest";
+import { MessageEvent } from "ws";
+
+//#region src/subscription.d.ts
+declare class Subscription {
+  subscriptionInfo?: SubscriptionInfo;
+  wse: WebSocketExtensionInterface;
+  eventFilters: string[];
+  eventListener: (event: MessageEvent) => void;
+  timeout?: NodeJS.Timeout;
+  enabled: boolean;
+  constructor(wse: WebSocketExtensionInterface, eventFilters: string[], callback: (event: {}) => void);
+  setupWsEventListener(): void;
+  get requestBody(): CreateSubscriptionRequest;
+  subscribe(): Promise<void>;
+  refresh(): Promise<void>;
+  revoke(): Promise<void>;
+  remove(): void;
+}
+//#endregion
+export { Subscription as default };

package/dist/subscription.d.mts

@@ -0,0 +1,23 @@
+import { WebSocketExtensionInterface } from "./types.mjs";
+import SubscriptionInfo from "@rc-ex/core/definitions/SubscriptionInfo";
+import CreateSubscriptionRequest from "@rc-ex/core/definitions/CreateSubscriptionRequest";
+import { MessageEvent } from "ws";
+
+//#region src/subscription.d.ts
+declare class Subscription {
+  subscriptionInfo?: SubscriptionInfo;
+  wse: WebSocketExtensionInterface;
+  eventFilters: string[];
+  eventListener: (event: MessageEvent) => void;
+  timeout?: NodeJS.Timeout;
+  enabled: boolean;
+  constructor(wse: WebSocketExtensionInterface, eventFilters: string[], callback: (event: {}) => void);
+  setupWsEventListener(): void;
+  get requestBody(): CreateSubscriptionRequest;
+  subscribe(): Promise<void>;
+  refresh(): Promise<void>;
+  revoke(): Promise<void>;
+  remove(): void;
+}
+//#endregion
+export { Subscription as default };

package/dist/subscription.mjs

@@ -0,0 +1,67 @@
+import Utils from "./utils.mjs";
+//#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] = Utils.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
+export { Subscription as default };

package/dist/types.cjs

@@ -1,16 +1 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var types_exports = {};
-module.exports = __toCommonJS(types_exports);
-//# sourceMappingURL=types.cjs.map
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });

package/dist/types.d.cts

@@ -0,0 +1,65 @@
+import RingCentral from "@rc-ex/core";
+import { RestMethod, RestRequestConfig, RestResponse } from "@rc-ex/core/types";
+import WS from "isomorphic-ws";
+
+//#region src/types.d.ts
+interface WsToken {
+  uri: string;
+  ws_access_token: string;
+  expires_in: number;
+}
+type CheckInterval = (retriesAttempted: number) => number;
+interface WebSocketOptions {
+  restOverWebSocket?: boolean;
+  debugMode?: boolean;
+  autoRecover?: {
+    enabled: boolean;
+    checkInterval?: CheckInterval;
+    pingServerInterval?: number;
+  };
+  wscToken?: string;
+}
+interface WsgEvent {
+  data: string;
+}
+interface Wsc {
+  token: string;
+  sequence: number;
+}
+interface WsgMeta {
+  type: "ClientRequest" | "ServerNotification" | "Error" | "ConnectionDetails" | "Heartbeat";
+  messageId: string;
+  status: number;
+  headers: {
+    [key: string]: string;
+  };
+  wsc?: Wsc;
+}
+interface WsgError {
+  errorCode: string;
+  message: string;
+}
+interface ConnectionDetails {
+  creationTime: string;
+  maxConnectionsPerSession: number;
+  recoveryBufferSize: number;
+  recoveryTimeout: number;
+  idleTimeout: number;
+  absoluteTimeout: number;
+  maxActiveRequests: number;
+  recoveryState?: "Successful" | "Failed";
+  recoveryErrorCode?: string;
+}
+interface WebSocketExtensionInterface {
+  options: WebSocketOptions;
+  subscription?: SubscriptionInterface;
+  ws: WS;
+  wsToken?: WsToken;
+  rc: RingCentral;
+  request: <T>(method: RestMethod, endpoint: string, content?: {}, queryParams?: {}, config?: RestRequestConfig) => Promise<RestResponse<T>>;
+}
+interface SubscriptionInterface {
+  eventFilters: string[];
+}
+//#endregion
+export { CheckInterval, ConnectionDetails, SubscriptionInterface, WebSocketExtensionInterface, WebSocketOptions, WsToken, Wsc, WsgError, WsgEvent, WsgMeta };

package/dist/types.d.mts

@@ -0,0 +1,65 @@
+import WS from "isomorphic-ws";
+import RingCentral from "@rc-ex/core";
+import { RestMethod, RestRequestConfig, RestResponse } from "@rc-ex/core/types";
+
+//#region src/types.d.ts
+interface WsToken {
+  uri: string;
+  ws_access_token: string;
+  expires_in: number;
+}
+type CheckInterval = (retriesAttempted: number) => number;
+interface WebSocketOptions {
+  restOverWebSocket?: boolean;
+  debugMode?: boolean;
+  autoRecover?: {
+    enabled: boolean;
+    checkInterval?: CheckInterval;
+    pingServerInterval?: number;
+  };
+  wscToken?: string;
+}
+interface WsgEvent {
+  data: string;
+}
+interface Wsc {
+  token: string;
+  sequence: number;
+}
+interface WsgMeta {
+  type: "ClientRequest" | "ServerNotification" | "Error" | "ConnectionDetails" | "Heartbeat";
+  messageId: string;
+  status: number;
+  headers: {
+    [key: string]: string;
+  };
+  wsc?: Wsc;
+}
+interface WsgError {
+  errorCode: string;
+  message: string;
+}
+interface ConnectionDetails {
+  creationTime: string;
+  maxConnectionsPerSession: number;
+  recoveryBufferSize: number;
+  recoveryTimeout: number;
+  idleTimeout: number;
+  absoluteTimeout: number;
+  maxActiveRequests: number;
+  recoveryState?: "Successful" | "Failed";
+  recoveryErrorCode?: string;
+}
+interface WebSocketExtensionInterface {
+  options: WebSocketOptions;
+  subscription?: SubscriptionInterface;
+  ws: WS;
+  wsToken?: WsToken;
+  rc: RingCentral;
+  request: <T>(method: RestMethod, endpoint: string, content?: {}, queryParams?: {}, config?: RestRequestConfig) => Promise<RestResponse<T>>;
+}
+interface SubscriptionInterface {
+  eventFilters: string[];
+}
+//#endregion
+export { CheckInterval, ConnectionDetails, SubscriptionInterface, WebSocketExtensionInterface, WebSocketOptions, WsToken, Wsc, WsgError, WsgEvent, WsgMeta };

package/dist/types.mjs

@@ -0,0 +1 @@
+export {};

package/dist/utils.cjs

@@ -1,103 +1,72 @@
-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 utils_exports = {};
-__export(utils_exports, {
-  default: () => utils_default
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
 });
-module.exports = __toCommonJS(utils_exports);
-var import_ClosedException = __toESM(require("./exceptions/ClosedException.js"), 1);
-var import_TimeoutException = __toESM(require("./exceptions/TimeoutException.js"), 1);
-class Utils {
-  static splitWsgData(wsgData) {
-    if (wsgData.includes(",--Boundary")) {
-      const index = wsgData.indexOf(",--Boundary");
-      return [
-        JSON.parse(wsgData.substring(1, index)),
-        wsgData.substring(index + 1, wsgData.length - 1)
-      ];
-    }
-    return JSON.parse(wsgData);
-  }
-  static debugWebSocket(_ws) {
-    const ws = _ws;
-    const send = ws.send.bind(ws);
-    ws.send = async (str) => {
-      await send(str);
-      console.debug(
-        `*** WebSocket outgoing message: ***
+const require_exceptions_ClosedException = require("./exceptions/ClosedException.cjs");
+const require_exceptions_TimeoutException = require("./exceptions/TimeoutException.cjs");
+//#region src/utils.ts
+var Utils = class Utils {
+	static splitWsgData(wsgData) {
+		if (wsgData.includes(",--Boundary")) {
+			const index = wsgData.indexOf(",--Boundary");
+			return [JSON.parse(wsgData.substring(1, index)), wsgData.substring(index + 1, wsgData.length - 1)];
+		}
+		return JSON.parse(wsgData);
+	}
+	static debugWebSocket(_ws) {
+		const ws = _ws;
+		const send = ws.send.bind(ws);
+		ws.send = async (str) => {
+			await send(str);
+			console.debug(`*** WebSocket outgoing message: ***
 ${JSON.stringify(JSON.parse(str), null, 2)}
-******`
-      );
-    };
-    ws.addEventListener("message", (mEvent) => {
-      const event = mEvent;
-      console.debug(
-        `*** WebSocket incoming message: ***
-${JSON.stringify(JSON.parse(event.data), null, 2)}
-******`
-      );
-    });
-    ws.addEventListener("open", (event) => {
-      console.debug("WebSocket open event:", event);
-    });
-    ws.addEventListener("error", (event) => {
-      console.debug("WebSocket error event:", event);
-    });
-    ws.addEventListener("close", (event) => {
-      console.debug("WebSocket close event:", event);
-    });
-  }
-  static waitForWebSocketMessage(ws, matchCondition, timeout = 6e4) {
-    return new Promise((resolve, reject) => {
-      const checkHandle = setInterval(() => {
-        if (ws.readyState === ws.CLOSED) {
-          clearInterval(checkHandle);
-          reject(new import_ClosedException.default());
-        }
-      }, 1e3);
-      const timeoutHandle = setTimeout(() => {
-        ws.removeEventListener("message", handler);
-        clearInterval(checkHandle);
-        reject(new import_TimeoutException.default());
-      }, timeout);
-      const handler = (mEvent) => {
-        const event = mEvent;
-        const [meta, body] = Utils.splitWsgData(event.data);
-        if (matchCondition(meta)) {
-          ws.removeEventListener("message", handler);
-          clearInterval(checkHandle);
-          clearTimeout(timeoutHandle);
-          resolve([meta, body, event]);
-        }
-      };
-      ws.addEventListener("message", handler);
-    });
-  }
-}
-var utils_default = Utils;
-//# sourceMappingURL=utils.cjs.map
+******`);
+		};
+		ws.addEventListener("message", (mEvent) => {
+			console.debug(`*** WebSocket incoming message: ***
+${JSON.stringify(JSON.parse(mEvent.data), null, 2)}
+******`);
+		});
+		ws.addEventListener("open", (event) => {
+			console.debug("WebSocket open event:", event);
+		});
+		ws.addEventListener("error", (event) => {
+			console.debug("WebSocket error event:", event);
+		});
+		ws.addEventListener("close", (event) => {
+			console.debug("WebSocket close event:", event);
+		});
+	}
+	static waitForWebSocketMessage(ws, matchCondition, timeout = 6e4) {
+		return new Promise((resolve, reject) => {
+			const checkHandle = setInterval(() => {
+				if (ws.readyState === ws.CLOSED) {
+					clearInterval(checkHandle);
+					reject(new require_exceptions_ClosedException.default());
+				}
+			}, 1e3);
+			const timeoutHandle = setTimeout(() => {
+				ws.removeEventListener("message", handler);
+				clearInterval(checkHandle);
+				reject(new require_exceptions_TimeoutException.default());
+			}, timeout);
+			const handler = (mEvent) => {
+				const event = mEvent;
+				const [meta, body] = Utils.splitWsgData(event.data);
+				if (matchCondition(meta)) {
+					ws.removeEventListener("message", handler);
+					clearInterval(checkHandle);
+					clearTimeout(timeoutHandle);
+					resolve([
+						meta,
+						body,
+						event
+					]);
+				}
+			};
+			ws.addEventListener("message", handler);
+		});
+	}
+};
+//#endregion
+exports.default = Utils;

package/dist/utils.d.cts

@@ -0,0 +1,11 @@
+import { WsgEvent, WsgMeta } from "./types.cjs";
+import WS from "isomorphic-ws";
+
+//#region src/utils.d.ts
+declare class Utils {
+  static splitWsgData(wsgData: string): [WsgMeta, any];
+  static debugWebSocket(_ws: WS): void;
+  static waitForWebSocketMessage(ws: WS, matchCondition: (meta: WsgMeta) => boolean, timeout?: number): Promise<[WsgMeta, any, WsgEvent]>;
+}
+//#endregion
+export { Utils as default };

package/dist/utils.d.mts

@@ -0,0 +1,11 @@
+import { WsgEvent, WsgMeta } from "./types.mjs";
+import WS from "isomorphic-ws";
+
+//#region src/utils.d.ts
+declare class Utils {
+  static splitWsgData(wsgData: string): [WsgMeta, any];
+  static debugWebSocket(_ws: WS): void;
+  static waitForWebSocketMessage(ws: WS, matchCondition: (meta: WsgMeta) => boolean, timeout?: number): Promise<[WsgMeta, any, WsgEvent]>;
+}
+//#endregion
+export { Utils as default };

package/dist/utils.mjs

@@ -0,0 +1,68 @@
+import ClosedException from "./exceptions/ClosedException.mjs";
+import TimeoutException from "./exceptions/TimeoutException.mjs";
+//#region src/utils.ts
+var Utils = class Utils {
+	static splitWsgData(wsgData) {
+		if (wsgData.includes(",--Boundary")) {
+			const index = wsgData.indexOf(",--Boundary");
+			return [JSON.parse(wsgData.substring(1, index)), wsgData.substring(index + 1, wsgData.length - 1)];
+		}
+		return JSON.parse(wsgData);
+	}
+	static debugWebSocket(_ws) {
+		const ws = _ws;
+		const send = ws.send.bind(ws);
+		ws.send = async (str) => {
+			await send(str);
+			console.debug(`*** WebSocket outgoing message: ***
+${JSON.stringify(JSON.parse(str), null, 2)}
+******`);
+		};
+		ws.addEventListener("message", (mEvent) => {
+			console.debug(`*** WebSocket incoming message: ***
+${JSON.stringify(JSON.parse(mEvent.data), null, 2)}
+******`);
+		});
+		ws.addEventListener("open", (event) => {
+			console.debug("WebSocket open event:", event);
+		});
+		ws.addEventListener("error", (event) => {
+			console.debug("WebSocket error event:", event);
+		});
+		ws.addEventListener("close", (event) => {
+			console.debug("WebSocket close event:", event);
+		});
+	}
+	static waitForWebSocketMessage(ws, matchCondition, timeout = 6e4) {
+		return new Promise((resolve, reject) => {
+			const checkHandle = setInterval(() => {
+				if (ws.readyState === ws.CLOSED) {
+					clearInterval(checkHandle);
+					reject(new ClosedException());
+				}
+			}, 1e3);
+			const timeoutHandle = setTimeout(() => {
+				ws.removeEventListener("message", handler);
+				clearInterval(checkHandle);
+				reject(new TimeoutException());
+			}, timeout);
+			const handler = (mEvent) => {
+				const event = mEvent;
+				const [meta, body] = Utils.splitWsgData(event.data);
+				if (matchCondition(meta)) {
+					ws.removeEventListener("message", handler);
+					clearInterval(checkHandle);
+					clearTimeout(timeoutHandle);
+					resolve([
+						meta,
+						body,
+						event
+					]);
+				}
+			};
+			ws.addEventListener("message", handler);
+		});
+	}
+};
+//#endregion
+export { Utils as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rc-ex/ws",
-  "version": "1.5.0",
+  "version": "1.5.1",
   "description": "WebSocket extension for ringcentral-extensible project",
   "author": "Tyler Liu <tyler.liu@ringcentral.com>",
   "homepage": "https://github.com/ringcentral/ringcentral-extensible/tree/master/packages/extensions/ws",
@@ -8,24 +8,30 @@
   "files": [
     "dist"
   ],
-  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "types": "./dist/index.d.mts",
   "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
+  "module": "./dist/index.mjs",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
-    },
-    "./lib/*": {
-      "types": "./dist/*.d.ts",
-      "import": "./dist/*.js",
-      "require": "./dist/*.cjs"
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
     },
     "./*": {
-      "types": "./dist/*.d.ts",
-      "import": "./dist/*.js",
-      "require": "./dist/*.cjs"
+      "import": {
+        "types": "./dist/*.d.mts",
+        "default": "./dist/*.mjs"
+      },
+      "require": {
+        "types": "./dist/*.d.cts",
+        "default": "./dist/*.cjs"
+      }
     }
   },
   "repository": {
@@ -44,11 +50,16 @@
     "hyperid": "^3.3.0",
     "isomorphic-ws": "^5.0.0",
     "wait-for-async": "^0.8.0",
-    "ws": "^8.19.0"
+    "ws": "^8.20.0"
   },
-  "scripts": {
-    "build": "tsup --config tsup.config.ts && tsc -p tsconfig.esm.json --declaration --emitDeclarationOnly --outDir dist"
+  "peerDependencies": {
+    "@rc-ex/core": "^1.8.1"
+  },
+  "devDependencies": {
+    "@rc-ex/core": "^1.8.1"
   },
   "type": "module",
-  "gitHead": "1da760879c09e61688901ba7dbce4d7658ffca7e"
-}
+  "scripts": {
+    "build": "tsdown"
+  }
+}

package/dist/core/src/FormData.d.ts

@@ -1,9 +0,0 @@
-import type { FormFile } from "./types.js";
-export declare const boundary = "ad05fc42-a66d-4a94-b807-f1c91136c17b";
-declare class FormData {
-    files: FormFile[];
-    append(formFile: FormFile): void;
-    prepend(formFile: FormFile): void;
-    getBody(): Promise<Uint8Array<ArrayBufferLike>>;
-}
-export default FormData;

package/dist/core/src/Rest.d.ts

@@ -1,16 +0,0 @@
-import type { AxiosInstance } from "axios";
-import type TokenInfo from "./definitions/TokenInfo.js";
-import type { RestMethod, RestOptions, RestRequestConfig, RestResponse } from "./types.js";
-export default class Rest {
-    static sandboxServer: string;
-    static productionServer: string;
-    server: string;
-    clientId: string;
-    clientSecret?: string;
-    token?: TokenInfo;
-    appName: string;
-    appVersion: string;
-    httpClient: AxiosInstance;
-    constructor(options: RestOptions);
-    request<T>(method: RestMethod, endpoint: string, content?: {}, queryParams?: {}, config?: RestRequestConfig): Promise<RestResponse<T>>;
-}

package/dist/core/src/RestException.d.ts

@@ -1,7 +0,0 @@
-import type { RestResponse } from "./types.js";
-declare class RestException extends Error {
-    response: RestResponse;
-    message: string;
-    constructor(r: RestResponse);
-}
-export default RestException;

package/dist/core/src/SdkExtension.d.ts

@@ -1,9 +0,0 @@
-import type { RingCentralInterface } from "./types.js";
-declare abstract class SdkExtension {
-    enabled: boolean;
-    enable(): void;
-    disable(): void;
-    abstract install(rc: RingCentralInterface): Promise<void>;
-    abstract revoke(): Promise<void>;
-}
-export default SdkExtension;

package/dist/core/src/Utils.d.ts

@@ -1,7 +0,0 @@
-import type { RestResponse } from "./types.js";
-declare class Utils {
-    static formatTraffic(r: RestResponse): string;
-    static isAttachment(obj: {}): boolean;
-    static getFormData(...objects: {}[]): Promise<Uint8Array>;
-}
-export default Utils;