api-def 0.9.0 → 0.9.2

package/cjs/util/retry/lib/retryOperation.js

@@ -1,134 +1,130 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-function RetryOperation(timeouts, options) {
-    // Compatibility for the old (timeouts, retryForever) signature
-    if (typeof options === "boolean") {
-        options = { forever: options };
-    }
-    this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
-    this._timeouts = timeouts;
-    this._options = options || {};
-    this._maxRetryTime = options && options.maxRetryTime || Infinity;
-    this._fn = null;
-    this._errors = [];
-    this._attempts = 1;
-    this._operationTimeout = null;
-    this._operationTimeoutCb = null;
-    this._timeout = null;
-    this._operationStart = null;
-    this._timer = null;
-    if (this._options.forever) {
-        this._cachedTimeouts = this._timeouts.slice(0);
-    }
-}
-RetryOperation.prototype.reset = function () {
-    this._attempts = 1;
-    this._timeouts = this._originalTimeouts.slice(0);
-};
-RetryOperation.prototype.stop = function () {
-    if (this._timeout) {
-        clearTimeout(this._timeout);
-    }
-    if (this._timer) {
-        clearTimeout(this._timer);
-    }
-    this._timeouts = [];
-    this._cachedTimeouts = null;
-};
-RetryOperation.prototype.retry = function (err) {
-    if (this._timeout) {
-        clearTimeout(this._timeout);
-    }
-    if (!err) {
-        return false;
-    }
-    var currentTime = new Date().getTime();
-    if (err && currentTime - this._operationStart >= this._maxRetryTime) {
-        this._errors.push(err);
-        this._errors.unshift(new Error("RetryOperation timeout occurred"));
-        return false;
-    }
-    this._errors.push(err);
-    var timeout = this._timeouts.shift();
-    if (timeout === undefined) {
-        if (this._cachedTimeouts) {
-            // retry forever, only keep last error
-            this._errors.splice(0, this._errors.length - 1);
-            timeout = this._cachedTimeouts.slice(-1);
-        }
-        else {
-            return false;
-        }
-    }
-    var self = this;
-    this._timer = setTimeout(function () {
-        self._attempts++;
-        if (self._operationTimeoutCb) {
-            self._timeout = setTimeout(function () {
-                self._operationTimeoutCb(self._attempts);
-            }, self._operationTimeout);
-            if (self._options.unref) {
-                self._timeout.unref();
-            }
-        }
-        self._fn(self._attempts);
-    }, timeout);
-    if (this._options.unref) {
-        this._timer.unref();
-    }
-    return true;
-};
-RetryOperation.prototype.attempt = function (fn, timeoutOps) {
-    this._fn = fn;
-    if (timeoutOps) {
-        if (timeoutOps.timeout) {
-            this._operationTimeout = timeoutOps.timeout;
-        }
-        if (timeoutOps.cb) {
-            this._operationTimeoutCb = timeoutOps.cb;
-        }
-    }
-    var self = this;
-    if (this._operationTimeoutCb) {
-        this._timeout = setTimeout(function () {
-            self._operationTimeoutCb();
-        }, self._operationTimeout);
-    }
-    this._operationStart = new Date().getTime();
-    this._fn(this._attempts);
-};
-RetryOperation.prototype.try = function (fn) {
-    // console.log("Using RetryOperation.try() is deprecated");
-    this.attempt(fn);
-};
-RetryOperation.prototype.start = function (fn) {
-    // console.log("Using RetryOperation.start() is deprecated");
-    this.attempt(fn);
-};
-RetryOperation.prototype.start = RetryOperation.prototype.try;
-RetryOperation.prototype.errors = function () {
-    return this._errors;
-};
-RetryOperation.prototype.attempts = function () {
-    return this._attempts;
-};
-RetryOperation.prototype.mainError = function () {
-    if (this._errors.length === 0) {
-        return null;
-    }
-    var counts = {};
-    var mainError = null;
-    var mainErrorCount = 0;
-    for (var i = 0; i < this._errors.length; i++) {
-        var error = this._errors[i];
-        var message = error.message;
-        var count = (counts[message] || 0) + 1;
-        counts[message] = count;
-        if (count >= mainErrorCount) {
-            mainError = error;
-            mainErrorCount = count;
-        }
-    }
-    return mainError;
-};
-exports.default = RetryOperation;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function RetryOperation(timeouts, options) {
+    this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
+    this._timeouts = timeouts;
+    this._options = options || {};
+    this._maxRetryTime = (options === null || options === void 0 ? void 0 : options.maxRetryTime) || Infinity;
+    this._fn = null;
+    this._errors = [];
+    this._attempts = 1;
+    this._operationTimeout = null;
+    this._operationTimeoutCb = null;
+    this._timeout = null;
+    this._operationStart = null;
+    this._timer = null;
+    if (this._options.forever) {
+        this._cachedTimeouts = this._timeouts.slice(0);
+    }
+}
+RetryOperation.prototype.reset = function () {
+    this._attempts = 1;
+    this._timeouts = this._originalTimeouts.slice(0);
+};
+RetryOperation.prototype.stop = function () {
+    if (this._timeout) {
+        clearTimeout(this._timeout);
+    }
+    if (this._timer) {
+        clearTimeout(this._timer);
+    }
+    this._timeouts = [];
+    this._cachedTimeouts = null;
+};
+RetryOperation.prototype.retry = function (err) {
+    var _this = this;
+    if (this._timeout) {
+        clearTimeout(this._timeout);
+    }
+    if (!err) {
+        return false;
+    }
+    var currentTime = new Date().getTime();
+    if (err && currentTime - this._operationStart >= this._maxRetryTime) {
+        this._errors.push(err);
+        this._errors.unshift(new Error("RetryOperation timeout occurred"));
+        return false;
+    }
+    this._errors.push(err);
+    var timeout = this._timeouts.shift();
+    if (timeout === undefined) {
+        if (this._cachedTimeouts) {
+            // retry forever, only keep last error
+            this._errors.splice(0, this._errors.length - 1);
+            timeout = this._cachedTimeouts.slice(-1);
+        }
+        else {
+            return false;
+        }
+    }
+    this._timer = setTimeout(function () {
+        _this._attempts++;
+        if (_this._operationTimeoutCb) {
+            _this._timeout = setTimeout(function () {
+                _this._operationTimeoutCb(_this._attempts);
+            }, _this._operationTimeout);
+            if (_this._options.unref) {
+                _this._timeout.unref();
+            }
+        }
+        _this._fn(_this._attempts);
+    }, timeout);
+    if (this._options.unref) {
+        this._timer.unref();
+    }
+    return true;
+};
+RetryOperation.prototype.attempt = function (fn, timeoutOps) {
+    var _this = this;
+    this._fn = fn;
+    if (timeoutOps) {
+        if (timeoutOps.timeout) {
+            this._operationTimeout = timeoutOps.timeout;
+        }
+        if (timeoutOps.cb) {
+            this._operationTimeoutCb = timeoutOps.cb;
+        }
+    }
+    if (this._operationTimeoutCb) {
+        this._timeout = setTimeout(function () {
+            _this._operationTimeoutCb();
+        }, this._operationTimeout);
+    }
+    this._operationStart = new Date().getTime();
+    this._fn(this._attempts);
+};
+RetryOperation.prototype.try = function (fn) {
+    // console.log("Using RetryOperation.try() is deprecated");
+    this.attempt(fn);
+};
+RetryOperation.prototype.start = function (fn) {
+    // console.log("Using RetryOperation.start() is deprecated");
+    this.attempt(fn);
+};
+RetryOperation.prototype.start = RetryOperation.prototype.try;
+RetryOperation.prototype.errors = function () {
+    return this._errors;
+};
+RetryOperation.prototype.attempts = function () {
+    return this._attempts;
+};
+RetryOperation.prototype.mainError = function () {
+    if (this._errors.length === 0) {
+        return null;
+    }
+    var counts = {};
+    var mainError = null;
+    var mainErrorCount = 0;
+    for (var i = 0; i < this._errors.length; i++) {
+        var error = this._errors[i];
+        var message = error.message;
+        var count = (counts[message] || 0) + 1;
+        counts[message] = count;
+        if (count >= mainErrorCount) {
+            mainError = error;
+            mainErrorCount = count;
+        }
+    }
+    return mainError;
+};
+exports.default = RetryOperation;

package/esm/Api.d.ts

@@ -1,35 +1,35 @@
-import Endpoint from "./Endpoint";
-import { ApiResponse, BaseRequestConfig, RequestConfig, RequestMiddleware } from "./ApiTypes";
-import RequestBackend from "./backend/RequestBackend";
-import EndpointBuilder from "./EndpointBuilder";
-import { ApiMockingConfig } from "./MockingTypes";
-export declare const getRequestBackend: () => RequestBackend | null;
-export declare const isRequestBackendDefault: () => boolean;
-export declare const setRequestBackend: (backend: RequestBackend) => void;
-export interface ApiInfo {
-    readonly name: string;
-    readonly baseUrl: string;
-    readonly middleware?: RequestMiddleware[];
-    readonly config?: BaseRequestConfig | (() => BaseRequestConfig);
-    readonly mocking?: ApiMockingConfig;
-    readonly requestBackend?: RequestBackend;
-}
-export declare class Api implements ApiInfo {
-    readonly baseUrl: string;
-    readonly name: string;
-    readonly middleware: RequestMiddleware[];
-    readonly config?: BaseRequestConfig | (() => BaseRequestConfig);
-    readonly mocking?: ApiMockingConfig;
-    readonly requestBackend: RequestBackend;
-    protected readonly endpoints: Record<string, Endpoint>;
-    constructor(info: ApiInfo);
-    endpoint(): EndpointBuilder;
-    getRequestBackend(): RequestBackend;
-    getConfig(): BaseRequestConfig;
-    private hotRequest;
-    get: <R = unknown>(path: string, config: RequestConfig) => Promise<ApiResponse<R>>;
-    post: <R = unknown>(path: string, config: RequestConfig) => Promise<ApiResponse<R>>;
-    put: <R = unknown>(path: string, config: RequestConfig) => Promise<ApiResponse<R>>;
-    delete: <R = unknown>(path: string, config: RequestConfig) => Promise<ApiResponse<R>>;
-    patch: <R = unknown>(path: string, config: RequestConfig) => Promise<ApiResponse<R>>;
-}
+import { ApiResponse, BaseRequestConfig, RequestConfig, RequestMiddleware } from "./ApiTypes";
+import Endpoint from "./Endpoint";
+import EndpointBuilder from "./EndpointBuilder";
+import { ApiMockingConfig } from "./MockingTypes";
+import RequestBackend from "./backend/RequestBackend";
+export declare const getRequestBackend: () => RequestBackend | null;
+export declare const isRequestBackendDefault: () => boolean;
+export declare const setRequestBackend: (backend: RequestBackend) => void;
+export interface ApiInfo {
+    readonly name: string;
+    readonly baseUrl: string;
+    readonly middleware?: RequestMiddleware[];
+    readonly config?: BaseRequestConfig | (() => BaseRequestConfig);
+    readonly mocking?: ApiMockingConfig;
+    readonly requestBackend?: RequestBackend;
+}
+export declare class Api implements ApiInfo {
+    readonly baseUrl: string;
+    readonly name: string;
+    readonly middleware: RequestMiddleware[];
+    readonly config?: BaseRequestConfig | (() => BaseRequestConfig);
+    readonly mocking?: ApiMockingConfig;
+    readonly requestBackend: RequestBackend;
+    protected readonly endpoints: Record<string, Endpoint>;
+    constructor(info: ApiInfo);
+    endpoint(): EndpointBuilder;
+    getRequestBackend(): RequestBackend;
+    getConfig(): BaseRequestConfig;
+    private hotRequest;
+    get: <R = unknown>(path: string, config: RequestConfig) => Promise<ApiResponse<R>>;
+    post: <R = unknown>(path: string, config: RequestConfig) => Promise<ApiResponse<R>>;
+    put: <R = unknown>(path: string, config: RequestConfig) => Promise<ApiResponse<R>>;
+    delete: <R = unknown>(path: string, config: RequestConfig) => Promise<ApiResponse<R>>;
+    patch: <R = unknown>(path: string, config: RequestConfig) => Promise<ApiResponse<R>>;
+}

package/esm/Api.js

@@ -1,98 +1,92 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import * as Requester from "./Requester";
-import EndpointBuilder from "./EndpointBuilder";
-import * as Utils from "./Utils";
-import FetchRequestBackend from "./backend/FetchRequestBackend";
-import { RequestMethod, } from "./ApiConstants";
-import { computeRequestConfig } from "./RequestConfig";
-// use fetch as default if it is present
-let requestBackend = Utils.getGlobalFetch() ? new FetchRequestBackend() : null;
-let requestBackendIsDefault = true;
-export const getRequestBackend = () => {
-    return requestBackend;
-};
-export const isRequestBackendDefault = () => {
-    return requestBackendIsDefault;
-};
-export const setRequestBackend = (backend) => {
-    requestBackendIsDefault = false;
-    requestBackend = backend;
-};
-class HotRequestHost {
-    constructor(api, path, method) {
-        this.responseType = undefined;
-        this.validation = {};
-        this.api = api;
-        this.method = method;
-        this.path = path;
-    }
-    get baseUrl() {
-        return this.api.baseUrl;
-    }
-    computeConfig(config) {
-        const apiDefaults = this.api.getConfig();
-        return computeRequestConfig([
-            apiDefaults,
-            config,
-        ]);
-    }
-    computePath(path, config) {
-        return path.startsWith("/") ? path : `/${path}`;
-    }
-    getRequestBackend() {
-        return this.api.getRequestBackend();
-    }
-}
-let defaultBackendMessageShown = false;
-export class Api {
-    constructor(info) {
-        var _a, _b;
-        this.endpoints = {};
-        this.hotRequest = (requestMethod) => (path, config) => __awaiter(this, void 0, void 0, function* () {
-            return (yield Requester.submit(new HotRequestHost(this, path, requestMethod), config, null));
-        });
-        this.get = this.hotRequest(RequestMethod.GET);
-        this.post = this.hotRequest(RequestMethod.POST);
-        this.put = this.hotRequest(RequestMethod.PUT);
-        this.delete = this.hotRequest(RequestMethod.DELETE);
-        this.patch = this.hotRequest(RequestMethod.PATCH);
-        this.name = info.name;
-        this.baseUrl = info.baseUrl;
-        this.middleware = info.middleware || [];
-        this.endpoints = {};
-        this.config = info.config;
-        this.mocking = (_a = info.mocking) !== null && _a !== void 0 ? _a : undefined;
-        const requestBackend = (_b = info.requestBackend) !== null && _b !== void 0 ? _b : getRequestBackend();
-        if (!requestBackend) {
-            throw new Error("[api-def] No request backend provided in either Api options or globally, use `setRequestBackend()` to set one or pass one via `requestBackend`");
-        }
-        this.requestBackend = requestBackend;
-        if (!info.requestBackend) {
-            if (process.env.NODE_ENV === "development") {
-                if (isRequestBackendDefault() && !defaultBackendMessageShown) {
-                    defaultBackendMessageShown = true;
-                    // eslint-disable-next-line
-                    console.warn("[api-def] Using default fetch backend, you can use a different one with 'setRequestBackend()' (dev only message)");
-                }
-            }
-        }
-    }
-    endpoint() {
-        return new EndpointBuilder(this);
-    }
-    getRequestBackend() {
-        return this.requestBackend;
-    }
-    getConfig() {
-        return ((typeof this.config === "function" ? this.config() : this.config) ||
-            {});
-    }
-}
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { RequestMethod } from "./ApiConstants";
+import EndpointBuilder from "./EndpointBuilder";
+import { computeRequestConfig } from "./RequestConfig";
+import * as Requester from "./Requester";
+import * as Utils from "./Utils";
+import FetchRequestBackend from "./backend/FetchRequestBackend";
+// use fetch as default if it is present
+let requestBackend = Utils.getGlobalFetch() ? new FetchRequestBackend() : null;
+let requestBackendIsDefault = true;
+export const getRequestBackend = () => {
+    return requestBackend;
+};
+export const isRequestBackendDefault = () => {
+    return requestBackendIsDefault;
+};
+export const setRequestBackend = (backend) => {
+    requestBackendIsDefault = false;
+    requestBackend = backend;
+};
+class HotRequestHost {
+    constructor(api, path, method) {
+        this.responseType = undefined;
+        this.validation = {};
+        this.api = api;
+        this.method = method;
+        this.path = path;
+    }
+    get baseUrl() {
+        return this.api.baseUrl;
+    }
+    computeConfig(config) {
+        const apiDefaults = this.api.getConfig();
+        return computeRequestConfig([apiDefaults, config]);
+    }
+    computePath(path, config) {
+        return path.startsWith("/") ? path : `/${path}`;
+    }
+    getRequestBackend() {
+        return this.api.getRequestBackend();
+    }
+}
+let defaultBackendMessageShown = false;
+export class Api {
+    constructor(info) {
+        var _a, _b;
+        this.endpoints = {};
+        this.hotRequest = (requestMethod) => (path, config) => __awaiter(this, void 0, void 0, function* () { return yield Requester.submit(new HotRequestHost(this, path, requestMethod), config, null); });
+        this.get = this.hotRequest(RequestMethod.GET);
+        this.post = this.hotRequest(RequestMethod.POST);
+        this.put = this.hotRequest(RequestMethod.PUT);
+        this.delete = this.hotRequest(RequestMethod.DELETE);
+        this.patch = this.hotRequest(RequestMethod.PATCH);
+        this.name = info.name;
+        this.baseUrl = info.baseUrl;
+        this.middleware = info.middleware || [];
+        this.endpoints = {};
+        this.config = info.config;
+        this.mocking = (_a = info.mocking) !== null && _a !== void 0 ? _a : undefined;
+        const requestBackend = (_b = info.requestBackend) !== null && _b !== void 0 ? _b : getRequestBackend();
+        if (!requestBackend) {
+            throw new Error("[api-def] No request backend provided in either Api options or globally, use `setRequestBackend()` to set one or pass one via `requestBackend`");
+        }
+        this.requestBackend = requestBackend;
+        if (!info.requestBackend) {
+            if (process.env.NODE_ENV === "development") {
+                if (isRequestBackendDefault() && !defaultBackendMessageShown) {
+                    defaultBackendMessageShown = true;
+                    // eslint-disable-next-line
+                    console.warn("[api-def] Using default fetch backend, you can use a different one with 'setRequestBackend()' (dev only message)");
+                }
+            }
+        }
+    }
+    endpoint() {
+        return new EndpointBuilder(this);
+    }
+    getRequestBackend() {
+        return this.requestBackend;
+    }
+    getConfig() {
+        return (typeof this.config === "function" ? this.config() : this.config) || {};
+    }
+}

package/esm/ApiConstants.d.ts

@@ -1,58 +1,58 @@
-import { EnumOf } from "./Utils";
-export declare const RequestMethod: {
-    /** @deprecated use 'POST' */
-    readonly Post: "post";
-    /** @deprecated use 'GET' */
-    readonly Get: "get";
-    readonly POST: "post";
-    readonly GET: "get";
-    readonly PUT: "put";
-    readonly DELETE: "delete";
-    readonly PATCH: "patch";
-};
-export declare type RequestMethod = EnumOf<typeof RequestMethod>;
-export declare const RequestEvent: {
-    /** @deprecated use 'BEFORE_SEND' */
-    readonly BeforeSend: "beforeSend";
-    /** @deprecated use 'SUCCESS' */
-    readonly Success: "success";
-    /** @deprecated use 'ERROR' */
-    readonly Error: "error";
-    /** @deprecated use 'UNRECOVERABLE_ERROR' */
-    readonly UnrecoverableError: "unrecoverableError";
-    readonly BEFORE_SEND: "beforeSend";
-    readonly SUCCESS: "success";
-    readonly ERROR: "error";
-    readonly UNRECOVERABLE_ERROR: "unrecoverableError";
-};
-export declare type RequestEvent = EnumOf<typeof RequestEvent>;
-export declare const EventResultType: {
-    /** @deprecated use 'RESPOND' */
-    readonly Respond: "respond";
-    /** @deprecated use 'RETRY' */
-    readonly Retry: "retry";
-    readonly RESPOND: "respond";
-    readonly RETRY: "retry";
-};
-export declare type EventResultType = EnumOf<typeof EventResultType>;
-export declare const CacheSource: {
-    /** @deprecated use 'API' */
-    readonly Api: "api";
-    /** @deprecated use 'LOCAL' */
-    readonly Local: "local";
-    readonly API: "api";
-    readonly LOCAL: "local";
-};
-export declare type CacheSource = EnumOf<typeof CacheSource>;
-export declare const ResponseType: {
-    /** @deprecated use 'JSON' */
-    readonly Json: "json";
-    /** @deprecated use 'TEXT' */
-    readonly Text: "text";
-    /** @deprecated use 'ARRAY_BUFFER' */
-    readonly ArrayBuffer: "arraybuffer";
-    readonly JSON: "json";
-    readonly TEXT: "text";
-    readonly ARRAY_BUFFER: "arraybuffer";
-};
-export declare type ResponseType = EnumOf<typeof ResponseType>;
+import { EnumOf } from "./Utils";
+export declare const RequestMethod: {
+    /** @deprecated use 'POST' */
+    readonly Post: "post";
+    /** @deprecated use 'GET' */
+    readonly Get: "get";
+    readonly POST: "post";
+    readonly GET: "get";
+    readonly PUT: "put";
+    readonly DELETE: "delete";
+    readonly PATCH: "patch";
+};
+export type RequestMethod = EnumOf<typeof RequestMethod>;
+export declare const RequestEvent: {
+    /** @deprecated use 'BEFORE_SEND' */
+    readonly BeforeSend: "beforeSend";
+    /** @deprecated use 'SUCCESS' */
+    readonly Success: "success";
+    /** @deprecated use 'ERROR' */
+    readonly Error: "error";
+    /** @deprecated use 'UNRECOVERABLE_ERROR' */
+    readonly UnrecoverableError: "unrecoverableError";
+    readonly BEFORE_SEND: "beforeSend";
+    readonly SUCCESS: "success";
+    readonly ERROR: "error";
+    readonly UNRECOVERABLE_ERROR: "unrecoverableError";
+};
+export type RequestEvent = EnumOf<typeof RequestEvent>;
+export declare const EventResultType: {
+    /** @deprecated use 'RESPOND' */
+    readonly Respond: "respond";
+    /** @deprecated use 'RETRY' */
+    readonly Retry: "retry";
+    readonly RESPOND: "respond";
+    readonly RETRY: "retry";
+};
+export type EventResultType = EnumOf<typeof EventResultType>;
+export declare const CacheSource: {
+    /** @deprecated use 'API' */
+    readonly Api: "api";
+    /** @deprecated use 'LOCAL' */
+    readonly Local: "local";
+    readonly API: "api";
+    readonly LOCAL: "local";
+};
+export type CacheSource = EnumOf<typeof CacheSource>;
+export declare const ResponseType: {
+    /** @deprecated use 'JSON' */
+    readonly Json: "json";
+    /** @deprecated use 'TEXT' */
+    readonly Text: "text";
+    /** @deprecated use 'ARRAY_BUFFER' */
+    readonly ArrayBuffer: "arraybuffer";
+    readonly JSON: "json";
+    readonly TEXT: "text";
+    readonly ARRAY_BUFFER: "arraybuffer";
+};
+export type ResponseType = EnumOf<typeof ResponseType>;