@rws-framework/db 2.0.2 → 2.0.4

package/dist/decorators/InverseRelation.d.ts

@@ -0,0 +1,10 @@
+import 'reflect-metadata';
+import { RWSModel, OpModelType } from '../models/_model';
+interface InverseRelationOpts {
+    key: string;
+    inversionModel: OpModelType<RWSModel<any>>;
+    foreignKey: string;
+}
+declare function InverseRelation(inversionModel: () => OpModelType<RWSModel<any>>, sourceModel: () => OpModelType<RWSModel<any>>, foreignKey?: string): (target: any, key: string) => void;
+export default InverseRelation;
+export { InverseRelationOpts };

package/dist/decorators/InverseRelation.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+function InverseRelation(inversionModel, sourceModel, foreignKey = null) {
+    return function (target, key) {
+        // Store the promise in metadata immediately
+        const metadataPromise = Promise.resolve().then(() => {
+            const model = inversionModel();
+            const source = sourceModel();
+            const metaOpts = {
+                key,
+                inversionModel: model,
+                foreignKey: foreignKey ? foreignKey : `${source._collection}_id`
+            };
+            return metaOpts;
+        });
+        // Store both the promise and the key information
+        Reflect.defineMetadata(`InverseRelation:${key}`, {
+            promise: metadataPromise,
+            key
+        }, target);
+    };
+}
+exports.default = InverseRelation;

package/dist/decorators/InverseTimeSeries.d.ts

@@ -0,0 +1,8 @@
+import 'reflect-metadata';
+interface InverseTimeSeriesOpts {
+    timeSeriesModel: string;
+    hydrationField: string;
+}
+declare function InverseTimeSeries(timeSeriesModel: string, hydrationField: string): (target: any, key: string) => void;
+export default InverseTimeSeries;
+export { InverseTimeSeriesOpts };

package/dist/decorators/InverseTimeSeries.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+function InverseTimeSeries(timeSeriesModel, hydrationField) {
+    const metaOpts = {
+        timeSeriesModel: timeSeriesModel,
+        hydrationField: hydrationField
+    };
+    return function (target, key) {
+        Reflect.defineMetadata(`InverseTimeSeries:${key}`, metaOpts, target);
+    };
+}
+exports.default = InverseTimeSeries;

package/dist/decorators/Relation.d.ts

@@ -0,0 +1,12 @@
+import 'reflect-metadata';
+import { RWSModel, OpModelType } from '../models/_model';
+interface IRelationOpts {
+    required?: boolean;
+    key?: string;
+    relationField?: string;
+    relatedToField?: string;
+    relatedTo: OpModelType<RWSModel<any>>;
+}
+declare function Relation(theModel: () => OpModelType<RWSModel<any>>, required?: boolean, relationField?: string, relatedToField?: string): (target: any, key: string) => void;
+export default Relation;
+export { IRelationOpts };

package/dist/decorators/Relation.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+function Relation(theModel, required = false, relationField = null, relatedToField = 'id') {
+    return function (target, key) {
+        // Store the promise in metadata immediately
+        const metadataPromise = Promise.resolve().then(() => {
+            const relatedTo = theModel();
+            const metaOpts = { required, relatedTo, relatedToField };
+            if (!relationField) {
+                metaOpts.relationField = relatedTo._collection + '_id';
+            }
+            else {
+                metaOpts.relationField = relationField;
+            }
+            metaOpts.key = key;
+            return metaOpts;
+        });
+        // Store both the promise and the key information
+        Reflect.defineMetadata(`Relation:${key}`, {
+            promise: metadataPromise,
+            key
+        }, target);
+    };
+}
+exports.default = Relation;

package/dist/decorators/TrackType.d.ts

@@ -0,0 +1,17 @@
+import 'reflect-metadata';
+import { OpModelType } from '../models/_model';
+interface ITrackerOpts {
+    required?: boolean;
+    relationField?: string;
+    relatedToField?: string;
+    relatedTo?: OpModelType<any>;
+    inversionModel?: OpModelType<any>;
+    relationName?: string;
+}
+interface IMetaOpts extends ITrackerOpts {
+    type: any;
+    tags: string[];
+}
+declare function TrackType(type: any, opts?: ITrackerOpts | null, tags?: string[]): (target: any, key: string) => void;
+export default TrackType;
+export { IMetaOpts, ITrackerOpts };

package/dist/decorators/TrackType.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+function TrackType(type, opts = null, tags = []) {
+    if (!opts) {
+        opts = {
+            required: false
+        };
+    }
+    const required = opts.required;
+    const metaOpts = { type, tags, required };
+    if (opts.relatedToField && opts.relatedTo) {
+        metaOpts.relatedToField = opts.relatedToField;
+        metaOpts.relatedTo = opts.relatedTo;
+        if (!opts.relationField) {
+            metaOpts.relationField = opts.relatedTo + '_id';
+        }
+        else {
+            metaOpts.relationField = opts.relationField;
+        }
+    }
+    if (opts.inversionModel) {
+        metaOpts.inversionModel = opts.inversionModel;
+    }
+    //const resolvedType = typeof type === 'function' ? type() : type;   
+    if (type._collection) {
+        metaOpts.type = type;
+    }
+    return function (target, key) {
+        Reflect.defineMetadata(`TrackType:${key}`, metaOpts, target);
+    };
+}
+exports.default = TrackType;

package/dist/decorators/index.d.ts

@@ -0,0 +1,5 @@
+import InverseRelation from './InverseRelation';
+import Relation from './Relation';
+import TrackType, { IMetaOpts } from './TrackType';
+import InverseTimeSeries from './InverseTimeSeries';
+export { InverseRelation, Relation, TrackType, InverseTimeSeries, IMetaOpts };

package/dist/decorators/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InverseTimeSeries = exports.TrackType = exports.Relation = exports.InverseRelation = void 0;
+const InverseRelation_1 = __importDefault(require("./InverseRelation"));
+exports.InverseRelation = InverseRelation_1.default;
+const Relation_1 = __importDefault(require("./Relation"));
+exports.Relation = Relation_1.default;
+const TrackType_1 = __importDefault(require("./TrackType"));
+exports.TrackType = TrackType_1.default;
+const InverseTimeSeries_1 = __importDefault(require("./InverseTimeSeries"));
+exports.InverseTimeSeries = InverseTimeSeries_1.default;

package/dist/helper/DbHelper.d.ts

@@ -0,0 +1,8 @@
+import { IDbConfigHandler } from '../types/DbConfigHandler';
+import { OpModelType } from '../models/_model';
+import { DBService } from '../services/DBService';
+export declare class DbHelper {
+    static installPrisma(configService: IDbConfigHandler, dbService: DBService, leaveFile?: boolean): Promise<void>;
+    static generateModelSections(model: OpModelType<any>): Promise<string>;
+    static toConfigCase(modelType: any): string;
+}

package/dist/helper/DbHelper.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbHelper = void 0;
+const console_1 = require("@rws-framework/console");
+const chalk_1 = __importDefault(require("chalk"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const _model_1 = require("../models/_model");
+const TimeSeriesModel_1 = __importDefault(require("../models/TimeSeriesModel"));
+const log = console.log;
+const workspaceRoot = console_1.rwsPath.findRootWorkspacePath();
+const moduleDir = path_1.default.resolve(workspaceRoot, 'node_modules', '@rws-framework', 'db');
+class DbHelper {
+    static async installPrisma(configService, dbService, leaveFile = false) {
+        const dbUrl = configService.get('mongo_url');
+        const dbType = 'mongodb';
+        let template = `generator client {\n
+        provider = "prisma-client-js"\n
+    }\n\n`;
+        template += `\ndatasource db {\n
+        provider = "${dbType}"\n
+        url = env("DATABASE_URL")\n    
+    }\n\n`;
+        const dbModels = configService.get('db_models');
+        if (dbModels) {
+            for (const model of dbModels) {
+                const modelSection = await DbHelper.generateModelSections(model);
+                template += '\n\n' + modelSection;
+                log('RWS SCHEMA BUILD', chalk_1.default.blue('Building DB Model'), model.name);
+                if (_model_1.RWSModel.isSubclass(model, TimeSeriesModel_1.default)) {
+                    dbService.collectionExists(model._collection).then((exists) => {
+                        if (exists) {
+                            return;
+                        }
+                        log(chalk_1.default.green('[RWS Init]') + ` creating TimeSeries type collection from ${model} model`);
+                        dbService.createTimeSeriesCollection(model._collection);
+                    });
+                }
+            }
+            const schemaDir = path_1.default.join(moduleDir, 'prisma');
+            const schemaPath = path_1.default.join(schemaDir, 'schema.prisma');
+            if (!fs_1.default.existsSync(schemaDir)) {
+                fs_1.default.mkdirSync(schemaDir);
+            }
+            if (fs_1.default.existsSync(schemaPath)) {
+                fs_1.default.unlinkSync(schemaPath);
+            }
+            fs_1.default.writeFileSync(schemaPath, template);
+            process.env.DB_URL = dbUrl;
+            const endPrisma = 'npx prisma';
+            await console_1.rwsShell.runCommand(`${endPrisma} generate --schema=${schemaPath}`, process.cwd());
+            // leaveFile = true;
+            log(chalk_1.default.green('[RWS Init]') + ' prisma schema generated from ', schemaPath);
+            if (!leaveFile) {
+                fs_1.default.unlinkSync(schemaPath);
+            }
+        }
+    }
+    static async generateModelSections(model) {
+        let section = '';
+        const modelMetadatas = await _model_1.RWSModel.getModelAnnotations(model);
+        const modelName = model._collection;
+        section += `model ${modelName} {\n`;
+        section += '\tid String @map("_id") @id @default(auto()) @db.ObjectId\n';
+        for (const key in modelMetadatas) {
+            const modelMetadata = modelMetadatas[key].metadata;
+            const requiredString = modelMetadata.required ? '' : '?';
+            const annotationType = modelMetadatas[key].annotationType;
+            if (key === 'id') {
+                continue;
+            }
+            if (annotationType === 'Relation') {
+                const relatedModel = modelMetadata.relatedTo;
+                // Handle direct relation (many-to-one or one-to-one)
+                section += `\t${key} ${relatedModel._collection}${requiredString} @relation("${modelName}_${relatedModel._collection}", fields: [${modelMetadata.relationField}], references: [${modelMetadata.relatedToField}], onDelete: Cascade)\n`;
+                section += `\t${modelMetadata.relationField} String${requiredString} @db.ObjectId\n`;
+            }
+            else if (annotationType === 'InverseRelation') {
+                // Handle inverse relation (one-to-many or one-to-one)
+                section += `\t${key} ${modelMetadata.inversionModel._collection}[] @relation("${modelMetadata.inversionModel._collection}_${modelName}")\n`;
+            }
+            else if (annotationType === 'InverseTimeSeries') {
+                section += `\t${key} String[] @db.ObjectId\n`;
+            }
+            else if (annotationType === 'TrackType') {
+                const tags = modelMetadata.tags.map((item) => '@' + item);
+                section += `\t${key} ${DbHelper.toConfigCase(modelMetadata)}${requiredString} ${tags.join(' ')}\n`;
+            }
+        }
+        section += '}\n';
+        return section;
+    }
+    static toConfigCase(modelType) {
+        const type = modelType.type;
+        const input = type.name;
+        if (input == 'Number') {
+            return 'Int';
+        }
+        if (input == 'Object') {
+            return 'Json';
+        }
+        if (input == 'Date') {
+            return 'DateTime';
+        }
+        const firstChar = input.charAt(0).toUpperCase();
+        const restOfString = input.slice(1);
+        return firstChar + restOfString;
+    }
+}
+exports.DbHelper = DbHelper;

package/dist/helper/FieldsHelper.d.ts

@@ -0,0 +1,4 @@
+export declare class FieldsHelper {
+    private constructor();
+    static getAllClassFields(target: any): string[];
+}

package/dist/helper/FieldsHelper.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldsHelper = void 0;
+class FieldsHelper {
+    constructor() {
+        throw new Error(`Class ${this.constructor.name} cannot be instanced.`);
+    }
+    static getAllClassFields(target) {
+        // Get instance properties
+        const instanceFields = Object.getOwnPropertyNames(target.prototype);
+        // Get static properties
+        const staticFields = Object.getOwnPropertyNames(target);
+        // Get decorated properties using Reflect metadata if available
+        const decoratedFields = Reflect.getMetadataKeys(target.prototype) || [];
+        // Combine all fields and remove duplicates and methods
+        const allFields = new Set([
+            ...instanceFields,
+            ...staticFields,
+            ...decoratedFields
+        ]);
+        // Filter out constructor and methods
+        return Array.from(allFields).filter(field => {
+            // Remove constructor
+            if (field === 'constructor')
+                return false;
+            // Remove methods
+            const descriptor = Object.getOwnPropertyDescriptor(target.prototype, field);
+            if (descriptor && typeof descriptor.value === 'function')
+                return false;
+            return true;
+        });
+    }
+    ;
+}
+exports.FieldsHelper = FieldsHelper;

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import { DBService } from "./services/DBService";
+import { RWSModel, OpModelType } from "./models/_model";
+import TimeSeriesModel from './models/TimeSeriesModel';
+import { InverseRelation, Relation, TrackType, InverseTimeSeries, IMetaOpts } from './decorators';
+import { DbHelper } from './helper/DbHelper';
+import { FieldsHelper } from './helper/FieldsHelper';
+import type { FindByType } from './types/FindParams';
+import type { ITimeSeries } from './types/ITimeSeries';
+import type { IDbConfigHandler } from './types/DbConfigHandler';
+import type { IRWSModel } from './types/IRWSModel';
+export { OpModelType, RWSModel, IRWSModel, IMetaOpts, DBService, FindByType, TimeSeriesModel, ITimeSeries, IDbConfigHandler, InverseRelation, Relation, TrackType, InverseTimeSeries, DbHelper, FieldsHelper };

package/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldsHelper = exports.DbHelper = exports.InverseTimeSeries = exports.TrackType = exports.Relation = exports.InverseRelation = exports.TimeSeriesModel = exports.DBService = exports.RWSModel = void 0;
+const DBService_1 = require("./services/DBService");
+Object.defineProperty(exports, "DBService", { enumerable: true, get: function () { return DBService_1.DBService; } });
+const _model_1 = require("./models/_model");
+Object.defineProperty(exports, "RWSModel", { enumerable: true, get: function () { return _model_1.RWSModel; } });
+const TimeSeriesModel_1 = __importDefault(require("./models/TimeSeriesModel"));
+exports.TimeSeriesModel = TimeSeriesModel_1.default;
+const decorators_1 = require("./decorators");
+Object.defineProperty(exports, "InverseRelation", { enumerable: true, get: function () { return decorators_1.InverseRelation; } });
+Object.defineProperty(exports, "Relation", { enumerable: true, get: function () { return decorators_1.Relation; } });
+Object.defineProperty(exports, "TrackType", { enumerable: true, get: function () { return decorators_1.TrackType; } });
+Object.defineProperty(exports, "InverseTimeSeries", { enumerable: true, get: function () { return decorators_1.InverseTimeSeries; } });
+const DbHelper_1 = require("./helper/DbHelper");
+Object.defineProperty(exports, "DbHelper", { enumerable: true, get: function () { return DbHelper_1.DbHelper; } });
+const FieldsHelper_1 = require("./helper/FieldsHelper");
+Object.defineProperty(exports, "FieldsHelper", { enumerable: true, get: function () { return FieldsHelper_1.FieldsHelper; } });

package/dist/models/TimeSeriesModel.d.ts

@@ -0,0 +1,7 @@
+import { RWSModel } from './_model';
+export default class TimeSeriesModel<ChildClass> extends RWSModel<TimeSeriesModel<ChildClass>> {
+    value: number;
+    timestamp: Date;
+    params: any;
+    constructor(data?: any);
+}

package/dist/models/TimeSeriesModel.js

@@ -0,0 +1,33 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const _model_1 = require("./_model");
+class TimeSeriesModel extends _model_1.RWSModel {
+    constructor(data) {
+        super(data);
+        if (!this.timestamp) {
+            this.timestamp = new Date();
+        }
+    }
+}
+exports.default = TimeSeriesModel;
+__decorate([
+    (0, _model_1.TrackType)(Number),
+    __metadata("design:type", Number)
+], TimeSeriesModel.prototype, "value", void 0);
+__decorate([
+    (0, _model_1.TrackType)(Date),
+    __metadata("design:type", Date)
+], TimeSeriesModel.prototype, "timestamp", void 0);
+__decorate([
+    (0, _model_1.TrackType)(Object),
+    __metadata("design:type", Object)
+], TimeSeriesModel.prototype, "params", void 0);

package/dist/models/_model.d.ts

@@ -0,0 +1,116 @@
+import { DBService } from '../services/DBService';
+import { IRWSModel } from '../types/IRWSModel';
+import { IDbConfigHandler } from '../types/DbConfigHandler';
+import { TrackType, IMetaOpts } from '../decorators';
+import { FindByType } from '../types/FindParams';
+interface IModel {
+    [key: string]: any;
+    id: string | null;
+    save: () => void;
+    getCollection: () => string | null;
+    configService?: IDbConfigHandler;
+    dbService?: DBService;
+}
+interface IRWSModelServices {
+    configService?: IDbConfigHandler;
+    dbService?: DBService;
+}
+type RelationBindType = {
+    connect: {
+        id: string;
+    };
+};
+type RelOneMetaType<T extends IRWSModel> = {
+    [key: string]: {
+        required: boolean;
+        key?: string;
+        model: OpModelType<T>;
+        hydrationField: string;
+        foreignKey: string;
+    };
+};
+type RelManyMetaType<T extends IRWSModel> = {
+    [key: string]: {
+        key: string;
+        inversionModel: OpModelType<T>;
+        foreignKey: string;
+    };
+};
+export interface OpModelType<ChildClass> {
+    new (data?: any | null): ChildClass;
+    services: IRWSModelServices;
+    name: string;
+    _collection: string;
+    _RELATIONS: {
+        [key: string]: boolean;
+    };
+    _CUT_KEYS: string[];
+    allModels: OpModelType<any>[];
+    loadModels: () => OpModelType<any>[];
+    checkForInclusionWithThrow: (className: string) => void;
+    checkForInclusion: (className: string) => boolean;
+    findOneBy<T extends RWSModel<T>>(this: OpModelType<T>, findParams: FindByType): Promise<T | null>;
+    find<T extends RWSModel<T>>(this: OpModelType<T>, id: string, findParams?: Omit<FindByType, 'conditions'>): Promise<T | null>;
+    findBy<T extends RWSModel<T>>(this: OpModelType<T>, findParams: FindByType): Promise<T[]>;
+    delete<ChildClass extends RWSModel<ChildClass>>(this: OpModelType<ChildClass>, conditions: any): Promise<void>;
+    create<T extends RWSModel<T>>(this: OpModelType<T>, data: T): Promise<T>;
+    getRelationOneMeta(model: any, classFields: string[]): Promise<RelOneMetaType<IRWSModel>>;
+    getRelationManyMeta(model: any, classFields: string[]): Promise<RelManyMetaType<IRWSModel>>;
+    getCollection(): string;
+    setServices(services: IRWSModelServices): void;
+}
+declare class RWSModel<ChildClass> implements IModel {
+    static services: IRWSModelServices;
+    [key: string]: any;
+    id: string;
+    static _collection: string;
+    static _RELATIONS: {};
+    static _BANNED_KEYS: string[];
+    static allModels: OpModelType<any>[];
+    static _CUT_KEYS: string[];
+    constructor(data: any);
+    checkForInclusionWithThrow(): void;
+    static checkForInclusionWithThrow(this: OpModelType<any>, checkModelType: string): void;
+    checkForInclusion(): boolean;
+    static checkForInclusion(this: OpModelType<any>, checkModelType: string): boolean;
+    protected _fill(data: any): RWSModel<ChildClass>;
+    protected hasRelation(key: string): boolean;
+    protected bindRelation(key: string, relatedModel: RWSModel<any>): RelationBindType;
+    _asyncFill(data: any, fullDataMode?: boolean, allowRelations?: boolean): Promise<ChildClass>;
+    private getModelScalarFields;
+    private getTimeSeriesModelFields;
+    private getRelationOneMeta;
+    static getRelationOneMeta(model: any, classFields: string[]): Promise<RelOneMetaType<RWSModel<any>>>;
+    private getRelationManyMeta;
+    static getRelationManyMeta(model: any, classFields: string[]): Promise<RelManyMetaType<RWSModel<any>>>;
+    toMongo(): Promise<any>;
+    getCollection(): string | null;
+    static getCollection(): string | null;
+    save(): Promise<this>;
+    static getModelAnnotations<T extends unknown>(constructor: new () => T): Promise<Record<string, {
+        annotationType: string;
+        metadata: any;
+    }>>;
+    preUpdate(): void;
+    postUpdate(): void;
+    preCreate(): void;
+    postCreate(): void;
+    static isSubclass<T extends RWSModel<T>, C extends new () => T>(constructor: C, baseClass: new () => T): boolean;
+    hasTimeSeries(): boolean;
+    static checkTimeSeries(constructor: any): boolean;
+    isDbVariable(variable: string): Promise<boolean>;
+    static checkDbVariable(constructor: any, variable: string): Promise<boolean>;
+    sanitizeDBData(data: any): any;
+    static watchCollection<ChildClass extends RWSModel<ChildClass>>(this: OpModelType<ChildClass>, preRun: () => void): Promise<any>;
+    static findOneBy<ChildClass extends RWSModel<ChildClass>>(this: OpModelType<ChildClass>, findParams?: FindByType): Promise<ChildClass | null>;
+    static find<ChildClass extends RWSModel<ChildClass>>(this: OpModelType<ChildClass>, id: string, findParams?: Omit<FindByType, 'conditions'>): Promise<ChildClass | null>;
+    static findBy<ChildClass extends RWSModel<ChildClass>>(this: OpModelType<ChildClass>, findParams?: FindByType): Promise<ChildClass[]>;
+    static delete<ChildClass extends RWSModel<ChildClass>>(this: OpModelType<ChildClass>, conditions: any): Promise<void>;
+    delete<ChildClass extends RWSModel<ChildClass>>(): Promise<void>;
+    static create<T extends RWSModel<T>>(this: new () => T, data: any): Promise<T>;
+    static loadModels(): OpModelType<any>[];
+    loadModels(): OpModelType<any>[];
+    private checkRelEnabled;
+    static setServices(services: IRWSModelServices): void;
+}
+export { IModel, TrackType, IMetaOpts, RWSModel };