@stemy/backend 5.2.1 → 6.0.0

package/services/job-manager.d.ts

@@ -1,35 +1,35 @@
-import { DependencyContainer } from "tsyringe";
-import { Socket } from "zeromq";
-import { Subject, Subscription } from "rxjs";
-import { IJob, IJobTask, ISocketMessage, JobParams, JobScheduleTime, SocketParams, Type } from "../common-types";
-import { Configuration } from "./configuration";
-import { Logger } from "./logger";
-export declare class JobManager {
-    readonly config: Configuration;
-    readonly logger: Logger;
-    readonly container: DependencyContainer;
-    protected jobTypes: Type<IJob>[];
-    protected jobs: {
-        [name: string]: (jobParams: JobParams, uniqueId: string) => Promise<any>;
-    };
-    protected messages: Subject<ISocketMessage>;
-    protected processing: Promise<any>;
-    protected apiPush: Socket;
-    protected apiPull: Socket;
-    protected workerPush: Socket;
-    protected workerPull: Socket;
-    readonly maxTimeout: number;
-    constructor(config: Configuration, logger: Logger, container: DependencyContainer, jobTypes: Type<IJob>[]);
-    on(message: string, cb: (params: SocketParams) => any): Subscription;
-    process(jobType: Type<IJob>, params?: JobParams): Promise<any>;
-    enqueueWithName(name: string, params?: JobParams): Promise<string>;
-    enqueue(jobType: Type<IJob>, params?: JobParams): Promise<string>;
-    schedule(minute: JobScheduleTime, hour: JobScheduleTime, dayOfMonth: JobScheduleTime, month: JobScheduleTime, dayOfWeek: JobScheduleTime, jobType: Type<IJob>, params?: JobParams): IJobTask;
-    protected initProcessing(): Promise<void>;
-    startProcessing(): Promise<void>;
-    tryResolve(jobType: Type<IJob>, params: JobParams): string;
-    protected tryResolveFromName(jobName: string, params: JobParams): string;
-    protected tryResolveAndInit(jobType: Type<IJob>, params: JobParams): string;
-    protected resolveJobInstance(jobType: Type<IJob>, params: JobParams, uniqueId?: string): IJob;
-    protected sendToWorkers(jobName: string, params: JobParams): Promise<string>;
-}
+import { DependencyContainer } from "tsyringe";
+import { Socket } from "zeromq/v5-compat";
+import { Subject, Subscription } from "rxjs";
+import { IJob, IJobTask, ISocketMessage, JobParams, JobScheduleTime, SocketParams, Type } from "../common-types";
+import { Configuration } from "./configuration";
+import { Logger } from "./logger";
+export declare class JobManager {
+    readonly config: Configuration;
+    readonly logger: Logger;
+    readonly container: DependencyContainer;
+    protected jobTypes: Type<IJob>[];
+    protected jobs: {
+        [name: string]: (jobParams: JobParams, uniqueId: string) => Promise<any>;
+    };
+    protected messages: Subject<ISocketMessage>;
+    protected processing: Promise<any>;
+    protected apiPush: Socket;
+    protected apiPull: Socket;
+    protected workerPush: Socket;
+    protected workerPull: Socket;
+    readonly maxTimeout: number;
+    constructor(config: Configuration, logger: Logger, container: DependencyContainer, jobTypes: Type<IJob>[]);
+    on(message: string, cb: (params: SocketParams) => any): Subscription;
+    process(jobType: Type<IJob>, params?: JobParams): Promise<any>;
+    enqueueWithName(name: string, params?: JobParams): Promise<string>;
+    enqueue(jobType: Type<IJob>, params?: JobParams): Promise<string>;
+    schedule(minute: JobScheduleTime, hour: JobScheduleTime, dayOfMonth: JobScheduleTime, month: JobScheduleTime, dayOfWeek: JobScheduleTime, jobType: Type<IJob>, params?: JobParams): IJobTask;
+    protected initProcessing(): Promise<void>;
+    startProcessing(): Promise<void>;
+    tryResolve(jobType: Type<IJob>, params: JobParams): string;
+    protected tryResolveFromName(jobName: string, params: JobParams): string;
+    protected tryResolveAndInit(jobType: Type<IJob>, params: JobParams): string;
+    protected resolveJobInstance(jobType: Type<IJob>, params: JobParams, uniqueId?: string): IJob;
+    protected sendToWorkers(jobName: string, params: JobParams): Promise<string>;
+}

package/services/lazy-assets.d.ts

@@ -1,22 +1,22 @@
-import { ObjectId } from "bson";
-import { Collection } from "mongodb";
-import { FilterQuery } from "mongoose";
-import { IJob, ILazyAsset, JobParams, Type } from "../common-types";
-import { MongoConnector } from "./mongo-connector";
-import { Assets } from "./assets";
-import { JobManager } from "./job-manager";
-import { Logger } from "./logger";
-import { Progresses } from "./progresses";
-export declare class LazyAssets {
-    readonly connector: MongoConnector;
-    readonly assets: Assets;
-    readonly progresses: Progresses;
-    readonly logger: Logger;
-    readonly jobMan: JobManager;
-    protected collection: Collection<Partial<ILazyAsset>>;
-    constructor(connector: MongoConnector, assets: Assets, progresses: Progresses, logger: Logger, jobMan: JobManager);
-    create(jobType: Type<IJob>, jobParamsObj?: JobParams, jobQue?: string): Promise<ILazyAsset>;
-    read(id: string | ObjectId): Promise<ILazyAsset>;
-    find(where: FilterQuery<ILazyAsset>): Promise<ILazyAsset>;
-    unlink(id: string): Promise<any>;
-}
+import { ObjectId } from "bson";
+import { Collection } from "mongodb";
+import { FilterQuery } from "mongoose";
+import { IJob, ILazyAsset, JobParams, Type } from "../common-types";
+import { MongoConnector } from "./mongo-connector";
+import { Assets } from "./assets";
+import { JobManager } from "./job-manager";
+import { Logger } from "./logger";
+import { Progresses } from "./progresses";
+export declare class LazyAssets {
+    readonly connector: MongoConnector;
+    readonly assets: Assets;
+    readonly progresses: Progresses;
+    readonly logger: Logger;
+    readonly jobMan: JobManager;
+    protected collection: Collection<Partial<ILazyAsset>>;
+    constructor(connector: MongoConnector, assets: Assets, progresses: Progresses, logger: Logger, jobMan: JobManager);
+    create(jobType: Type<IJob>, jobParamsObj?: JobParams, jobQue?: string): Promise<ILazyAsset>;
+    read(id: string | ObjectId): Promise<ILazyAsset>;
+    find(where: FilterQuery<ILazyAsset>): Promise<ILazyAsset>;
+    unlink(id: string): Promise<any>;
+}

package/services/logger.d.ts

@@ -1,8 +1,8 @@
-import { Configuration } from "./configuration";
-export declare class Logger {
-    readonly config: Configuration;
-    protected tags: string[];
-    protected ignoredTags: string[];
-    constructor(config: Configuration);
-    log(tag: string, ...params: any[]): void;
-}
+import { Configuration } from "./configuration";
+export declare class Logger {
+    readonly config: Configuration;
+    protected tags: string[];
+    protected ignoredTags: string[];
+    constructor(config: Configuration);
+    log(tag: string, ...params: any[]): void;
+}

package/services/mail-sender.d.ts

@@ -1,20 +1,20 @@
-import * as Mail from "nodemailer/lib/mailer";
-import { TemplateRenderer } from "./template-renderer";
-import { Translator } from "./translator";
-import { Configuration } from "./configuration";
-export interface MailOptions {
-    to: string;
-    from?: string;
-    subject?: string;
-    template: string;
-    context: any;
-    attachments?: Mail.Attachment[];
-}
-export declare class MailSender {
-    readonly config: Configuration;
-    readonly renderer: TemplateRenderer;
-    readonly transporter: Mail;
-    get translator(): Translator;
-    constructor(config: Configuration, renderer: TemplateRenderer);
-    sendMail(language: string, options: MailOptions): Promise<any>;
-}
+import * as Mail from "nodemailer/lib/mailer";
+import { TemplateRenderer } from "./template-renderer";
+import { Translator } from "./translator";
+import { Configuration } from "./configuration";
+export interface MailOptions {
+    to: string;
+    from?: string;
+    subject?: string;
+    template: string;
+    context: any;
+    attachments?: Mail.Attachment[];
+}
+export declare class MailSender {
+    readonly config: Configuration;
+    readonly renderer: TemplateRenderer;
+    readonly transporter: Mail;
+    get translator(): Translator;
+    constructor(config: Configuration, renderer: TemplateRenderer);
+    sendMail(language: string, options: MailOptions): Promise<any>;
+}

package/services/memory-cache.d.ts

@@ -1,10 +1,10 @@
-import { Cache, ICacheItem } from "./cache";
-export declare class MemoryCache {
-    protected readonly cache: Cache;
-    protected readonly cacheMap: Map<string, ICacheItem>;
-    constructor(cache: Cache);
-    set(key: string, value: any, ttl?: number, expirationTimestamp?: number, tags?: any): Promise<any>;
-    get(key: string): Promise<any>;
-    getOrSet(key: string, valueCb: () => Promise<any>, ttl?: number, expirationTimestamp?: number, tags?: any): Promise<any>;
-    delete(key: string): Promise<any>;
-}
+import { Cache, ICacheItem } from "./cache";
+export declare class MemoryCache {
+    protected readonly cache: Cache;
+    protected readonly cacheMap: Map<string, ICacheItem>;
+    constructor(cache: Cache);
+    set(key: string, value: any, ttl?: number, expirationTimestamp?: number, tags?: any): Promise<any>;
+    get(key: string): Promise<any>;
+    getOrSet(key: string, valueCb: () => Promise<any>, ttl?: number, expirationTimestamp?: number, tags?: any): Promise<any>;
+    delete(key: string): Promise<any>;
+}

package/services/mongo-connector.d.ts

@@ -1,12 +1,12 @@
-import { Db } from "mongodb";
-import mongoose from "mongoose";
-import { Configuration } from "./configuration";
-export declare class MongoConnector {
-    readonly configuration: Configuration;
-    get connection(): mongoose.Connection;
-    get database(): Db;
-    protected conn: mongoose.Connection;
-    protected db: Db;
-    constructor(configuration: Configuration);
-    connect(): Promise<Db>;
-}
+import { Db } from "mongodb";
+import mongoose from "mongoose";
+import { Configuration } from "./configuration";
+export declare class MongoConnector {
+    readonly configuration: Configuration;
+    get connection(): mongoose.Connection;
+    get database(): Db;
+    protected conn: mongoose.Connection;
+    protected db: Db;
+    constructor(configuration: Configuration);
+    connect(): Promise<Db>;
+}

package/services/open-api.d.ts

@@ -1,13 +1,13 @@
-import { OpenAPIObject, ReferenceObject, SchemaObject } from "openapi3-ts";
-import { IDependencyContainer, IRequest, OpenApiValidation } from "../common-types";
-export declare class OpenApi {
-    protected container: IDependencyContainer;
-    protected customValidation: OpenApiValidation;
-    protected docs: OpenAPIObject;
-    protected docsStr: string;
-    get apiDocs(): OpenAPIObject;
-    get apiDocsStr(): string;
-    constructor(container: IDependencyContainer, customValidation: OpenApiValidation);
-    schemaToExample(src: ReferenceObject | SchemaObject, req?: IRequest): Promise<any>;
-    protected createApiDocs(): OpenAPIObject;
-}
+import { OpenAPIObject, ReferenceObject, SchemaObject } from "openapi3-ts";
+import { IDependencyContainer, IRequest, OpenApiValidation } from "../common-types";
+export declare class OpenApi {
+    protected container: IDependencyContainer;
+    protected customValidation: OpenApiValidation;
+    protected docs: OpenAPIObject;
+    protected docsStr: string;
+    get apiDocs(): OpenAPIObject;
+    get apiDocsStr(): string;
+    constructor(container: IDependencyContainer, customValidation: OpenApiValidation);
+    schemaToExample(src: ReferenceObject | SchemaObject, req?: IRequest): Promise<any>;
+    protected createApiDocs(): OpenAPIObject;
+}

package/services/progresses.d.ts

@@ -1,20 +1,20 @@
-import { Collection } from "mongodb";
-import { FilterQuery } from "mongoose";
-import { IProgress } from "../common-types";
-import { MongoConnector } from "./mongo-connector";
-import { JobManager } from "./job-manager";
-export declare class Progresses {
-    readonly connector: MongoConnector;
-    readonly jobMan: JobManager;
-    protected collection: Collection<Partial<IProgress>>;
-    protected progresses: {
-        [id: string]: IProgress;
-    };
-    constructor(connector: MongoConnector, jobMan: JobManager);
-    waitToFinish(id: string): Promise<IProgress>;
-    get(id: string): Promise<IProgress>;
-    find(where: FilterQuery<IProgress>): Promise<IProgress>;
-    create(max?: number): Promise<IProgress>;
-    remove(id: string): Promise<any>;
-    protected waitForProgress(id: string, cb: () => Promise<IProgress>, delay: number): Promise<IProgress>;
-}
+import { Collection } from "mongodb";
+import { FilterQuery } from "mongoose";
+import { IProgress } from "../common-types";
+import { MongoConnector } from "./mongo-connector";
+import { JobManager } from "./job-manager";
+export declare class Progresses {
+    readonly connector: MongoConnector;
+    readonly jobMan: JobManager;
+    protected collection: Collection<Partial<IProgress>>;
+    protected progresses: {
+        [id: string]: IProgress;
+    };
+    constructor(connector: MongoConnector, jobMan: JobManager);
+    waitToFinish(id: string): Promise<IProgress>;
+    get(id: string): Promise<IProgress>;
+    find(where: FilterQuery<IProgress>): Promise<IProgress>;
+    create(max?: number): Promise<IProgress>;
+    remove(id: string): Promise<any>;
+    protected waitForProgress(id: string, cb: () => Promise<IProgress>, delay: number): Promise<IProgress>;
+}

package/services/template-renderer.d.ts

@@ -1,14 +1,14 @@
-import { Translator } from "./translator";
-import { Configuration } from "./configuration";
-export declare class TemplateRenderer {
-    readonly translator: Translator;
-    readonly config: Configuration;
-    templates: {
-        [name: string]: Function;
-    };
-    protected initPromise: Promise<any>;
-    constructor(translator: Translator, config: Configuration);
-    protected init(): Promise<any>;
-    parseTemplates(dir: string, dirPath: string[]): Promise<void>;
-    render(template: string, language: string, context?: any): Promise<string>;
-}
+import { Translator } from "./translator";
+import { Configuration } from "./configuration";
+export declare class TemplateRenderer {
+    readonly translator: Translator;
+    readonly config: Configuration;
+    templates: {
+        [name: string]: Function;
+    };
+    protected initPromise: Promise<any>;
+    constructor(translator: Translator, config: Configuration);
+    protected init(): Promise<any>;
+    parseTemplates(dir: string, dirPath: string[]): Promise<void>;
+    render(template: string, language: string, context?: any): Promise<string>;
+}

package/services/terminal-manager.d.ts

@@ -1,15 +1,15 @@
-import { ICommandMap, ISuggestionMap } from "@stemy/terminal-commands-addon";
-import { ITerminal, ITerminalCommand } from "../common-types";
-import { Logger } from "./logger";
-import { Configuration } from "./configuration";
-export declare class TerminalManager {
-    protected logger: Logger;
-    protected config: Configuration;
-    protected servicePassword: string;
-    protected suggestions: ISuggestionMap;
-    protected commands: ICommandMap;
-    protected loggedOutCommands: string[];
-    protected loggedInCommands: string[];
-    constructor(logger: Logger, config: Configuration, commands: ITerminalCommand[]);
-    loadAddons(terminal: ITerminal): void;
-}
+import { ICommandMap, ISuggestionMap } from "@stemy/terminal-commands-addon";
+import { ITerminal, ITerminalCommand } from "../common-types";
+import { Logger } from "./logger";
+import { Configuration } from "./configuration";
+export declare class TerminalManager {
+    protected logger: Logger;
+    protected config: Configuration;
+    protected servicePassword: string;
+    protected suggestions: ISuggestionMap;
+    protected commands: ICommandMap;
+    protected loggedOutCommands: string[];
+    protected loggedInCommands: string[];
+    constructor(logger: Logger, config: Configuration, commands: ITerminalCommand[]);
+    loadAddons(terminal: ITerminal): void;
+}

package/services/token-generator.d.ts

@@ -1,6 +1,6 @@
-export declare class TokenGenerator {
-    protected chars: string;
-    constructor();
-    generate(checkCb: (token: string) => Promise<boolean>): Promise<string>;
-    private generateToken;
-}
+export declare class TokenGenerator {
+    protected chars: string;
+    constructor();
+    generate(checkCb: (token: string) => Promise<boolean>): Promise<string>;
+    private generateToken;
+}

package/services/translation-provider.d.ts

@@ -1,9 +1,9 @@
-import { Configuration } from "./configuration";
-import { ITranslations } from "../common-types";
-import { Cache } from "./cache";
-export declare class TranslationProvider {
-    readonly config: Configuration;
-    readonly cache: Cache;
-    constructor(config: Configuration, cache: Cache);
-    getDictionary(language: string): Promise<ITranslations>;
-}
+import { Configuration } from "./configuration";
+import { ITranslations } from "../common-types";
+import { Cache } from "./cache";
+export declare class TranslationProvider {
+    readonly config: Configuration;
+    readonly cache: Cache;
+    constructor(config: Configuration, cache: Cache);
+    getDictionary(language: string): Promise<ITranslations>;
+}

package/services/translator.d.ts

@@ -1,15 +1,15 @@
-import { ITranslations } from "../common-types";
-import { TranslationProvider } from "./translation-provider";
-export declare class Translator {
-    private translationProvider;
-    protected dictionaries: {
-        [lang: string]: ITranslations;
-    };
-    constructor(translationProvider: TranslationProvider);
-    getDictionary(language: string): Promise<ITranslations>;
-    getTranslationSync(language: string, key: string, params?: any): string;
-    getTranslation(language: string, key: string, params?: any): Promise<string>;
-    getTranslations(language: string, ...keys: string[]): Promise<ITranslations>;
-    protected interpolate(expr: string | Function, params?: any): string;
-    protected interpolateString(expr: string, params?: any): string;
-}
+import { ITranslations } from "../common-types";
+import { TranslationProvider } from "./translation-provider";
+export declare class Translator {
+    private translationProvider;
+    protected dictionaries: {
+        [lang: string]: ITranslations;
+    };
+    constructor(translationProvider: TranslationProvider);
+    getDictionary(language: string): Promise<ITranslations>;
+    getTranslationSync(language: string, key: string, params?: any): string;
+    getTranslation(language: string, key: string, params?: any): Promise<string>;
+    getTranslations(language: string, ...keys: string[]): Promise<ITranslations>;
+    protected interpolate(expr: string | Function, params?: any): string;
+    protected interpolateString(expr: string, params?: any): string;
+}

package/services/user-manager.d.ts

@@ -1,6 +1,6 @@
-import { IUser } from "../common-types";
-export declare class UserManager {
-    getByCredentials(credentials: any): Promise<IUser>;
-    getById(id: string): Promise<IUser>;
-    serialize(user: IUser): Promise<any>;
-}
+import { IUser } from "../common-types";
+export declare class UserManager {
+    getByCredentials(credentials: any): Promise<IUser>;
+    getById(id: string): Promise<IUser>;
+    serialize(user: IUser): Promise<any>;
+}

package/socket-controllers/progress.controller.d.ts

@@ -1,10 +1,10 @@
-import { Server } from "socket.io";
-import { IClientSocket } from "../common-types";
-import { Progresses } from "../services/progresses";
-export declare class ProgressController {
-    readonly progresses: Progresses;
-    readonly socketServer: Server;
-    constructor(progresses: Progresses, socketServer: Server);
-    advanceProgress(client: IClientSocket, progressId: string): Promise<void>;
-    setProgressInterest(client: IClientSocket, progressId: string): Promise<void>;
-}
+import { Server } from "socket.io";
+import { IClientSocket } from "../common-types";
+import { Progresses } from "../services/progresses";
+export declare class ProgressController {
+    readonly progresses: Progresses;
+    readonly socketServer: Server;
+    constructor(progresses: Progresses, socketServer: Server);
+    advanceProgress(client: IClientSocket, progressId: string): Promise<void>;
+    setProgressInterest(client: IClientSocket, progressId: string): Promise<void>;
+}

package/socket-controllers/terminal.controller.d.ts

@@ -1,13 +1,13 @@
-import { IClientSocket, ITerminalFile } from "../common-types";
-import { TerminalManager } from "../services/terminal-manager";
-import { Terminal } from "./terminal";
-export declare class TerminalController {
-    protected manager: TerminalManager;
-    protected terminals: {
-        [id: string]: Terminal;
-    };
-    constructor(manager: TerminalManager);
-    terminalInit(client: IClientSocket): Promise<void>;
-    terminalData(client: IClientSocket, data: string): Promise<void>;
-    terminalUpload(client: IClientSocket, upload: ITerminalFile): Promise<void>;
-}
+import { IClientSocket, ITerminalFile } from "../common-types";
+import { TerminalManager } from "../services/terminal-manager";
+import { Terminal } from "./terminal";
+export declare class TerminalController {
+    protected manager: TerminalManager;
+    protected terminals: {
+        [id: string]: Terminal;
+    };
+    constructor(manager: TerminalManager);
+    terminalInit(client: IClientSocket): Promise<void>;
+    terminalData(client: IClientSocket, data: string): Promise<void>;
+    terminalUpload(client: IClientSocket, upload: ITerminalFile): Promise<void>;
+}

package/socket-controllers/terminal.d.ts

@@ -1,20 +1,19 @@
-/// <reference types="node" />
-import { BehaviorSubject, Subject } from "rxjs";
-import { IDisposable, ITerminalAddon } from "@stemy/terminal-commands-addon";
-import { IClientSocket, ITerminal, ITerminalFile } from "../common-types";
-export declare class Terminal implements ITerminal {
-    protected client: IClientSocket;
-    protected addons: ITerminalAddon[];
-    protected files$: BehaviorSubject<ITerminalFile[]>;
-    protected input$: Subject<string>;
-    constructor(client: IClientSocket);
-    onData(cb: (data: string) => any): IDisposable;
-    write(data: string): void;
-    writeln(data: string): void;
-    loadAddon(addon: ITerminalAddon): void;
-    dispose(): void;
-    suggestFiles(accept: string): Promise<ITerminalFile[]>;
-    downloadFile(filename: string, buffer: Buffer): Promise<void>;
-    addFile(upload: ITerminalFile): void;
-    input(data: string): void;
-}
+import { BehaviorSubject, Subject } from "rxjs";
+import { IDisposable, ITerminalAddon } from "@stemy/terminal-commands-addon";
+import { IClientSocket, ITerminal, ITerminalFile } from "../common-types";
+export declare class Terminal implements ITerminal {
+    protected client: IClientSocket;
+    protected addons: ITerminalAddon[];
+    protected files$: BehaviorSubject<ITerminalFile[]>;
+    protected input$: Subject<string>;
+    constructor(client: IClientSocket);
+    onData(cb: (data: string) => any): IDisposable;
+    write(data: string): void;
+    writeln(data: string): void;
+    loadAddon(addon: ITerminalAddon): void;
+    dispose(): void;
+    suggestFiles(accept: string): Promise<ITerminalFile[]>;
+    downloadFile(filename: string, buffer: Buffer): Promise<void>;
+    addFile(upload: ITerminalFile): void;
+    input(data: string): void;
+}

package/socket-middlewares/compression.middleware.d.ts

@@ -1,4 +1,4 @@
-import { MiddlewareInterface } from "socket-controllers";
-export declare class CompressionMiddleware implements MiddlewareInterface {
-    use(socket: any, next: (err?: any) => any): void;
-}
+import { MiddlewareInterface } from "socket-controllers";
+export declare class CompressionMiddleware implements MiddlewareInterface {
+    use(socket: any, next: (err?: any) => any): void;
+}

package/static.d.ts

@@ -1,2 +1,2 @@
-import { IDependencyContainer } from "./common-types";
-export declare function setupStatic(rootFolder: string, container: IDependencyContainer): Promise<any>;
+import { IDependencyContainer } from "./common-types";
+export declare function setupStatic(rootFolder: string, container: IDependencyContainer): Promise<any>;

package/utilities/base-doc.d.ts

@@ -1,40 +1,40 @@
-import { RefType } from "mongoose";
-import mongoose from "mongoose";
-import { DocumentType, ReturnModelType } from "@typegoose/typegoose";
-import { Constructor } from "../common-types";
-export declare abstract class BaseDoc<IDType extends RefType = mongoose.Types.ObjectId> {
-    _id?: IDType;
-    /**
-     * This getter/setter doesn't exist if "schemaOptions.id" being set to "false"
-     */
-    id: string;
-    /**
-     * This getter doesn't exist if "schemaOptions.timestamps" being set to "false"
-     */
-    createdAt?: Date;
-    /**
-     * This getter doesn't exist if "schemaOptions.timestamps" being set to "false"
-     */
-    updatedAt?: Date;
-    /**
-     * Returns the Document as JSON
-     */
-    toJSON?(): any;
-    /**
-     * Returns the Document as an Object
-     */
-    toObject?(): any;
-    /**
-     * Casts this to DocumentType<this> to allow using document methods in get/set-s
-     */
-    cast<ImplType = this>(): DocumentType<ImplType>;
-    /**
-     * Gets a pre-compiled model from typegoose cache by its class type
-     * @param type
-     */
-    model<T extends Constructor<any>>(type: T): ReturnModelType<T>;
-}
-export type PrimitiveArray<T> = mongoose.Types.Array<T>;
-export declare const PrimitiveArray: typeof mongoose.Types.Array;
-export type DocumentArray<T extends BaseDoc> = mongoose.Types.DocumentArray<DocumentType<T>>;
-export declare const DocumentArray: typeof mongoose.Types.DocumentArray;
+import { RefType } from "mongoose";
+import mongoose from "mongoose";
+import { DocumentType, ReturnModelType } from "@typegoose/typegoose";
+import { Constructor } from "../common-types";
+export declare abstract class BaseDoc<IDType extends RefType = mongoose.Types.ObjectId> {
+    _id?: IDType;
+    /**
+     * This getter/setter doesn't exist if "schemaOptions.id" being set to "false"
+     */
+    id: string;
+    /**
+     * This getter doesn't exist if "schemaOptions.timestamps" being set to "false"
+     */
+    createdAt?: Date;
+    /**
+     * This getter doesn't exist if "schemaOptions.timestamps" being set to "false"
+     */
+    updatedAt?: Date;
+    /**
+     * Returns the Document as JSON
+     */
+    toJSON?(): any;
+    /**
+     * Returns the Document as an Object
+     */
+    toObject?(): any;
+    /**
+     * Casts this to DocumentType<this> to allow using document methods in get/set-s
+     */
+    cast<ImplType = this>(): DocumentType<ImplType>;
+    /**
+     * Gets a pre-compiled model from typegoose cache by its class type
+     * @param type
+     */
+    model<T extends Constructor<any>>(type: T): ReturnModelType<T>;
+}
+export type PrimitiveArray<T> = mongoose.Types.Array<T>;
+export declare const PrimitiveArray: typeof mongoose.Types.Array;
+export type DocumentArray<T extends BaseDoc> = mongoose.Types.DocumentArray<DocumentType<T>>;
+export declare const DocumentArray: typeof mongoose.Types.DocumentArray;