@cloudbase/js-sdk 3.6.8-beta.0 → 3.6.8

package/database/dist/commonjs/commands/update.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isKnownUpdateCommand = exports.isUpdateCommand = exports.UpdateCommand = exports.UPDATE_COMMANDS_LITERAL = void 0;
+var symbol_1 = require("../helper/symbol");
+var UPDATE_COMMANDS_LITERAL;
+(function (UPDATE_COMMANDS_LITERAL) {
+    UPDATE_COMMANDS_LITERAL["SET"] = "set";
+    UPDATE_COMMANDS_LITERAL["REMOVE"] = "remove";
+    UPDATE_COMMANDS_LITERAL["INC"] = "inc";
+    UPDATE_COMMANDS_LITERAL["MUL"] = "mul";
+    UPDATE_COMMANDS_LITERAL["PUSH"] = "push";
+    UPDATE_COMMANDS_LITERAL["PULL"] = "pull";
+    UPDATE_COMMANDS_LITERAL["PULL_ALL"] = "pullAll";
+    UPDATE_COMMANDS_LITERAL["POP"] = "pop";
+    UPDATE_COMMANDS_LITERAL["SHIFT"] = "shift";
+    UPDATE_COMMANDS_LITERAL["UNSHIFT"] = "unshift";
+    UPDATE_COMMANDS_LITERAL["ADD_TO_SET"] = "addToSet";
+    UPDATE_COMMANDS_LITERAL["BIT"] = "bit";
+    UPDATE_COMMANDS_LITERAL["RENAME"] = "rename";
+    UPDATE_COMMANDS_LITERAL["MAX"] = "max";
+    UPDATE_COMMANDS_LITERAL["MIN"] = "min";
+})(UPDATE_COMMANDS_LITERAL = exports.UPDATE_COMMANDS_LITERAL || (exports.UPDATE_COMMANDS_LITERAL = {}));
+var UpdateCommand = (function () {
+    function UpdateCommand(operator, operands, fieldName) {
+        this._internalType = symbol_1.SYMBOL_UPDATE_COMMAND;
+        Object.defineProperties(this, {
+            _internalType: {
+                enumerable: false,
+                configurable: false,
+            },
+        });
+        this.operator = operator;
+        this.operands = operands;
+        this.fieldName = fieldName || symbol_1.SYMBOL_UNSET_FIELD_NAME;
+    }
+    UpdateCommand.prototype._setFieldName = function (fieldName) {
+        var command = new UpdateCommand(this.operator, this.operands, fieldName);
+        return command;
+    };
+    return UpdateCommand;
+}());
+exports.UpdateCommand = UpdateCommand;
+function isUpdateCommand(object) {
+    return object && (object instanceof UpdateCommand) && (object._internalType === symbol_1.SYMBOL_UPDATE_COMMAND);
+}
+exports.isUpdateCommand = isUpdateCommand;
+function isKnownUpdateCommand(object) {
+    return isUpdateCommand(object) && (object.operator.toUpperCase() in UPDATE_COMMANDS_LITERAL);
+}
+exports.isKnownUpdateCommand = isKnownUpdateCommand;
+exports.default = UpdateCommand;

package/database/dist/commonjs/config/app.config.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    db_doc_size_limit: number;
+    db_realtime_ping_interval: number;
+    db_realtime_pong_wait_timeout: number;
+};
+export default _default;

package/database/dist/commonjs/config/app.config.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    db_doc_size_limit: 512 * 1024,
+    db_realtime_ping_interval: 15 * 1000,
+    db_realtime_pong_wait_timeout: 15 * 1000,
+};

package/database/dist/commonjs/config/error.config.d.ts

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

package/database/dist/commonjs/config/error.config.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERR_CODE = void 0;
+exports.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/database/dist/commonjs/const/code.d.ts

@@ -0,0 +1,30 @@
+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;
+    };
+};

package/database/dist/commonjs/const/code.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERRORS = void 0;
+exports.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'
+    }
+};

package/database/dist/commonjs/constant.d.ts

@@ -0,0 +1,51 @@
+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",
+    QueryParamTypeError = "\u67E5\u8BE2\u53C2\u6570\u5FC5\u987B\u4E3A\u5BF9\u8C61",
+    QueryParamValueError = "\u67E5\u8BE2\u53C2\u6570\u5BF9\u8C61\u503C\u4E0D\u80FD\u5747\u4E3Aundefined"
+}
+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;
+    Timestamp: string;
+    Command: string;
+    ServerDate: string;
+    BsonDate: string;
+};
+type OrderByDirection = 'desc' | 'asc';
+declare const OrderDirectionList: string[];
+type WhereFilterOp = '<' | '<=' | '==' | '>=' | '>';
+declare const WhereFilterOpList: string[];
+declare enum Opeartor {
+    lt = "<",
+    gt = ">",
+    lte = "<=",
+    gte = ">=",
+    eq = "=="
+}
+declare const OperatorMap: {
+    "==": string;
+    "<": string;
+    "<=": string;
+    ">": string;
+    ">=": string;
+};
+declare const UpdateOperatorList: string[];
+declare enum QueryType {
+    WHERE = "WHERE",
+    DOC = "DOC"
+}
+export { ErrorCode, FieldType, WhereFilterOp, WhereFilterOpList, Opeartor, OperatorMap, OrderByDirection, OrderDirectionList, UpdateOperatorList, QueryType };

package/database/dist/commonjs/constant.js

@@ -0,0 +1,75 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryType = exports.UpdateOperatorList = exports.OrderDirectionList = exports.OperatorMap = exports.Opeartor = exports.WhereFilterOpList = exports.FieldType = exports.ErrorCode = void 0;
+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["QueryParamTypeError"] = "\u67E5\u8BE2\u53C2\u6570\u5FC5\u987B\u4E3A\u5BF9\u8C61";
+    ErrorCode["QueryParamValueError"] = "\u67E5\u8BE2\u53C2\u6570\u5BF9\u8C61\u503C\u4E0D\u80FD\u5747\u4E3Aundefined";
+})(ErrorCode || (ErrorCode = {}));
+exports.ErrorCode = ErrorCode;
+var 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',
+    Timestamp: 'Date',
+    Command: 'Command',
+    ServerDate: 'ServerDate',
+    BsonDate: 'BsonDate'
+};
+exports.FieldType = FieldType;
+var OrderDirectionList = ['desc', 'asc'];
+exports.OrderDirectionList = OrderDirectionList;
+var WhereFilterOpList = ['<', '<=', '==', '>=', '>'];
+exports.WhereFilterOpList = WhereFilterOpList;
+var Opeartor;
+(function (Opeartor) {
+    Opeartor["lt"] = "<";
+    Opeartor["gt"] = ">";
+    Opeartor["lte"] = "<=";
+    Opeartor["gte"] = ">=";
+    Opeartor["eq"] = "==";
+})(Opeartor || (Opeartor = {}));
+exports.Opeartor = Opeartor;
+var OperatorMap = (_a = {},
+    _a[Opeartor.eq] = '$eq',
+    _a[Opeartor.lt] = '$lt',
+    _a[Opeartor.lte] = '$lte',
+    _a[Opeartor.gt] = '$gt',
+    _a[Opeartor.gte] = '$gte',
+    _a);
+exports.OperatorMap = OperatorMap;
+var UpdateOperatorList = [
+    '$set',
+    '$inc',
+    '$mul',
+    '$unset',
+    '$push',
+    '$pop',
+    '$unshift',
+    '$shift',
+    '$currentDate',
+    '$each',
+    '$position'
+];
+exports.UpdateOperatorList = UpdateOperatorList;
+var QueryType;
+(function (QueryType) {
+    QueryType["WHERE"] = "WHERE";
+    QueryType["DOC"] = "DOC";
+})(QueryType || (QueryType = {}));
+exports.QueryType = QueryType;

package/database/dist/commonjs/document.d.ts

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

package/database/dist/commonjs/document.js

@@ -0,0 +1,260 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentReference = void 0;
+var util_1 = require("./lib/util");
+var index_1 = require("./index");
+var util_2 = require("./util");
+var update_1 = require("./serializer/update");
+var datatype_1 = require("./serializer/datatype");
+var update_2 = require("./commands/update");
+var constant_1 = require("./constant");
+var utils_1 = require("./utils/utils");
+var DocumentReference = (function () {
+    function DocumentReference(db, coll, docID, projection) {
+        if (projection === void 0) { projection = {}; }
+        var _this = this;
+        this.watch = function (options) {
+            var ws = (0, utils_1.getWsInstance)(_this._db);
+            return ws.watch(__assign(__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.request = index_1.Db.createRequest(this._db.config);
+        this.projection = projection;
+    }
+    DocumentReference.prototype.create = function (data, callback) {
+        callback = callback || (0, util_1.createPromiseCallback)();
+        var isBatch = Array.isArray(data);
+        var params = {
+            collectionName: this._coll,
+            data: isBatch ? data.map(function (item) { return (0, datatype_1.serialize)(item); }) : (0, datatype_1.serialize)(data)
+        };
+        if (!isBatch && this.id) {
+            params['_id'] = this.id;
+        }
+        this.request
+            .send('database.addDocument', params)
+            .then(function (res) {
+            var _a;
+            if (res.code) {
+                callback(0, res);
+            }
+            else {
+                if (isBatch) {
+                    callback(0, {
+                        ids: ((_a = res.data) === null || _a === void 0 ? void 0 : _a.insertedIds) || [],
+                        requestId: res.requestId
+                    });
+                }
+                else {
+                    callback(0, {
+                        id: res.data._id,
+                        requestId: res.requestId
+                    });
+                }
+            }
+        })
+            .catch(function (err) {
+            callback(err);
+        });
+        return callback.promise;
+    };
+    DocumentReference.prototype.set = function (data, callback) {
+        callback = callback || (0, util_1.createPromiseCallback)();
+        if (!this.id) {
+            return Promise.resolve({
+                code: 'INVALID_PARAM',
+                message: 'docId不能为空'
+            });
+        }
+        if (!data || typeof data !== 'object') {
+            return Promise.resolve({
+                code: 'INVALID_PARAM',
+                message: '参数必需是非空对象'
+            });
+        }
+        if (data.hasOwnProperty('_id')) {
+            return Promise.resolve({
+                code: 'INVALID_PARAM',
+                message: '不能更新_id的值'
+            });
+        }
+        var hasOperator = false;
+        var checkMixed = function (objs) {
+            if (typeof objs === 'object') {
+                for (var key in objs) {
+                    if (objs[key] instanceof update_2.UpdateCommand) {
+                        hasOperator = true;
+                    }
+                    else if (typeof objs[key] === 'object') {
+                        checkMixed(objs[key]);
+                    }
+                }
+            }
+        };
+        checkMixed(data);
+        if (hasOperator) {
+            return Promise.resolve({
+                code: 'DATABASE_REQUEST_FAILED',
+                message: 'update operator complicit'
+            });
+        }
+        var merge = false;
+        var param = {
+            collectionName: this._coll,
+            queryType: constant_1.QueryType.DOC,
+            data: (0, datatype_1.serialize)(data),
+            multi: false,
+            merge: merge,
+            upsert: true
+        };
+        if (this.id) {
+            param['query'] = { _id: this.id };
+        }
+        this.request
+            .send('database.updateDocument', param)
+            .then(function (res) {
+            if (res.code) {
+                callback(0, res);
+            }
+            else {
+                callback(0, {
+                    updated: res.data.updated,
+                    upsertedId: res.data.upserted_id,
+                    requestId: res.requestId
+                });
+            }
+        })
+            .catch(function (err) {
+            callback(err);
+        });
+        return callback.promise;
+    };
+    DocumentReference.prototype.update = function (data, callback) {
+        callback = callback || (0, util_1.createPromiseCallback)();
+        if (!data || typeof data !== 'object') {
+            return Promise.resolve({
+                code: 'INVALID_PARAM',
+                message: '参数必需是非空对象'
+            });
+        }
+        if (data.hasOwnProperty('_id')) {
+            return Promise.resolve({
+                code: 'INVALID_PARAM',
+                message: '不能更新_id的值'
+            });
+        }
+        var query = { _id: this.id };
+        var merge = true;
+        var param = {
+            collectionName: this._coll,
+            data: update_1.UpdateSerializer.encode(data),
+            query: query,
+            queryType: constant_1.QueryType.DOC,
+            multi: false,
+            merge: merge,
+            upsert: false
+        };
+        this.request
+            .send('database.updateDocument', param)
+            .then(function (res) {
+            if (res.code) {
+                callback(0, res);
+            }
+            else {
+                callback(0, {
+                    updated: res.data.updated,
+                    upsertedId: res.data.upserted_id,
+                    requestId: res.requestId
+                });
+            }
+        })
+            .catch(function (err) {
+            callback(err);
+        });
+        return callback.promise;
+    };
+    DocumentReference.prototype.remove = function (callback) {
+        callback = callback || (0, util_1.createPromiseCallback)();
+        var query = { _id: this.id };
+        var param = {
+            collectionName: this._coll,
+            query: query,
+            queryType: constant_1.QueryType.DOC,
+            multi: false
+        };
+        this.request
+            .send('database.deleteDocument', param)
+            .then(function (res) {
+            if (res.code) {
+                callback(0, res);
+            }
+            else {
+                callback(0, {
+                    deleted: res.data.deleted,
+                    requestId: res.requestId
+                });
+            }
+        })
+            .catch(function (err) {
+            callback(err);
+        });
+        return callback.promise;
+    };
+    DocumentReference.prototype.get = function (callback) {
+        callback = callback || (0, util_1.createPromiseCallback)();
+        var query = { _id: this.id };
+        var param = {
+            collectionName: this._coll,
+            query: query,
+            queryType: constant_1.QueryType.DOC,
+            multi: false,
+            projection: this.projection
+        };
+        this.request
+            .send('database.queryDocument', param)
+            .then(function (res) {
+            if (res.code) {
+                callback(0, res);
+            }
+            else {
+                var documents = util_2.Util.formatResDocumentData(res.data.list);
+                callback(0, {
+                    data: documents,
+                    requestId: res.requestId
+                });
+            }
+        })
+            .catch(function (err) {
+            callback(err);
+        });
+        return callback.promise;
+    };
+    DocumentReference.prototype.field = function (projection) {
+        for (var k in projection) {
+            if (projection[k]) {
+                projection[k] = 1;
+            }
+            else {
+                projection[k] = 0;
+            }
+        }
+        return new DocumentReference(this._db, this._coll, this.id, projection);
+    };
+    return DocumentReference;
+}());
+exports.DocumentReference = DocumentReference;

package/database/dist/commonjs/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/database/dist/commonjs/geo/index.js

@@ -0,0 +1,22 @@
+"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("./point"), exports);
+__exportStar(require("./lineString"), exports);
+__exportStar(require("./polygon"), exports);
+__exportStar(require("./multiPoint"), exports);
+__exportStar(require("./multiLineString"), exports);
+__exportStar(require("./multiPolygon"), exports);

package/database/dist/commonjs/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/database/dist/commonjs/geo/interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/database/dist/commonjs/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;
+    get _internalType(): import("../utils/symbol").InternalSymbol;
+}