@klapeks/micro-db-utils 0.0.1

package/dist/connections/kafka/kafka.js

@@ -0,0 +1,205 @@
+"use strict";
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaConnection = exports.instances = void 0;
+var utils_1 = require("@klapeks/utils");
+var kafka_producer_1 = require("./kafka.producer");
+var kafka_consumer_1 = require("./kafka.consumer");
+var quiet_require_1 = require("../quiet.require");
+var kafkajsModule = (0, quiet_require_1.quietRequire)('kafkajs');
+var logger = new utils_1.Logger("Kafka");
+exports.instances = {
+    producers: [],
+    consumers: [],
+};
+var KafkaConnection = /** @class */ (function () {
+    function KafkaConnection(clientId) {
+        this.clientId = clientId;
+        if (!kafkajsModule)
+            throw "No kafkajs module installed";
+        this.kafka = new kafkajsModule.Kafka({
+            clientId: clientId,
+            brokers: ['localhost:9092'],
+            logCreator: function () { return function () { }; }
+        });
+    }
+    KafkaConnection.prototype.createTopic = function (topic, partitions, replicas) {
+        return __awaiter(this, void 0, void 0, function () {
+            var admin, topics, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        admin = this.kafka.admin();
+                        return [4 /*yield*/, admin.connect()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, admin.fetchTopicMetadata({ topics: [topic] }).catch(function (err) { return null; })];
+                    case 2:
+                        topics = _a.sent();
+                        logger.log("Topic infos:", topics === null || topics === void 0 ? void 0 : topics.topics);
+                        if (!!(topics === null || topics === void 0 ? void 0 : topics.topics.length)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, admin.createTopics({
+                                topics: [{
+                                        topic: topic,
+                                        numPartitions: partitions,
+                                        replicationFactor: replicas
+                                    }],
+                            })];
+                    case 3:
+                        _a.sent();
+                        logger.log("New topic created:", topic, '|', partitions, '|', replicas);
+                        return [3 /*break*/, 6];
+                    case 4:
+                        if (!(topics.topics[0].partitions.length < partitions)) return [3 /*break*/, 6];
+                        logger.log("Malo partitions:", topics.topics[0].partitions.length);
+                        // Увеличиваем число партиций
+                        return [4 /*yield*/, admin.createPartitions({
+                                topicPartitions: [{
+                                        topic: topic,
+                                        count: partitions, // новое общее количество партиций
+                                    }],
+                            })];
+                    case 5:
+                        // Увеличиваем число партиций
+                        _a.sent();
+                        logger.log("Topic partitions change:", topic, '|', partitions);
+                        _a.label = 6;
+                    case 6: return [4 /*yield*/, admin.alterConfigs({
+                            validateOnly: false,
+                            resources: [{
+                                    type: kafkajsModule.ConfigResourceTypes.TOPIC,
+                                    name: topic,
+                                    configEntries: [{
+                                            name: 'retention.ms',
+                                            value: (24 * 60 * 60 * 1000).toString() // 86400000
+                                        }]
+                                }]
+                        })];
+                    case 7:
+                        result = _a.sent();
+                        logger.log("Alter config result:", result);
+                        return [4 /*yield*/, admin.disconnect()];
+                    case 8:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    KafkaConnection.prototype.createProducer = function (config) {
+        return new kafka_producer_1.KafkaProducer(this, config);
+    };
+    KafkaConnection.prototype.createConsumer = function (config) {
+        return new kafka_consumer_1.KafkaConsumer(this, config);
+    };
+    KafkaConnection.cleanExit = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var consumers, producers, _i, consumers_1, c, _a, producers_1, p;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        consumers = exports.instances.consumers;
+                        producers = exports.instances.producers;
+                        exports.instances.producers = [];
+                        exports.instances.consumers = [];
+                        _i = 0, consumers_1 = consumers;
+                        _b.label = 1;
+                    case 1:
+                        if (!(_i < consumers_1.length)) return [3 /*break*/, 4];
+                        c = consumers_1[_i];
+                        return [4 /*yield*/, c.disconnect().catch(function (err) { return logger.error(err); })];
+                    case 2:
+                        _b.sent();
+                        _b.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4:
+                        _a = 0, producers_1 = producers;
+                        _b.label = 5;
+                    case 5:
+                        if (!(_a < producers_1.length)) return [3 /*break*/, 8];
+                        p = producers_1[_a];
+                        return [4 /*yield*/, p.disconnect().catch(function (err) { return logger.error(err); })];
+                    case 6:
+                        _b.sent();
+                        _b.label = 7;
+                    case 7:
+                        _a++;
+                        return [3 /*break*/, 5];
+                    case 8: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return KafkaConnection;
+}());
+exports.KafkaConnection = KafkaConnection;
+function cleanExit() {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, KafkaConnection.cleanExit()];
+                case 1:
+                    _a.sent();
+                    process.exit(0);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+process.on('SIGTERM', function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, cleanExit()];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); });
+process.on('SIGINT', function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, cleanExit()];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); });

package/dist/connections/kafka/kafka.producer.d.ts

@@ -0,0 +1,11 @@
+import type { Message as KafkaMessage, Producer, ProducerConfig } from "kafkajs";
+import { KafkaConnection } from "./kafka";
+export declare class KafkaProducer {
+    readonly connection: KafkaConnection;
+    readonly producer: Producer;
+    constructor(connection: KafkaConnection, config?: ProducerConfig);
+    private _needConnection;
+    connect(): Promise<void>;
+    sendMessage(topic: string, data: any, options?: Omit<KafkaMessage, "value">): Promise<void>;
+    disconnect(): Promise<void>;
+}

package/dist/connections/kafka/kafka.producer.js

@@ -0,0 +1,101 @@
+"use strict";
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaProducer = void 0;
+var utils_1 = require("@klapeks/utils");
+var logger = new utils_1.Logger("Kafka Producer");
+var KafkaProducer = /** @class */ (function () {
+    function KafkaProducer(connection, config) {
+        this._needConnection = true;
+        this.connection = connection;
+        this.producer = connection.kafka.producer(config);
+    }
+    KafkaProducer.prototype.connect = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this._needConnection)
+                            return [2 /*return*/];
+                        return [4 /*yield*/, this.producer.connect()];
+                    case 1:
+                        _a.sent();
+                        this._needConnection = false;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    KafkaProducer.prototype.sendMessage = function (topic, data, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var message;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this._needConnection) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.connect()];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        message = (options || {});
+                        message.value = JSON.stringify(data);
+                        return [4 /*yield*/, this.producer.send({ topic: topic, messages: [message] })];
+                    case 3:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    KafkaProducer.prototype.disconnect = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.producer.disconnect()];
+                    case 1:
+                        _a.sent();
+                        logger.log("Consumer disconnected:", this.connection.clientId);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return KafkaProducer;
+}());
+exports.KafkaProducer = KafkaProducer;

package/dist/connections/mysql.connection.d.ts

@@ -0,0 +1,15 @@
+import mysql2 from 'mysql2';
+import { DatabaseOptions } from '@klapeks/utils';
+export declare class RawMySQLConnection {
+    private _pool;
+    private _poolOptions;
+    constructor(options: DatabaseOptions & {
+        type: "mysql";
+    });
+    get pool(): mysql2.Pool | undefined;
+    takePool(): Promise<mysql2.Pool>;
+    destroyConnection(): Promise<void>;
+    getConnection(): Promise<mysql2.PoolConnection>;
+    runSQL<T = any>(query: string, params?: any[]): Promise<T[]>;
+    runSQL_One<T = any>(query: string, params?: any[]): Promise<T | null>;
+}

package/dist/connections/mysql.connection.js

@@ -0,0 +1,165 @@
+"use strict";
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RawMySQLConnection = void 0;
+var mysql2_1 = __importDefault(require("mysql2"));
+var utils_1 = require("@klapeks/utils");
+var logger = new utils_1.Logger('MySQL');
+var RawMySQLConnection = /** @class */ (function () {
+    function RawMySQLConnection(options) {
+        this._poolOptions = {
+            user: options.username,
+            password: options.password,
+            host: options.host,
+            port: options.port,
+            database: options.database,
+            charset: options.charset,
+        };
+    }
+    Object.defineProperty(RawMySQLConnection.prototype, "pool", {
+        get: function () {
+            return this._pool;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    RawMySQLConnection.prototype.takePool = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                if (this._pool)
+                    return [2 /*return*/, this._pool];
+                // if (this.options.type != 'mysql') throw "Not a mysql";
+                this._pool = mysql2_1.default.createPool(this._poolOptions);
+                this._pool.on('connection', function () {
+                    logger.log('Database connected');
+                });
+                this._pool.on('close', function () {
+                    var _a;
+                    logger.log('Database disconnected');
+                    (_a = _this._pool) === null || _a === void 0 ? void 0 : _a.end();
+                    _this._pool = undefined;
+                });
+                return [2 /*return*/, this._pool];
+            });
+        });
+    };
+    RawMySQLConnection.prototype.destroyConnection = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, new Promise(function (resolve, reject) {
+                        if (!_this._pool)
+                            return resolve();
+                        _this._pool.end(function (err) {
+                            _this._pool = undefined;
+                            if (err)
+                                reject(err);
+                            else
+                                resolve();
+                        });
+                    })];
+            });
+        });
+    };
+    RawMySQLConnection.prototype.getConnection = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!!this._pool) return [3 /*break*/, 2];
+                        _a = this;
+                        return [4 /*yield*/, this.takePool()];
+                    case 1:
+                        _a._pool = _b.sent();
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, new Promise(function (resolve, reject) {
+                            if (!_this._pool)
+                                return reject("Can't connect to (unknown) mysql");
+                            _this._pool.getConnection(function (err, conn) {
+                                if (err)
+                                    return reject(err);
+                                resolve(conn);
+                            });
+                        })];
+                }
+            });
+        });
+    };
+    RawMySQLConnection.prototype.runSQL = function (query, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var connection;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getConnection()];
+                    case 1:
+                        connection = _a.sent();
+                        return [2 /*return*/, new Promise(function (resolve, reject) {
+                                // logger.debug("SQL query: ", query, '| params:', params||[])
+                                connection.query(query, params || [], function (err, result) {
+                                    connection.release();
+                                    if (err)
+                                        return reject(err);
+                                    resolve(result);
+                                });
+                            })];
+                }
+            });
+        });
+    };
+    RawMySQLConnection.prototype.runSQL_One = function (query, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.runSQL(query, params)];
+                    case 1:
+                        res = _a.sent();
+                        return [2 /*return*/, res.length ? (res[0] || res) : null];
+                }
+            });
+        });
+    };
+    return RawMySQLConnection;
+}());
+exports.RawMySQLConnection = RawMySQLConnection;

package/dist/connections/nosql/mongo.d.ts

@@ -0,0 +1,56 @@
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/inferschematype" />
+/// <reference types="mongoose/types/inferrawdoctype" />
+import { DatabaseOptions, Flatten } from "@klapeks/utils";
+import type { Schema as MongooseSchema, PipelineStage, QuerySelector } from "mongoose";
+import { Point } from "typeorm";
+export type MongoDBConnectOptions = Omit<DatabaseOptions & {
+    type: "mysql";
+}, "type"> & {
+    type: "mongo";
+};
+export type MongoSearchQuery<T extends object> = {
+    [K in keyof Flatten<T>]?: Flatten<T>[K] | QuerySelector<Flatten<T>[K]>;
+};
+export declare function flattenForUpdate<T extends object>(object: T, prefix?: string): Partial<Flatten<T>>;
+export declare function cursorOffsetAggregation<T extends object>(sortField: keyof Flatten<T>, lastValue: number | string, fieldSort: 'asc' | 'desc', idField: keyof Flatten<T>, lastId: number | string): PipelineStage;
+export declare class MongoDBConnection {
+    static createCounter<T extends string>(name?: string): {
+        readonly model: any;
+        readonly increment: (model: T, increment?: number) => Promise<any>;
+        readonly set: (model: T, value: number) => Promise<any>;
+    };
+    static getOptions(): MongoDBConnectOptions;
+    static init(databaseName: string): Promise<void>;
+}
+export declare const MongoGeoPoint: MongooseSchema<Point, import("mongoose").Model<Point, any, any, any, import("mongoose").Document<unknown, any, Point, any, {}> & Point & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, Point, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<Point>, {}, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & import("mongoose").FlatRecord<Point> & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}>;