taon 0.0.0 → 18.0.12

package/websql/lib/decorators/http/http-params-decorators.d.ts

@@ -0,0 +1,6 @@
+// @ts-nocheck
+export declare function Path(name: string): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+export declare function Query(name?: string): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+export declare function Cookie(name: string, expireInSecond?: number): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+export declare function Header(name?: string): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+export declare function Body(name?: string): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;

package/websql/lib/dependency-injection/di-container.d.ts

@@ -0,0 +1,6 @@
+// @ts-nocheck
+export declare class DITaonContainer {
+    private static instances;
+    static resolve<T>(target: Function): T;
+    static inject<T>(target: new (...args: any[]) => T): T;
+}

package/websql/lib/endpoint-context.d.ts

@@ -0,0 +1,117 @@
+// @ts-nocheck
+import { Models } from './models';
+import type { Application } from 'express';
+import type { NgZone } from '@angular/core';
+import { DataSource } from 'taon-typeorm/websql';
+import type { Server } from 'http';
+import type { BaseClass } from './base-classes/base-class';
+export declare class EndpointContext {
+    private originalConfig;
+    private configFn;
+    private static ngZone;
+    static initNgZone(ngZone: NgZone): void;
+    static findForTraget(classFnOrObject: any): EndpointContext;
+    disabledRealtime: boolean;
+    /**
+     * check whether context is inited
+     * (with init() function )
+     */
+    inited: boolean;
+    private readonly localInstaceObjSymbol;
+    /**
+     * all instances of classes from context
+     * key is class name
+     */
+    readonly allClassesInstances: {};
+    private readonly classInstancesByNameObj;
+    private readonly objWithClassesInstancesArr;
+    readonly activeRoutes: {
+        routePath: string;
+        method: Models.Http.Rest.HttpMethod;
+    }[];
+    private injectableTypesfromContexts;
+    private allTypesfromContexts;
+    expressApp: Application;
+    serverTcpUdp: Server;
+    databaseConfig?: Models.DatabaseConfig;
+    private autoGeneratedConfig?;
+    mode: Models.FrameworkMode;
+    session?: Models.ISession;
+    connection: DataSource;
+    private entitiesTriggers;
+    private realtime;
+    get realtimeClient(): import("./realtime/realtime-client").RealtimeClient;
+    get realtimeServer(): import("./realtime/realtime-server").RealtimeServer;
+    /**
+     * available after init()
+     */
+    config: Models.ContextOptions<any, any, any, any, any, any>;
+    get logHttp(): boolean;
+    get logRealtime(): boolean;
+    get logFramework(): boolean;
+    get logDb(): boolean;
+    constructor(originalConfig: Models.ContextOptions<any, any, any, any, any, any>, configFn: (env: any) => Models.ContextOptions<any, any, any, any, any, any>);
+    init(options?: {
+        initFromRecrusiveContextResovle?: boolean;
+    }): Promise<void>;
+    private getAutoGeneratedConfig;
+    get ngZone(): any;
+    startServer(): any;
+    displayRoutes(app: any): void;
+    get modeAllowsDatabaseCreation(): boolean;
+    private cloneClassWithNewMetadata;
+    private cloneClassesObjWithNewMetadata;
+    private getRecrusiveClassesfromContextsObj;
+    private getRecrusiveClassesfromContexts;
+    getClassInstanceObjBy(classType: Models.ClassType): any;
+    private getClassesInstancesArrBy;
+    inject<T>(ctor: new (...args: any[]) => T, options?: {
+        localInstance?: boolean;
+        contextClassInstance?: BaseClass;
+        locaInstanceConstructorArgs?: ConstructorParameters<typeof ctor>;
+    }): T;
+    /**
+     * alias for inject
+     */
+    getInstanceBy<T>(ctor: new (...args: any[]) => T): T;
+    checkIfContextInitialized(): void;
+    getClassFunBy(classType: Models.ClassType): any;
+    isCLassType(classType: Models.ClassType, classFn: Function): boolean;
+    /**
+     * Only for injectable types
+     * Only for classType: CONTROLLER, REPOSITORY, PROVIDER
+     */
+    getClassFunByClassName(className: string): Function;
+    getClassFunByClass(classFunction: Function): Function;
+    getClassFunByArr(classType: Models.ClassType): Function[];
+    private createInstances;
+    reinitControllers(): Promise<void>;
+    initClasses(): Promise<void>;
+    isActiveOn(classInstance: object): boolean;
+    get uri(): URL;
+    get isHttpServer(): boolean;
+    /**
+     * ipc/udp needs this
+     */
+    get contextName(): string;
+    get publicAssets(): {
+        serverPath: string;
+        locationOnDisk: string;
+    }[];
+    get isProductionMode(): boolean;
+    get remoteHost(): string;
+    get host(): string;
+    get orgin(): string;
+    initSubscribers(): Promise<void>;
+    initEntities(): Promise<void>;
+    initDatabaseConnection(): Promise<void>;
+    initMetadata(): void;
+    writeActiveRoutes(): void;
+    get middlewares(): Models.MiddlewareType[];
+    private initMidleware;
+    private initServer;
+    /**
+     * client can be browser or nodejs (when remote host)
+     */
+    private initClient;
+}

package/websql/lib/entity-process.d.ts

@@ -0,0 +1,40 @@
+// @ts-nocheck
+import { Response } from 'express';
+/**
+ * @deprecated
+ */
+export declare const getTransformFunction: (target: Function) => (entity: any) => any;
+/**
+ * @deprecated
+ */
+export declare const singleTransform: (json: any) => any;
+export declare class EntityProcess {
+    /**
+     * Data from backend
+     */
+    private result;
+    private response;
+    static init(result: any, response: Response): Promise<void>;
+    /**
+     * Data to send
+     */
+    data: any;
+    /**
+     * Say yes to:
+     * - circural object
+     * - transform browser fn in decorator
+     */
+    private advancedManipulation;
+    private entityMapping;
+    private circural;
+    constructor(
+    /**
+     * Data from backend
+     */
+    result: any, response: Response);
+    private checkAdvancedManiupulation;
+    run(): Promise<void>;
+    applayTransformFn(): void;
+    setHeaders(): void;
+    send(): void;
+}

package/websql/lib/env.d.ts

@@ -0,0 +1,3 @@
+// @ts-nocheck
+declare const ENV: any;
+export { ENV };

package/websql/lib/get-response-value.d.ts

@@ -0,0 +1,7 @@
+// @ts-nocheck
+import { Models } from './models';
+import { Response as ExpressResponse, Request as ExpressRequest } from 'express';
+export declare const getResponseValue: <T>(response: Models.Http.Response<T>, options?: {
+    req: ExpressRequest;
+    res: ExpressResponse;
+}) => Promise<T>;

package/websql/lib/helpers/class-helpers.d.ts

@@ -0,0 +1,19 @@
+// @ts-nocheck
+import { Models } from '../models';
+export declare namespace ClassHelpers {
+    /**
+     * TODO - repalce in every place when getting class fn from object
+     */
+    const getClassFnFromObject: (json: Object) => any;
+    const getName: (classFnOrObject: any) => string;
+    const getOrginalClass: (classFnOrObject: any) => any;
+    const getFullInternalName: (classFnOrObject: any) => string;
+    const getUniquKey: (classFnOrObject: any) => string;
+    const isContextClassObject: (obj: any) => boolean;
+    const setName: (target: Function, className: string) => void;
+    const hasParentClassWithName: (target: Function, className: string, targets?: any[]) => boolean;
+    const getControllerConfig: (target: Function) => Models.ControllerConfig | undefined;
+    const getMethodsNames: (classOrClassInstance: any, allMethodsNames?: any[]) => string[];
+    const getControllerConfigs: (target: Function, configs?: Models.ControllerConfig[], callerTarget?: Function) => Models.RuntimeControllerConfig[];
+    const getCalculatedPathFor: (target: Function) => string;
+}

package/websql/lib/helpers/taon-helpers.d.ts

@@ -0,0 +1,17 @@
+// @ts-nocheck
+import { Models } from '../models';
+export declare namespace TaonHelpers {
+    const fillUpTo: (s: string, nCharacters: number) => string;
+    const isGoodPath: (p: string) => boolean;
+    const tryTransformParam: (param: any) => any;
+    const getExpressPath: (c: Models.RuntimeControllerConfig, pathOrClassConfig: Models.MethodConfig) => string;
+    const defaultType: (value: any) => {};
+    const parseJSONwithStringJSONs: (object: Object, waring?: boolean) => Object;
+    const isPlainFileOrFolder: (filePath: any) => boolean;
+    const ipcKeyNameResponse: (target: Function, methodConfig: Models.MethodConfig, expressPath: string) => string;
+    const ipcKeyNameRequest: (target: Function, methodConfig: Models.MethodConfig, expressPath: string) => string;
+    const websqlMocks: (headers: any) => {
+        request: Express.Request;
+        response: Express.Response;
+    };
+}

package/websql/lib/index.d.ts

@@ -0,0 +1,113 @@
+// @ts-nocheck
+import 'reflect-metadata';
+import * as http from './decorators/http/http-decorators';
+import * as base from './base-classes/base';
+import * as controllerDecorator from './decorators/classes/controller-decorator';
+import * as entityDecorator from './decorators/classes/entity-decorator';
+import * as providerDecorator from './decorators/classes/provider-decorator';
+import * as repositoryDecorator from './decorators/classes/repository-decorator';
+import * as subscriberDecorator from './decorators/classes/subscriber-decorator';
+import * as orm from './orm';
+import * as models from './models';
+import * as endpointContext from './endpoint-context';
+import * as allSymbols from './symbols';
+import { NgZone } from '@angular/core';
+export { BaseRepository } from './base-classes/base-repository';
+export { BaseController } from './base-classes/base-controller';
+export { BaseProvider } from './base-classes/base-provider';
+export { BaseSubscriber } from './base-classes/base-subscriber';
+export { BaseEntity } from './base-classes/base-entity';
+export { BaseContext } from './base-classes/base-context';
+export { createContext } from './create-context';
+export { inject } from './inject';
+export { Models } from './models';
+export * from './constants';
+export { ClassHelpers } from './helpers/class-helpers';
+export declare namespace Taon {
+    export import Response = models.Models.Http.Response;
+    export import Http = http.Http;
+    export import Base = base.Base;
+    export import Orm = orm.Orm;
+    const getResponseValue: <T>(response: Response<T>, options?: {
+        req: import("express").Request;
+        res: import("express").Response;
+    }) => Promise<T>;
+    export import Controller = controllerDecorator.TaonController;
+    export import Entity = entityDecorator.TaonEntity;
+    export import Provider = providerDecorator.TaonProvider;
+    export import Repository = repositoryDecorator.TaonRepository;
+    export import Subscriber = subscriberDecorator.TaonSubscriber;
+    /**
+     * @deprecated
+     */
+    const isBrowser: boolean;
+    /**
+     * @deprecated
+     */
+    const isNode: boolean;
+    /**
+     * @deprecated
+     */
+    const isWebSQL: boolean;
+    /**
+     * @deprecated
+     */
+    const isElectron: boolean;
+    const createContext: <CTX extends Record<string, object>, CTRL extends Record<string, new (...args: any[]) => any>, ENTITY extends Record<string, new (...args: any[]) => any>, REPO extends Record<string, new (...args: any[]) => any>, PROVIDER extends Record<string, new (...args: any[]) => any>, SUBSCRIBER extends Record<string, new (...args: any[]) => any>>(configFn: (env: any) => models.Models.ContextOptions<CTX, CTRL, ENTITY, REPO, PROVIDER, SUBSCRIBER>) => {
+        types: {
+            readonly controllers: CTRL;
+            readonly repositories: REPO;
+            readonly providers: PROVIDER;
+            readonly subscribers: SUBSCRIBER;
+        };
+        readonly contexts: CTX;
+        readonly contextName: string;
+        __ref(): Promise<endpointContext.EndpointContext>;
+        readonly __refSync: endpointContext.EndpointContext;
+        getClassInstance<T>(ctor: new (...args: any[]) => T): T;
+        getClass<T>(ctor: new (...args: any[]) => T): new (...args: any[]) => T;
+        initialize: () => Promise<endpointContext.EndpointContext>;
+    };
+    const inject: <T>(entity: () => new (...args: any[]) => T) => T;
+    const initNgZone: (ngZone: NgZone) => void;
+    const symbols: typeof allSymbols.Symbols;
+    /**
+     * @deprecated
+     * use createContext instead
+     */
+    const init: (options: {
+        host: string;
+        entities: Function[];
+        controllers: Function[];
+    }) => Promise<{
+        types: {
+            readonly controllers: any;
+            readonly repositories: Record<string, new (...args: any[]) => any>;
+            readonly providers: Record<string, new (...args: any[]) => any>;
+            readonly subscribers: Record<string, new (...args: any[]) => any>;
+        };
+        readonly contexts: {
+            BaseContext: {
+                types: {
+                    readonly controllers: Record<string, new (...args: any[]) => any>;
+                    readonly repositories: Record<string, new (...args: any[]) => any>;
+                    readonly providers: Record<string, new (...args: any[]) => any>;
+                    readonly subscribers: Record<string, new (...args: any[]) => any>;
+                };
+                readonly contexts: Record<string, object>;
+                readonly contextName: string;
+                __ref(): Promise<endpointContext.EndpointContext>;
+                readonly __refSync: endpointContext.EndpointContext;
+                getClassInstance<T>(ctor: new (...args: any[]) => T): T;
+                getClass<T>(ctor: new (...args: any[]) => T): new (...args: any[]) => T;
+                initialize: () => Promise<endpointContext.EndpointContext>;
+            };
+        };
+        readonly contextName: string;
+        __ref(): Promise<endpointContext.EndpointContext>;
+        readonly __refSync: endpointContext.EndpointContext;
+        getClassInstance<T>(ctor: new (...args: any[]) => T): T;
+        getClass<T>(ctor: new (...args: any[]) => T): new (...args: any[]) => T;
+        initialize: () => Promise<endpointContext.EndpointContext>;
+    }>;
+}

package/websql/lib/inject.d.ts

@@ -0,0 +1,9 @@
+// @ts-nocheck
+import { Observable } from 'rxjs';
+export declare const inject: <T>(entity: () => new (...args: any[]) => T) => T;
+export declare const injectController: <T>(entity: () => new (...args: any[]) => T) => T;
+export type SubscbtionEvent<T> = {
+    name: keyof T;
+    data: any;
+};
+export declare const injectSubscriberEvents: <T>(subscriberClassResolveFn: () => new (...args: any[]) => T, eventName: keyof T) => Observable<SubscbtionEvent<T>>;

package/websql/lib/models.d.ts

@@ -0,0 +1,181 @@
+// @ts-nocheck
+import { CoreModels } from 'tnp-core/websql';
+import { RequestHandler } from 'express';
+import { Response as ExpressResponse, Request as ExpressRequest } from 'express';
+import { Models as ModelsNg2Rest } from 'ng2-rest/websql';
+export declare namespace Models {
+    type FrameworkMode = 'backend-frontend(tcp+udp)' | 'remote-backend(tcp+udp)' | 'backend-frontend(ipc-electron)' | 'backend-frontend(websql)';
+    enum ClassType {
+        ENTITY = "ENTITY",
+        CONTROLLER = "CONTROLLER",
+        REPOSITORY = "REPOSITORY",
+        PROVIDER = "PROVIDER",
+        SUBSCRIBER = "SUBSCRIBER"
+    }
+    const ClassTypeKey: { [key in ClassType]: keyof ContextOptions<any, any, any, any, any, any>; };
+    type MiddlewareType = [Function, any[]];
+    interface DatabaseConfig {
+        /**
+         * database name
+         */
+        database?: string;
+        /**
+         * only for file base db: sqlite, sqljs
+         */
+        location?: string;
+        synchronize: boolean;
+        dropSchema: boolean;
+        type?: CoreModels.DatabaseType;
+        autoSave: boolean;
+        /**
+         * for websql db mode
+         */
+        useLocalForage?: boolean;
+        logging: boolean;
+        databasePort?: number;
+        databaseHost?: string;
+        databaseUsername?: string;
+        databasePassword?: string;
+    }
+    type ISession = {
+        secret?: string;
+        saveUninitialized?: boolean;
+        /**
+         * max age of session
+         */
+        cookieMaxAge?: number;
+        secure?: boolean;
+        resave?: boolean;
+    };
+    type ContectionOptionsLogs = {
+        http: boolean;
+        realtime: boolean;
+        framework: boolean;
+        db: boolean;
+    };
+    interface ContextOptions<CONTEXTS, CONTROLLERS, ENTITIES, REPOSITORIES, PROVIDERS, SUBSCRIBERS> {
+        contextName: string;
+        host?: string;
+        /**
+       * frontend host only needed when we are using
+       * withCredentials for axios
+       * and session cookie
+       */
+        frontendHost?: string;
+        remoteHost?: string;
+        useIpcWhenElectron?: boolean;
+        contexts?: CONTEXTS;
+        controllers?: CONTROLLERS;
+        entities?: ENTITIES;
+        repositories?: REPOSITORIES;
+        providers?: PROVIDERS;
+        subscribers?: SUBSCRIBERS;
+        session?: ISession;
+        productionMode?: boolean;
+        abstract?: boolean;
+        logs?: boolean | ContectionOptionsLogs;
+        database?: boolean | DatabaseConfig;
+        disabledRealtime?: boolean;
+        https?: {
+            key: string;
+            cert: string;
+        };
+        publicAssets?: {
+            serverPath: string;
+            locationOnDisk: string;
+        }[];
+        middlewares?: MiddlewareType[];
+        /**
+         * @deprecated
+         * only for debugging purpose
+         */
+        override?: {
+            entities?: Function[];
+            controllers?: Function[];
+            repositories?: Function[];
+            providers?: Function[];
+            subscribers?: Function[];
+        };
+    }
+    class DecoratorAbstractOpt {
+        className: string;
+    }
+    class ParamConfig {
+        paramName: string;
+        paramType: CoreModels.ParamType;
+        index: number;
+        defaultType: any;
+        expireInSeconds?: number;
+    }
+    class MethodConfig {
+        methodName: string;
+        /**
+         * path is global in express app
+         */
+        global?: boolean;
+        /**
+         * override default content type
+         */
+        contentType?: any;
+        /**
+         * override default axiso response type
+         */
+        responseType?: any;
+        path: string;
+        descriptor: PropertyDescriptor;
+        type: CoreModels.HttpMethod;
+        requestHandler: any;
+        parameters: {
+            [paramName: string]: ParamConfig;
+        };
+    }
+    class ControllerConfig extends DecoratorAbstractOpt {
+        realtime?: boolean;
+        path: string;
+        uniqueKey?: string;
+        methods: {
+            [methodName: string]: MethodConfig;
+        };
+    }
+    class RuntimeControllerConfig extends ControllerConfig {
+        calculatedPath?: string;
+        browserTransformFn?: (entity: any) => any;
+    }
+    namespace Http {
+        export import Rest = ModelsNg2Rest;
+        type ContextENDPOINT = {
+            target: Function;
+            initFN: Function;
+        };
+        type FormlyFromType = 'material' | 'bootstrap';
+        type ExpressContext<T> = (req: ExpressRequest, res: ExpressResponse) => T;
+        type SyncResponse<T> = string | T;
+        type ResponseFuncOpt<T> = {
+            limitSize?: (enties: Function | Function[], include: string[], exclude: string[]) => void;
+        };
+        type SyncResponseFunc<T> = (options?: ResponseFuncOpt<T>) => SyncResponse<T>;
+        type MixResponse<T> = SyncResponse<T> | ExpressContext<T>;
+        interface ClientAction<T> {
+            received?: Rest.PromiseObservableMix<Rest.HttpResponse<T>>;
+        }
+        interface __Response<T> {
+            send?: MixResponse<T>;
+        }
+        interface AsyncResponse<T> {
+            (req?: ExpressRequest, res?: ExpressResponse): Promise<SyncResponse<T> | SyncResponseFunc<T>>;
+        }
+        type Response<T = string> = (__Response<T> | AsyncResponse<T>) & ClientAction<T> & __Response<T>;
+        class Errors {
+            message: string;
+            private code;
+            toString: () => string;
+            private constructor();
+            private static create;
+            static entityNotFound(entity?: Function): Errors;
+            static custom(message: string, code?: ModelsNg2Rest.HttpCode): Errors;
+        }
+        interface AuthCallBack {
+            (methodReference: Function): RequestHandler;
+        }
+    }
+}

package/websql/lib/orm.d.ts

@@ -0,0 +1,52 @@
+// @ts-nocheck
+import * as tsorm from 'taon-typeorm/websql';
+export declare namespace Orm {
+    const Repository: typeof tsorm.Repository;
+    export import Connection = tsorm.Connection;
+    namespace ListenEvent {
+        export import AfterInsert = tsorm.AfterInsert;
+        export import AfterLoad = tsorm.AfterLoad;
+        export import AfterRecover = tsorm.AfterRecover;
+        export import AfterRemove = tsorm.AfterRemove;
+        export import AfterSoftRemove = tsorm.AfterSoftRemove;
+        export import AfterUpdate = tsorm.AfterUpdate;
+        export import BeforeInsert = tsorm.BeforeInsert;
+        export import BeforeRecover = tsorm.BeforeRecover;
+        export import BeforeRemove = tsorm.BeforeRemove;
+        export import BeforeSoftRemove = tsorm.BeforeSoftRemove;
+        export import BeforeUpdate = tsorm.BeforeUpdate;
+    }
+    namespace Tree {
+        export import Children = tsorm.TreeChildren;
+        export import Parent = tsorm.TreeParent;
+    }
+    namespace Column {
+        export import Generated = tsorm.PrimaryGeneratedColumn;
+        export import Primary = tsorm.PrimaryColumn;
+        export import Index = tsorm.Index;
+        export import CreateDate = tsorm.CreateDateColumn;
+        export import UpdateDate = tsorm.UpdateDateColumn;
+        export import DeleteDate = tsorm.DeleteDateColumn;
+        export import Custom = tsorm.Column;
+        /**
+         * 100 characters varchar
+         */
+        const String: () => PropertyDecorator;
+        const Number: () => PropertyDecorator;
+        const DecimalNumber: () => PropertyDecorator;
+        const SimpleJson: () => PropertyDecorator;
+        const Boolean: (defaultValue: boolean) => PropertyDecorator;
+        export import Version = tsorm.VersionColumn;
+        export import Virtual = tsorm.VirtualColumn;
+    }
+    namespace Join {
+        export import Table = tsorm.JoinTable;
+        export import Column = tsorm.JoinColumn;
+    }
+    namespace Relation {
+        export import OneToMany = tsorm.OneToMany;
+        export import OneToOne = tsorm.OneToOne;
+        export import ManyToMany = tsorm.ManyToMany;
+        export import ManyToOne = tsorm.ManyToOne;
+    }
+}

package/websql/lib/realtime/realtime-client.d.ts

@@ -0,0 +1,32 @@
+// @ts-nocheck
+import { RealtimeCore } from './realtime-core';
+import { Observable } from 'rxjs';
+import { RealtimeModels } from './realtime.models';
+import type { BaseEntity } from '../base-classes/base-entity';
+export declare class RealtimeClient {
+    private core;
+    private subsmanagers;
+    constructor(core: RealtimeCore);
+    private init;
+    /**
+     * Changes trigger on backend needs to be done manually.. example code:
+     *
+     * ...
+     * Context.Realtime.Server.TrigggerEntityChanges(myEntityInstance);
+     * ...
+     */
+    listenChangesEntity(entityClassFn: Function, idOrUniqValue: any, options: RealtimeModels.ChangeOption): Observable<unknown>;
+    listenChangesEntityTable(entityClassFn: Function): Observable<unknown>;
+    /**
+     * Changes trigger on backend needs to be done manually.. example code:
+     *
+     * ...
+     * Context.Realtime.Server.TrigggerEntityChanges(myEntityInstance);
+     * // or
+     * Context.Realtime.Server.TrigggerEntityPropertyChanges(myEntityInstance,{ property: 'geolocationX' });
+     * ...
+     */
+    listenChangesEntityObj<T extends BaseEntity>(entity: T, options?: RealtimeModels.ChangeOption): Observable<unknown>;
+    listenChangesCustomEvent(customEvent: string): Observable<unknown>;
+    private getRoomIdFrom;
+}

package/websql/lib/realtime/realtime-core.d.ts

@@ -0,0 +1,41 @@
+// @ts-nocheck
+import { Socket as SocketClient } from 'socket.io-client';
+import type { EndpointContext } from '../endpoint-context';
+import { RealtimeClient } from './realtime-client';
+import { RealtimeServer } from './realtime-server';
+import type { RealtimeStrategy } from './realtime-strategy';
+import { DefaultEventsMap } from 'socket.io/dist/typed-events';
+import { Server } from 'socket.io';
+/**
+ * Realtime class
+ * - mock (when browser-browser)
+ * - sockets (from socket io when backend-browser)
+ * - ipc (when electron is used or between processes)
+ * - webworker (when webworker is used in browser or nodejs)
+ */
+export declare class RealtimeCore {
+    ctx: EndpointContext;
+    readonly allHttpMethods: string[];
+    readonly client: RealtimeClient;
+    readonly server: RealtimeServer;
+    readonly strategy: RealtimeStrategy;
+    /**
+     * global FE socket
+     */
+    FE: SocketClient<DefaultEventsMap, DefaultEventsMap>;
+    /**
+     * socket for namespaces and rooms
+     */
+    FE_REALTIME: SocketClient<DefaultEventsMap, DefaultEventsMap>;
+    /**
+     * global BE socket
+     */
+    BE: Server<DefaultEventsMap, DefaultEventsMap, DefaultEventsMap, any>;
+    /**
+     * socket for namespaces and rooms
+     */
+    BE_REALTIME: Server<DefaultEventsMap, DefaultEventsMap, DefaultEventsMap, any>;
+    constructor(ctx: EndpointContext);
+    private resolveStrategy;
+    pathFor(namespace?: string): URL;
+}

package/websql/lib/realtime/realtime-server.d.ts

@@ -0,0 +1,14 @@
+// @ts-nocheck
+import { RealtimeCore } from './realtime-core';
+import type { BaseEntity } from '../base-classes/base-entity';
+export declare class RealtimeServer {
+    private core;
+    private jobs;
+    constructor(core: RealtimeCore);
+    private init;
+    private triggerChanges;
+    trigggerEntityChanges(entityObjOrClass: Function, idToTrigger?: number | string): void;
+    trigggerEntityPropertyChanges<ENTITY extends BaseEntity>(entityObjOrClass: new (...args: any[]) => ENTITY, property: keyof ENTITY | (keyof ENTITY)[], idToTrigger?: number | string): void;
+    triggerCustomEvent(customEvent: string, dataToPush: any): void;
+    trigggerEntityTableChanges(entityClass: Function): void;
+}