@cloudbase/database 1.4.2 → 1.4.3

package/dist/esm/config/app.config.js

@@ -0,0 +1,5 @@
+export default {
+    db_doc_size_limit: 512 * 1024,
+    db_realtime_ping_interval: 15 * 1000,
+    db_realtime_pong_wait_timeout: 15 * 1000,
+};

package/dist/esm/config/error.config.d.ts

@@ -0,0 +1,3 @@
+export declare const ERR_CODE: {
+    [key: string]: string | number;
+};

package/dist/esm/config/error.config.js

@@ -0,0 +1,13 @@
+export const ERR_CODE = {
+    UNKNOWN_ERROR: 'UNKNOWN_ERROR',
+    SDK_DATABASE_REALTIME_LISTENER_INIT_WATCH_FAIL: 'SDK_DATABASE_REALTIME_LISTENER_INIT_WATCH_FAIL',
+    SDK_DATABASE_REALTIME_LISTENER_RECONNECT_WATCH_FAIL: 'SDK_DATABASE_REALTIME_LISTENER_RECONNECT_WATCH_FAIL',
+    SDK_DATABASE_REALTIME_LISTENER_REBUILD_WATCH_FAIL: 'SDK_DATABASE_REALTIME_LISTENER_REBUILD_WATCH_FAIL',
+    SDK_DATABASE_REALTIME_LISTENER_CLOSE_WATCH_FAIL: 'SDK_DATABASE_REALTIME_LISTENER_CLOSE_WATCH_FAIL',
+    SDK_DATABASE_REALTIME_LISTENER_SERVER_ERROR_MSG: 'SDK_DATABASE_REALTIME_LISTENER_SERVER_ERROR_MSG',
+    SDK_DATABASE_REALTIME_LISTENER_RECEIVE_INVALID_SERVER_DATA: 'SDK_DATABASE_REALTIME_LISTENER_RECEIVE_INVALID_SERVER_DATA',
+    SDK_DATABASE_REALTIME_LISTENER_WEBSOCKET_CONNECTION_ERROR: 'SDK_DATABASE_REALTIME_LISTENER_WEBSOCKET_CONNECTION_ERROR',
+    SDK_DATABASE_REALTIME_LISTENER_WEBSOCKET_CONNECTION_CLOSED: 'SDK_DATABASE_REALTIME_LISTENER_WEBSOCKET_CONNECTION_CLOSED',
+    SDK_DATABASE_REALTIME_LISTENER_CHECK_LAST_FAIL: 'SDK_DATABASE_REALTIME_LISTENER_CHECK_LAST_FAIL',
+    SDK_DATABASE_REALTIME_LISTENER_UNEXPECTED_FATAL_ERROR: 'SDK_DATABASE_REALTIME_LISTENER_UNEXPECTED_FATAL_ERROR'
+};

package/dist/esm/const/code.d.ts

@@ -0,0 +1,34 @@
+export declare const ERRORS: {
+    CREATE_WATCH_NET_ERROR: {
+        code: string;
+        message: string;
+    };
+    CREATE_WACTH_EXCEED_ERROR: {
+        code: string;
+        message: string;
+    };
+    CREATE_WATCH_SERVER_ERROR: {
+        code: string;
+        message: string;
+    };
+    CONN_ERROR: {
+        code: string;
+        message: string;
+    };
+    INVALID_PARAM: {
+        code: string;
+        message: string;
+    };
+    INSERT_DOC_FAIL: {
+        code: string;
+        message: string;
+    };
+    DATABASE_TRANSACTION_CONFLICT: {
+        code: string;
+        message: string;
+    };
+    DATABASE_REQUEST_FAILED: {
+        code: string;
+        message: string;
+    };
+};

package/dist/esm/const/code.js

@@ -0,0 +1,34 @@
+export const ERRORS = {
+    CREATE_WATCH_NET_ERROR: {
+        code: 'CREATE_WATCH_NET_ERROR',
+        message: 'create watch network error'
+    },
+    CREATE_WACTH_EXCEED_ERROR: {
+        code: 'CREATE_WACTH_EXCEED_ERROR',
+        message: 'maximum connections exceed'
+    },
+    CREATE_WATCH_SERVER_ERROR: {
+        code: 'CREATE_WATCH_SERVER_ERROR',
+        message: 'create watch server error'
+    },
+    CONN_ERROR: {
+        code: 'CONN_ERROR',
+        message: 'connection error'
+    },
+    INVALID_PARAM: {
+        code: 'INVALID_PARAM',
+        message: 'Invalid request param'
+    },
+    INSERT_DOC_FAIL: {
+        code: 'INSERT_DOC_FAIL',
+        message: 'insert document failed'
+    },
+    DATABASE_TRANSACTION_CONFLICT: {
+        code: 'DATABASE_TRANSACTION_CONFLICT',
+        message: 'database transaction conflict'
+    },
+    DATABASE_REQUEST_FAILED: {
+        code: 'DATABASE_REQUEST_FAILED',
+        message: 'database request failed'
+    }
+};

package/dist/esm/constant.d.ts

@@ -0,0 +1,54 @@
+declare enum ErrorCode {
+    DocIDError = "\u6587\u6863ID\u4E0D\u5408\u6CD5",
+    CollNameError = "\u96C6\u5408\u540D\u79F0\u4E0D\u5408\u6CD5",
+    OpStrError = "\u64CD\u4F5C\u7B26\u4E0D\u5408\u6CD5",
+    DirectionError = "\u6392\u5E8F\u5B57\u7B26\u4E0D\u5408\u6CD5",
+    IntergerError = "must be integer",
+    BooleanError = "must be boolean",
+    ArrayError = "must be array",
+    QueryParamTypeError = "\u67E5\u8BE2\u53C2\u6570\u5FC5\u987B\u4E3A\u5BF9\u8C61",
+    QueryParamValueError = "\u67E5\u8BE2\u53C2\u6570\u5BF9\u8C61\u503C\u4E0D\u80FD\u5747\u4E3Aundefined",
+    CentersPhereError = "centersPhere\u7ED3\u6784\u4E0D\u5408\u6CD5"
+}
+declare const FieldType: {
+    String: string;
+    Number: string;
+    Object: string;
+    Array: string;
+    Boolean: string;
+    Null: string;
+    GeoPoint: string;
+    GeoLineString: string;
+    GeoPolygon: string;
+    GeoMultiPoint: string;
+    GeoMultiLineString: string;
+    GeoMultiPolygon: string;
+    Date: string;
+    Command: string;
+    ServerDate: string;
+    BsonDate: string;
+};
+declare type OrderByDirection = 'desc' | 'asc';
+declare const OrderDirectionList: string[];
+declare type WhereFilterOp = '<' | '<=' | '==' | '>=' | '>';
+declare const WhereFilterOpList: string[];
+declare enum Opeartor {
+    lt = "<",
+    gt = ">",
+    lte = "<=",
+    gte = ">=",
+    eq = "=="
+}
+declare const OperatorMap: {
+    [Opeartor.eq]: string;
+    [Opeartor.lt]: string;
+    [Opeartor.lte]: string;
+    [Opeartor.gt]: string;
+    [Opeartor.gte]: string;
+};
+declare const UpdateOperatorList: string[];
+declare enum QueryType {
+    WHERE = "WHERE",
+    DOC = "DOC"
+}
+export { ErrorCode, FieldType, WhereFilterOp, WhereFilterOpList, Opeartor, OperatorMap, OrderByDirection, OrderDirectionList, UpdateOperatorList, QueryType };

package/dist/esm/constant.js

@@ -0,0 +1,67 @@
+var ErrorCode;
+(function (ErrorCode) {
+    ErrorCode["DocIDError"] = "\u6587\u6863ID\u4E0D\u5408\u6CD5";
+    ErrorCode["CollNameError"] = "\u96C6\u5408\u540D\u79F0\u4E0D\u5408\u6CD5";
+    ErrorCode["OpStrError"] = "\u64CD\u4F5C\u7B26\u4E0D\u5408\u6CD5";
+    ErrorCode["DirectionError"] = "\u6392\u5E8F\u5B57\u7B26\u4E0D\u5408\u6CD5";
+    ErrorCode["IntergerError"] = "must be integer";
+    ErrorCode["BooleanError"] = "must be boolean";
+    ErrorCode["ArrayError"] = "must be array";
+    ErrorCode["QueryParamTypeError"] = "\u67E5\u8BE2\u53C2\u6570\u5FC5\u987B\u4E3A\u5BF9\u8C61";
+    ErrorCode["QueryParamValueError"] = "\u67E5\u8BE2\u53C2\u6570\u5BF9\u8C61\u503C\u4E0D\u80FD\u5747\u4E3Aundefined";
+    ErrorCode["CentersPhereError"] = "centersPhere\u7ED3\u6784\u4E0D\u5408\u6CD5";
+})(ErrorCode || (ErrorCode = {}));
+const FieldType = {
+    String: 'String',
+    Number: 'Number',
+    Object: 'Object',
+    Array: 'Array',
+    Boolean: 'Boolean',
+    Null: 'Null',
+    GeoPoint: 'GeoPoint',
+    GeoLineString: 'GeoLineString',
+    GeoPolygon: 'GeoPolygon',
+    GeoMultiPoint: 'GeoMultiPoint',
+    GeoMultiLineString: 'GeoMultiLineString',
+    GeoMultiPolygon: 'GeoMultiPolygon',
+    Date: 'Date',
+    Command: 'Command',
+    ServerDate: 'ServerDate',
+    BsonDate: 'BsonDate'
+};
+const OrderDirectionList = ['desc', 'asc'];
+const WhereFilterOpList = ['<', '<=', '==', '>=', '>'];
+var Opeartor;
+(function (Opeartor) {
+    Opeartor["lt"] = "<";
+    Opeartor["gt"] = ">";
+    Opeartor["lte"] = "<=";
+    Opeartor["gte"] = ">=";
+    Opeartor["eq"] = "==";
+})(Opeartor || (Opeartor = {}));
+const OperatorMap = {
+    [Opeartor.eq]: '$eq',
+    [Opeartor.lt]: '$lt',
+    [Opeartor.lte]: '$lte',
+    [Opeartor.gt]: '$gt',
+    [Opeartor.gte]: '$gte'
+};
+const UpdateOperatorList = [
+    '$set',
+    '$inc',
+    '$mul',
+    '$unset',
+    '$push',
+    '$pop',
+    '$unshift',
+    '$shift',
+    '$currentDate',
+    '$each',
+    '$position'
+];
+var QueryType;
+(function (QueryType) {
+    QueryType["WHERE"] = "WHERE";
+    QueryType["DOC"] = "DOC";
+})(QueryType || (QueryType = {}));
+export { ErrorCode, FieldType, WhereFilterOpList, Opeartor, OperatorMap, OrderDirectionList, UpdateOperatorList, QueryType };

package/dist/esm/document.d.ts

@@ -0,0 +1,14 @@
+import { IWatchOptions, DBRealtimeListener } from './typings/index';
+export declare class DocumentReference {
+    readonly id: string | number;
+    readonly _transactionId: string;
+    readonly projection: Object;
+    private _apiOptions;
+    set(data: Object): Promise<any>;
+    update(data: Object): Promise<any>;
+    delete(): Promise<any>;
+    remove(): Promise<any>;
+    get(): Promise<any>;
+    field(projection: Object): DocumentReference;
+    watch: (options: IWatchOptions) => DBRealtimeListener;
+}

package/dist/esm/document.js

@@ -0,0 +1,214 @@
+import { Db } from './index';
+import { Util } from './util';
+import { UpdateSerializer } from './serializer/update';
+import { serialize } from './serializer/datatype';
+import { UpdateCommand } from './commands/update';
+import { RealtimeWebSocketClient } from './realtime/websocket-client';
+import { QueryType } from './constant';
+import { getReqOpts, stringifyByEJSON, processReturn } from './utils/utils';
+import { ERRORS } from './const/code';
+import { EJSON } from 'bson';
+export class DocumentReference {
+    constructor(db, coll, apiOptions, docID, transactionId) {
+        this.watch = (options) => {
+            if (!Db.ws) {
+                Db.ws = new RealtimeWebSocketClient({
+                    context: {
+                        appConfig: {
+                            docSizeLimit: 1000,
+                            realtimePingInterval: 10000,
+                            realtimePongWaitTimeout: 5000,
+                            request: this.request
+                        }
+                    }
+                });
+            }
+            return Db.ws.watch(Object.assign(Object.assign({}, options), { envId: this._db.config.env, collectionName: this._coll, query: JSON.stringify({
+                    _id: this.id
+                }) }));
+        };
+        this._db = db;
+        this._coll = coll;
+        this.id = docID;
+        this._transactionId = transactionId;
+        this.request = new Db.reqClass(this._db.config);
+        this._apiOptions = apiOptions;
+    }
+    async create(data) {
+        if (this.id) {
+            data['_id'] = this.id;
+        }
+        let params = {
+            collectionName: this._coll,
+            data: [stringifyByEJSON(serialize(data))],
+            transactionId: this._transactionId
+        };
+        const res = await this.request.send('database.insertDocument', params, getReqOpts(this._apiOptions));
+        if (res.code) {
+            return res;
+        }
+        if (this._transactionId) {
+            return {
+                inserted: 1,
+                ok: 1,
+                id: res.data.insertedIds[0],
+                requestId: res.requestId
+            };
+        }
+        return {
+            id: res.data.insertedIds[0],
+            requestId: res.requestId
+        };
+    }
+    async set(data) {
+        if (!this.id) {
+            return processReturn(this._db.config.throwOnCode, Object.assign(Object.assign({}, ERRORS.INVALID_PARAM), { message: 'docId不能为空' }));
+        }
+        if (!data || typeof data !== 'object') {
+            return processReturn(this._db.config.throwOnCode, Object.assign(Object.assign({}, ERRORS.INVALID_PARAM), { message: '参数必需是非空对象' }));
+        }
+        if (data.hasOwnProperty('_id')) {
+            return processReturn(this._db.config.throwOnCode, Object.assign(Object.assign({}, ERRORS.INVALID_PARAM), { message: '不能更新_id的值' }));
+        }
+        let hasOperator = false;
+        const checkMixed = objs => {
+            if (typeof objs === 'object') {
+                for (let key in objs) {
+                    if (objs[key] instanceof UpdateCommand) {
+                        hasOperator = true;
+                    }
+                    else if (typeof objs[key] === 'object') {
+                        checkMixed(objs[key]);
+                    }
+                }
+            }
+        };
+        checkMixed(data);
+        if (hasOperator) {
+            return processReturn(this._db.config.throwOnCode, Object.assign(Object.assign({}, ERRORS.DATABASE_REQUEST_FAILED), { message: 'update operator complicit' }));
+        }
+        let param = {
+            collectionName: this._coll,
+            queryType: QueryType.DOC,
+            data: stringifyByEJSON(serialize(data)),
+            transactionId: this._transactionId,
+            multi: false,
+            merge: false,
+            upsert: true
+        };
+        if (this.id) {
+            param['query'] = stringifyByEJSON({ _id: this.id });
+        }
+        const res = await this.request.send('database.modifyDocument', param, getReqOpts(this._apiOptions));
+        if (res.code) {
+            return res;
+        }
+        if (this._transactionId) {
+            return {
+                updated: res.data.updated,
+                upserted: [{ _id: res.data.upsert_id }],
+                requestId: res.requestId
+            };
+        }
+        return {
+            updated: res.data.updated,
+            upsertedId: res.data.upsert_id,
+            requestId: res.requestId
+        };
+    }
+    async update(data) {
+        if (!data || typeof data !== 'object') {
+            return processReturn(this._db.config.throwOnCode, Object.assign(Object.assign({}, ERRORS.INVALID_PARAM), { message: '参数必需是非空对象' }));
+        }
+        if (data.hasOwnProperty('_id')) {
+            return processReturn(this._db.config.throwOnCode, Object.assign(Object.assign({}, ERRORS.INVALID_PARAM), { message: '不能更新_id的值' }));
+        }
+        const query = stringifyByEJSON({ _id: this.id });
+        const param = {
+            collectionName: this._coll,
+            transactionId: this._transactionId,
+            data: UpdateSerializer.encodeEJSON(data, this._apiOptions.raw || false),
+            query,
+            queryType: QueryType.DOC,
+            multi: false,
+            merge: true,
+            upsert: false
+        };
+        const res = await this.request.send('database.modifyDocument', param, getReqOpts(this._apiOptions));
+        if (res.code) {
+            return res;
+        }
+        return {
+            updated: res.data.updated,
+            requestId: res.requestId
+        };
+    }
+    async delete() {
+        return this.remove();
+    }
+    async remove() {
+        const query = stringifyByEJSON({ _id: this.id });
+        const param = {
+            collectionName: this._coll,
+            transactionId: this._transactionId,
+            query: query,
+            queryType: QueryType.DOC,
+            multi: false
+        };
+        const res = await this.request.send('database.removeDocument', param, getReqOpts(this._apiOptions));
+        if (res.code) {
+            return res;
+        }
+        return {
+            deleted: res.data.deleted,
+            requestId: res.requestId
+        };
+    }
+    async get() {
+        const query = stringifyByEJSON({ _id: this.id });
+        const { projection } = this._apiOptions;
+        const param = {
+            collectionName: this._coll,
+            query,
+            transactionId: this._transactionId,
+            queryType: QueryType.DOC,
+            multi: false
+        };
+        if (projection) {
+            param.projection = stringifyByEJSON(projection);
+        }
+        const res = await this.request.send('database.getDocument', param, getReqOpts(this._apiOptions));
+        if (res.code) {
+            return res;
+        }
+        const list = res.data.list.map(item => EJSON.parse(item));
+        const documents = Util.formatResDocumentData(list);
+        if (this._transactionId) {
+            return {
+                data: documents[0] || null,
+                requestId: res.requestId
+            };
+        }
+        return {
+            data: documents,
+            requestId: res.requestId
+        };
+    }
+    field(projection) {
+        let transformProjection = {};
+        for (let k in projection) {
+            if (typeof projection[k] === 'boolean') {
+                transformProjection[k] = projection[k] === true ? 1 : 0;
+            }
+            if (typeof projection[k] === 'number') {
+                transformProjection[k] = projection[k] > 0 ? 1 : 0;
+            }
+            if (typeof projection[k] === 'object') {
+                transformProjection[k] = projection[k];
+            }
+        }
+        let newApiOption = Object.assign({}, this._apiOptions);
+        newApiOption.projection = transformProjection;
+        return new DocumentReference(this._db, this._coll, newApiOption, this.id, this._transactionId);
+    }
+}

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

@@ -0,0 +1,6 @@
+export * from './point';
+export * from './lineString';
+export * from './polygon';
+export * from './multiPoint';
+export * from './multiLineString';
+export * from './multiPolygon';

package/dist/esm/geo/index.js

@@ -0,0 +1,6 @@
+export * from './point';
+export * from './lineString';
+export * from './polygon';
+export * from './multiPoint';
+export * from './multiLineString';
+export * from './multiPolygon';

package/dist/esm/geo/interface.d.ts

@@ -0,0 +1,24 @@
+export interface ISerializedPoint {
+    type: string;
+    coordinates: [number, number];
+}
+export interface ISerializedLineString {
+    type: string;
+    coordinates: [number, number][];
+}
+export interface ISerializedPolygon {
+    type: string;
+    coordinates: [number, number][][];
+}
+export interface ISerializedMultiPoint {
+    type: string;
+    coordinates: [number, number][];
+}
+export interface ISerializedMultiLineString {
+    type: string;
+    coordinates: [number, number][][];
+}
+export interface ISerializedMultiPolygon {
+    type: string;
+    coordinates: [number, number][][][];
+}

package/dist/esm/geo/lineString.d.ts

@@ -0,0 +1,19 @@
+import { Point } from './point';
+import { ISerializedLineString } from './interface';
+export declare class LineString {
+    readonly points: Point[];
+    constructor(points: Point[]);
+    parse(key: any): {
+        [x: number]: {
+            type: string;
+            coordinates: number[][];
+        };
+    };
+    toJSON(): {
+        type: string;
+        coordinates: number[][];
+    };
+    static validate(lineString: ISerializedLineString): boolean;
+    static isClosed(lineString: LineString): boolean;
+    readonly _internalType: import("../utils/symbol").InternalSymbol;
+}

package/dist/esm/geo/lineString.js

@@ -0,0 +1,54 @@
+import { SYMBOL_GEO_LINE_STRING } from '../helper/symbol';
+import { Point } from './point';
+import { isArray, isNumber } from '../utils/type';
+export class LineString {
+    constructor(points) {
+        if (!isArray(points)) {
+            throw new TypeError(`"points" must be of type Point[]. Received type ${typeof points}`);
+        }
+        if (points.length < 2) {
+            throw new Error('"points" must contain 2 points at least');
+        }
+        points.forEach(point => {
+            if (!(point instanceof Point)) {
+                throw new TypeError(`"points" must be of type Point[]. Received type ${typeof point}[]`);
+            }
+        });
+        this.points = points;
+    }
+    parse(key) {
+        return {
+            [key]: {
+                type: 'LineString',
+                coordinates: this.points.map(point => point.toJSON().coordinates)
+            }
+        };
+    }
+    toJSON() {
+        return {
+            type: 'LineString',
+            coordinates: this.points.map(point => point.toJSON().coordinates)
+        };
+    }
+    static validate(lineString) {
+        if (lineString.type !== 'LineString' || !isArray(lineString.coordinates)) {
+            return false;
+        }
+        for (let point of lineString.coordinates) {
+            if (!isNumber(point[0]) || !isNumber(point[1])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    static isClosed(lineString) {
+        const firstPoint = lineString.points[0];
+        const lastPoint = lineString.points[lineString.points.length - 1];
+        if (firstPoint.latitude === lastPoint.latitude && firstPoint.longitude === lastPoint.longitude) {
+            return true;
+        }
+    }
+    get _internalType() {
+        return SYMBOL_GEO_LINE_STRING;
+    }
+}

package/dist/esm/geo/multiLineString.d.ts

@@ -0,0 +1,18 @@
+import { LineString } from './lineString';
+import { ISerializedMultiLineString } from './interface';
+export declare class MultiLineString {
+    readonly lines: LineString[];
+    constructor(lines: LineString[]);
+    parse(key: any): {
+        [x: number]: {
+            type: string;
+            coordinates: number[][][];
+        };
+    };
+    toJSON(): {
+        type: string;
+        coordinates: number[][][];
+    };
+    static validate(multiLineString: ISerializedMultiLineString): boolean;
+    readonly _internalType: import("../utils/symbol").InternalSymbol;
+}

package/dist/esm/geo/multiLineString.js

@@ -0,0 +1,53 @@
+import { SYMBOL_GEO_MULTI_LINE_STRING } from '../helper/symbol';
+import { isArray, isNumber } from '../utils/type';
+import { LineString } from './lineString';
+export class MultiLineString {
+    constructor(lines) {
+        if (!isArray(lines)) {
+            throw new TypeError(`"lines" must be of type LineString[]. Received type ${typeof lines}`);
+        }
+        if (lines.length === 0) {
+            throw new Error('Polygon must contain 1 linestring at least');
+        }
+        lines.forEach(line => {
+            if (!(line instanceof LineString)) {
+                throw new TypeError(`"lines" must be of type LineString[]. Received type ${typeof line}[]`);
+            }
+        });
+        this.lines = lines;
+    }
+    parse(key) {
+        return {
+            [key]: {
+                type: 'MultiLineString',
+                coordinates: this.lines.map(line => {
+                    return line.points.map(point => [point.longitude, point.latitude]);
+                })
+            }
+        };
+    }
+    toJSON() {
+        return {
+            type: 'MultiLineString',
+            coordinates: this.lines.map(line => {
+                return line.points.map(point => [point.longitude, point.latitude]);
+            })
+        };
+    }
+    static validate(multiLineString) {
+        if (multiLineString.type !== 'MultiLineString' || !isArray(multiLineString.coordinates)) {
+            return false;
+        }
+        for (let line of multiLineString.coordinates) {
+            for (let point of line) {
+                if (!isNumber(point[0]) || !isNumber(point[1])) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    get _internalType() {
+        return SYMBOL_GEO_MULTI_LINE_STRING;
+    }
+}

package/dist/esm/geo/multiPoint.d.ts

@@ -0,0 +1,18 @@
+import { Point } from './point';
+import { ISerializedMultiPoint } from './interface';
+export declare class MultiPoint {
+    readonly points: Point[];
+    constructor(points: Point[]);
+    parse(key: any): {
+        [x: number]: {
+            type: string;
+            coordinates: number[][];
+        };
+    };
+    toJSON(): {
+        type: string;
+        coordinates: number[][];
+    };
+    static validate(multiPoint: ISerializedMultiPoint): boolean;
+    readonly _internalType: import("../utils/symbol").InternalSymbol;
+}