@runware/sdk-js 1.1.11 → 1.1.13

package/dist/esm/Runware/Runware-server.d.ts

@@ -0,0 +1,14 @@
+import { RunwareBase } from "./Runware-base";
+import { RunwareBaseType } from "./types";
+export declare class RunwareServer extends RunwareBase {
+    _instantiated: boolean;
+    _listeners: any[];
+    _reconnectingIntervalId: null | any;
+    _pingTimeout: any;
+    _pongListener: any;
+    constructor({ apiKey, url }: RunwareBaseType);
+    protected connect(): Promise<void>;
+    protected send: (msg: Object) => void;
+    protected handleClose(): void;
+    protected heartBeat(): void;
+}

package/dist/esm/Runware/Runware-server.js

@@ -0,0 +1,155 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunwareServer = void 0;
+// @ts-ignore
+// import ReconnectingWebsocket from "./reconnect";
+const ws_1 = __importDefault(require("ws"));
+const Runware_base_1 = require("./Runware-base");
+const types_1 = require("./types");
+// let allImages: IImage[] = [];
+class RunwareServer extends Runware_base_1.RunwareBase {
+    constructor({ apiKey, url }) {
+        super({ apiKey, url });
+        this._instantiated = false;
+        this._listeners = [];
+        this._reconnectingIntervalId = null;
+        this.send = (msg) => {
+            this._ws.send(JSON.stringify([msg]));
+        };
+        this._sdkType = types_1.SdkType.SERVER;
+        if (apiKey) {
+            this.connect();
+        }
+    }
+    // protected addListener({
+    //   lis,
+    //   check,
+    //   groupKey,
+    // }: {
+    //   lis: (v: any) => any;
+    //   check: (v: any) => any;
+    //   groupKey?: string;
+    // }) {
+    //   const listener = (msg: any) => {
+    //     if (msg?.error) {
+    //       lis(msg);
+    //     } else if (check(msg)) {
+    //       lis(msg);
+    //     }
+    //   };
+    //   const groupListener = { key: getUUID(), listener, groupKey };
+    //   this._listeners.push(groupListener);
+    //   const destroy = () => {
+    //     this._listeners = removeListener(this._listeners, groupListener);
+    //   };
+    //   return {
+    //     destroy,
+    //   };
+    // }
+    async connect() {
+        if (!this._url)
+            return;
+        this._ws = new ws_1.default(this._url, {
+            perMessageDeflate: false,
+        });
+        // delay(1);
+        this._ws.on("error", () => { });
+        this._ws.on("close", () => {
+            this.handleClose();
+        });
+        this._ws.on("open", () => {
+            if (this._reconnectingIntervalId) {
+                clearInterval(this._reconnectingIntervalId);
+            }
+            if (this._connectionSessionUUID && this.isWebsocketReadyState()) {
+                this.send({
+                    taskType: types_1.ETaskType.AUTHENTICATION,
+                    apiKey: this._apiKey,
+                    connectionSessionUUID: this._connectionSessionUUID,
+                });
+            }
+            else {
+                if (this.isWebsocketReadyState()) {
+                    this.send({
+                        apiKey: this._apiKey,
+                        taskType: types_1.ETaskType.AUTHENTICATION,
+                    });
+                }
+            }
+            this.addListener({
+                taskUUID: types_1.ETaskType.AUTHENTICATION,
+                lis: (m) => {
+                    var _a, _b;
+                    if (m === null || m === void 0 ? void 0 : m.error) {
+                        this._invalidAPIkey = "Invalid API key";
+                        return;
+                    }
+                    this._connectionSessionUUID =
+                        (_b = (_a = m === null || m === void 0 ? void 0 : m[types_1.ETaskType.AUTHENTICATION]) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.connectionSessionUUID;
+                    this._invalidAPIkey = undefined;
+                },
+            });
+            // this.addListener({
+            //   check: (m) => m?.newConnectionSessionUUID?.connectionSessionUUID,
+            //   lis: (m) => {
+            //     if (m?.error) {
+            //       if (m.errorId === 19) {
+            //         this._invalidAPIkey = "Invalid API key";
+            //       } else {
+            //         this._invalidAPIkey = "Error connection ";
+            //       }
+            //       return;
+            //     }
+            //     this._connectionSessionUUID =
+            //       m?.newConnectionSessionUUID?.connectionSessionUUID;
+            //     this._invalidAPIkey = undefined;
+            //     this.heartBeat();
+            //   },
+            // });
+            // this._pongListener?.destroy();
+            // this._pongListener = this.addListener({
+            //   check: (m) => m?.pong,
+            //   lis: (m) => {
+            //     // console.log({ m });
+            //     if (m.pong) {
+            //       this.heartBeat();
+            //     }
+            //   },
+            // });
+        });
+        this._ws.on("message", (e, isBinary) => {
+            const data = isBinary ? e : e === null || e === void 0 ? void 0 : e.toString();
+            if (!data)
+                return;
+            const m = JSON.parse(data);
+            this._listeners.forEach((lis) => {
+                const result = lis.listener(m);
+                if (result) {
+                    return;
+                }
+            });
+        });
+    }
+    handleClose() {
+        if (this._invalidAPIkey) {
+            console.error(this._invalidAPIkey);
+            return;
+        }
+        if (this._reconnectingIntervalId) {
+            clearInterval(this._reconnectingIntervalId);
+        }
+        // this._reconnectingIntervalId = setInterval(() => this.connect(), 1000);
+    }
+    heartBeat() {
+        clearTimeout(this._pingTimeout);
+        this._pingTimeout = setTimeout(() => {
+            if (this.isWebsocketReadyState()) {
+                this.send({ ping: true });
+            }
+        }, 5000);
+    }
+}
+exports.RunwareServer = RunwareServer;

package/dist/esm/Runware/Runware.d.ts

@@ -0,0 +1,4 @@
+import { RunwareClient } from "./Runware-client";
+import { RunwareServer } from "./Runware-server";
+declare let Runware: typeof RunwareClient | typeof RunwareServer;
+export { Runware };

package/dist/esm/Runware/Runware.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Runware = void 0;
+// @ts-ignore
+const Runware_client_1 = require("./Runware-client");
+const Runware_server_1 = require("./Runware-server");
+let Runware;
+if (typeof window === "undefined") {
+    exports.Runware = Runware = Runware_server_1.RunwareServer;
+}
+else {
+    exports.Runware = Runware = Runware_client_1.RunwareClient;
+}

package/dist/esm/Runware/async-retry.d.ts

@@ -0,0 +1,5 @@
+export declare const asyncRetry: (apiCall: Function, options?: {
+    maxRetries?: number;
+    delayInSeconds?: number;
+    callback?: Function;
+}) => Promise<any>;

package/dist/esm/Runware/async-retry.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asyncRetry = void 0;
+const utils_1 = require("./utils");
+const asyncRetry = async (apiCall, options = {}) => {
+    var _a;
+    const { delayInSeconds = 1, callback } = options;
+    let maxRetries = (_a = options.maxRetries) !== null && _a !== void 0 ? _a : 1;
+    while (maxRetries) {
+        try {
+            const result = await apiCall();
+            return result; // Return the result if successful
+        }
+        catch (error) {
+            callback === null || callback === void 0 ? void 0 : callback();
+            maxRetries--;
+            if (maxRetries > 0) {
+                await (0, utils_1.delay)(delayInSeconds); // Delay before the next retry
+                await (0, exports.asyncRetry)(apiCall, Object.assign(Object.assign({}, options), { maxRetries }));
+            }
+            else {
+                throw error; // Throw the error if max retries are reached
+            }
+        }
+    }
+};
+exports.asyncRetry = asyncRetry;

package/dist/esm/Runware/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./Runware-client";
+export * from "./types";
+export * from "./Runware-server";
+export * from "./Runware";

package/dist/esm/Runware/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Runware-client"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./Runware-server"), exports);
+__exportStar(require("./Runware"), exports);

package/dist/esm/Runware/reconnect.d.ts

@@ -0,0 +1,11 @@
+type Options = {
+    constructor?: new (url: string, protocols?: string | string[]) => WebSocket;
+    maxReconnectionDelay?: number;
+    minReconnectionDelay?: number;
+    reconnectionDelayGrowFactor?: number;
+    connectionTimeout?: number;
+    maxRetries?: number;
+    debug?: boolean;
+};
+declare const ReconnectingWebsocket: (url: string, protocols?: string | string[], options?: Options) => void;
+export = ReconnectingWebsocket;

package/dist/esm/Runware/reconnect.js

@@ -0,0 +1,175 @@
+"use strict";
+const isWebSocket = (constructor) => constructor && constructor.CLOSING === 2;
+const isGlobalWebSocket = () => typeof WebSocket !== "undefined" && isWebSocket(WebSocket);
+const getDefaultOptions = () => ({
+    constructor: isGlobalWebSocket() ? WebSocket : null,
+    maxReconnectionDelay: 10000,
+    minReconnectionDelay: 1500,
+    reconnectionDelayGrowFactor: 1.3,
+    connectionTimeout: 4000,
+    maxRetries: Infinity,
+    debug: false,
+});
+const bypassProperty = (src, dst, name) => {
+    Object.defineProperty(dst, name, {
+        get: () => src[name],
+        set: (value) => {
+            src[name] = value;
+        },
+        enumerable: true,
+        configurable: true,
+    });
+};
+const initReconnectionDelay = (config) => config.minReconnectionDelay + Math.random() * config.minReconnectionDelay;
+const updateReconnectionDelay = (config, previousDelay) => {
+    const newDelay = previousDelay * config.reconnectionDelayGrowFactor;
+    return newDelay > config.maxReconnectionDelay
+        ? config.maxReconnectionDelay
+        : newDelay;
+};
+const LEVEL_0_EVENTS = ["onopen", "onclose", "onmessage", "onerror"];
+const reassignEventListeners = (ws, oldWs, listeners) => {
+    Object.keys(listeners).forEach((type) => {
+        listeners[type].forEach(([listener, options]) => {
+            ws.addEventListener(type, listener, options);
+        });
+    });
+    if (oldWs) {
+        LEVEL_0_EVENTS.forEach((name) => {
+            ws[name] = oldWs[name];
+        });
+    }
+};
+const ReconnectingWebsocket = function (url, protocols, options = {}) {
+    let ws;
+    let connectingTimeout;
+    let reconnectDelay = 0;
+    let retriesCount = 0;
+    let shouldRetry = true;
+    const listeners = {};
+    // require new to construct
+    if (!(this instanceof ReconnectingWebsocket)) {
+        throw new TypeError("Failed to construct 'ReconnectingWebSocket': Please use the 'new' operator");
+    }
+    // Set config. Not using `Object.assign` because of IE11
+    const config = getDefaultOptions();
+    Object.keys(config)
+        .filter((key) => options.hasOwnProperty(key))
+        .forEach((key) => (config[key] = options[key]));
+    if (!isWebSocket(config.constructor)) {
+        throw new TypeError("Invalid WebSocket constructor. Set `options.constructor`");
+    }
+    const log = config.debug
+        ? (...params) => console.log("RWS:", ...params)
+        : () => { };
+    /**
+     * Not using dispatchEvent, otherwise we must use a DOM Event object
+     * Deferred because we want to handle the close event before this
+     */
+    const emitError = (code, msg) => setTimeout(() => {
+        const err = new Error(msg);
+        err.code = code;
+        if (Array.isArray(listeners.error)) {
+            listeners.error.forEach(([fn]) => fn(err));
+        }
+        if (ws.onerror) {
+            ws.onerror(err);
+        }
+    }, 0);
+    const handleClose = () => {
+        log("close");
+        retriesCount++;
+        log("retries count:", retriesCount);
+        if (retriesCount > config.maxRetries) {
+            emitError("EHOSTDOWN", "Too many failed connection attempts");
+            return;
+        }
+        if (!reconnectDelay) {
+            reconnectDelay = initReconnectionDelay(config);
+        }
+        else {
+            reconnectDelay = updateReconnectionDelay(config, reconnectDelay);
+        }
+        log("reconnectDelay:", reconnectDelay);
+        if (shouldRetry) {
+            setTimeout(connect, reconnectDelay);
+        }
+    };
+    const connect = () => {
+        log("connect");
+        const oldWs = ws;
+        ws = new config.constructor(url, protocols);
+        connectingTimeout = setTimeout(() => {
+            log("timeout");
+            ws.close();
+            emitError("ETIMEDOUT", "Connection timeout");
+        }, config.connectionTimeout);
+        log("bypass properties");
+        for (let key in ws) {
+            // @todo move to constant
+            if (["addEventListener", "removeEventListener", "close", "send"].indexOf(key) < 0) {
+                bypassProperty(ws, this, key);
+            }
+        }
+        ws.addEventListener("open", () => {
+            clearTimeout(connectingTimeout);
+            log("open");
+            reconnectDelay = initReconnectionDelay(config);
+            log("reconnectDelay:", reconnectDelay);
+            retriesCount = 0;
+        });
+        ws.addEventListener("close", handleClose);
+        reassignEventListeners(ws, oldWs, listeners);
+    };
+    log("init");
+    connect();
+    this.close = (code = 1000, reason = "", { keepClosed = false, fastClose = true, delay = 0 } = {}) => {
+        if (delay) {
+            reconnectDelay = delay;
+        }
+        shouldRetry = !keepClosed;
+        ws.close(code, reason);
+        if (fastClose) {
+            const fakeCloseEvent = {
+                code,
+                reason,
+                wasClean: true,
+            };
+            // execute close listeners soon with a fake closeEvent
+            // and remove all close listeners from the WS instance
+            // so they don't get fired on the real close.
+            handleClose();
+            if (Array.isArray(listeners.close)) {
+                listeners.close.forEach(([listener, options]) => {
+                    listener(fakeCloseEvent);
+                    ws.removeEventListener("close", listener, options);
+                });
+            }
+            if (ws.onclose) {
+                ws.onclose(fakeCloseEvent);
+                ws.onclose = null;
+            }
+        }
+    };
+    this.send = (data) => {
+        ws.send(data);
+    };
+    this.addEventListener = (type, listener, options) => {
+        if (Array.isArray(listeners[type])) {
+            if (!listeners[type].some(([l]) => l === listener)) {
+                listeners[type].push([listener, options]);
+            }
+        }
+        else {
+            listeners[type] = [[listener, options]];
+        }
+        ws.addEventListener(type, listener, options);
+    };
+    this.removeEventListener = (type, listener, options) => {
+        if (Array.isArray(listeners[type])) {
+            listeners[type] = listeners[type].filter(([l]) => l !== listener);
+        }
+        ws.removeEventListener(type, listener, options);
+    };
+};
+module.exports = ReconnectingWebsocket;

package/dist/esm/Runware/types.d.ts

@@ -0,0 +1,244 @@
+export declare enum Environment {
+    PRODUCTION = "PRODUCTION",
+    DEVELOPMENT = "DEVELOPMENT",
+    TEST = "TEST"
+}
+export declare enum SdkType {
+    CLIENT = "CLIENT",
+    SERVER = "SERVER"
+}
+export declare enum ETaskType {
+    IMAGE_INFERENCE = "imageInference",
+    IMAGE_UPLOAD = "imageUpload",
+    IMAGE_UPSCALE = "imageUpscale",
+    IMAGE_BACKGROUND_REMOVAL = "imageBackgroundRemoval",
+    IMAGE_CAPTION = "imageCaption",
+    IMAGE_CONTROL_NET_PRE_PROCESS = "imageControlNetPreProcess",
+    PROMPT_ENHANCE = "promptEnhance",
+    AUTHENTICATION = "authentication"
+}
+export type RunwareBaseType = {
+    apiKey: string;
+    url?: string;
+};
+export type IOutputType = "base64Data" | "dataURI" | "URL";
+export type IOutputFormat = "JPG" | "PNG" | "WEBP";
+export interface IImage {
+    taskType: ETaskType;
+    imageUUID: string;
+    inputImageUUID?: string;
+    taskUUID: string;
+    imageURL?: string;
+    imageBase64Data?: string;
+    imageDataURI?: string;
+    NSFWContent?: boolean;
+    cost?: number;
+}
+export interface ITextToImage extends IImage {
+    positivePrompt?: string;
+    negativePrompt?: string;
+}
+export interface IControlNetImage {
+    taskUUID: string;
+    inputImageUUID: string;
+    guideImageUUID: string;
+    guideImageURL?: string;
+    guideImageBase64Data?: string;
+    guideImageDataURI?: string;
+    cost?: number;
+}
+interface ILora {
+    model: string | number;
+    weight: number;
+}
+export declare enum EControlMode {
+    BALANCED = "balanced",
+    PROMPT = "prompt",
+    CONTROL_NET = "controlnet"
+}
+export type IControlNetGeneral = {
+    model: string;
+    guideImage: string | File;
+    weight?: number;
+    startStep?: number;
+    startStepPercentage?: number;
+    endStep?: number;
+    endStepPercentage?: number;
+    controlMode: EControlMode;
+};
+export type IControlNetPreprocess = {
+    inputImage: string | File;
+    preProcessor: EPreProcessor;
+    height?: number;
+    width?: number;
+    outputType?: IOutputType;
+    outputFormat?: IOutputFormat;
+    highThresholdCanny?: number;
+    lowThresholdCanny?: number;
+    includeHandsAndFaceOpenPose?: boolean;
+    includeCost?: boolean;
+    customTaskUUID?: string;
+};
+export type IControlNet = IControlNetGeneral;
+export type IControlNetWithUUID = Omit<IControlNet, "guideImage"> & {
+    guideImage?: string;
+};
+export interface IError {
+    error: boolean;
+    errorMessage: string;
+    taskUUID: string;
+}
+export interface IRequestImage {
+    outputType?: IOutputType;
+    outputFormat?: IOutputFormat;
+    uploadEndpoint?: string;
+    checkNsfw?: boolean;
+    positivePrompt: string;
+    negativePrompt?: string;
+    seedImage?: File | string;
+    maskImage?: File | string;
+    strength?: number;
+    height?: number;
+    width?: number;
+    model: number | string;
+    steps?: number;
+    scheduler?: string;
+    seed?: number;
+    CFGScale?: number;
+    clipSkip?: number;
+    usePromptWeighting?: boolean;
+    numberResults?: number;
+    controlNet?: IControlNet[];
+    lora?: ILora[];
+    includeCost?: boolean;
+    customTaskUUID?: string;
+    onPartialImages?: (images: IImage[], error?: IError) => void;
+    retry?: number;
+}
+export interface IRequestImageToText {
+    inputImage?: File | string;
+    includeCost?: boolean;
+    customTaskUUID?: string;
+}
+export interface IImageToText {
+    taskType: ETaskType;
+    taskUUID: string;
+    text: string;
+    cost?: number;
+}
+export interface IRemoveImageBackground extends IRequestImageToText {
+    outputType?: IOutputType;
+    outputFormat?: IOutputFormat;
+    rgba?: number[];
+    postProcessMask?: boolean;
+    returnOnlyMask?: boolean;
+    alphaMatting?: boolean;
+    alphaMattingForegroundThreshold?: number;
+    alphaMattingBackgroundThreshold?: number;
+    alphaMattingErodeSize?: number;
+    includeCost?: boolean;
+}
+export interface IRemoveImage {
+    taskType: ETaskType;
+    taskUUID: string;
+    imageUUID: string;
+    inputImageUUID: string;
+    imageURL?: string;
+    imageBase64Data?: string;
+    imageDataURI?: string;
+    cost?: number;
+}
+export interface IPromptEnhancer {
+    promptMaxLength?: number;
+    promptVersions?: number;
+    prompt: string;
+    includeCost?: boolean;
+    customTaskUUID?: string;
+}
+export interface IEnhancedPrompt extends IImageToText {
+}
+export interface IUpscaleGan {
+    inputImage: File | string;
+    upscaleFactor: number;
+    outputType?: IOutputType;
+    outputFormat?: IOutputFormat;
+    includeCost?: boolean;
+    customTaskUUID?: string;
+}
+export type ReconnectingWebsocketProps = {
+    addEventListener: (type: string, listener: EventListener, options: any) => void;
+    send: (data: any) => void;
+} & WebSocket;
+export type UploadImageType = {
+    imageURL: string;
+    imageUUID: string;
+    taskUUID: string;
+    taskType: ETaskType;
+};
+export type GetWithPromiseCallBackType = ({ resolve, reject, intervalId, }: {
+    resolve: <T>(value: T) => void;
+    reject: <T>(value: T) => void;
+    intervalId: any;
+}) => boolean | undefined;
+export declare enum EPreProcessorGroup {
+    "canny" = "canny",
+    "depth" = "depth",
+    "mlsd" = "mlsd",
+    "normalbae" = "normalbae",
+    "openpose" = "openpose",
+    "tile" = "tile",
+    "seg" = "seg",
+    "lineart" = "lineart",
+    "lineart_anime" = "lineart_anime",
+    "shuffle" = "shuffle",
+    "scribble" = "scribble",
+    "softedge" = "softedge"
+}
+export declare enum EPreProcessor {
+    "canny" = "canny",
+    "depth_leres" = "depth_leres",
+    "depth_midas" = "depth_midas",
+    "depth_zoe" = "depth_zoe",
+    "inpaint_global_harmonious" = "inpaint_global_harmonious",
+    "lineart_anime" = "lineart_anime",
+    "lineart_coarse" = "lineart_coarse",
+    "lineart_realistic" = "lineart_realistic",
+    "lineart_standard" = "lineart_standard",
+    "mlsd" = "mlsd",
+    "normal_bae" = "normal_bae",
+    "scribble_hed" = "scribble_hed",
+    "scribble_pidinet" = "scribble_pidinet",
+    "seg_ofade20k" = "seg_ofade20k",
+    "seg_ofcoco" = "seg_ofcoco",
+    "seg_ufade20k" = "seg_ufade20k",
+    "shuffle" = "shuffle",
+    "softedge_hed" = "softedge_hed",
+    "softedge_hedsafe" = "softedge_hedsafe",
+    "softedge_pidinet" = "softedge_pidinet",
+    "softedge_pidisafe" = "softedge_pidisafe",
+    "tile_gaussian" = "tile_gaussian",
+    "openpose" = "openpose",
+    "openpose_face" = "openpose_face",
+    "openpose_faceonly" = "openpose_faceonly",
+    "openpose_full" = "openpose_full",
+    "openpose_hand" = "openpose_hand"
+}
+export declare enum EOpenPosePreProcessor {
+    "openpose" = "openpose",
+    "openpose_face" = "openpose_face",
+    "openpose_faceonly" = "openpose_faceonly",
+    "openpose_full" = "openpose_full",
+    "openpose_hand" = "openpose_hand"
+}
+export type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
+    [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
+}[Keys];
+export type RequireOnlyOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
+    [K in Keys]-?: Required<Pick<T, K>> & Partial<Record<Exclude<Keys, K>, undefined>>;
+}[Keys];
+export type ListenerType = {
+    key: string;
+    listener: (msg: any) => void;
+    groupKey?: string;
+};
+export {};