taon 18.0.17 → 18.0.19

package/websql/lib/base-classes/base-context.d.ts

@@ -12,6 +12,13 @@ declare const BaseContext: {
     readonly __refSync: import("../endpoint-context").EndpointContext;
     getClassInstance<T>(ctor: new (...args: any[]) => T): T;
     getClass<T>(ctor: new (...args: any[]) => T): new (...args: any[]) => T;
-    initialize: () => Promise<import("../endpoint-context").EndpointContext>;
+    initialize: (overrideOptions?: {
+        overrideHost?: string;
+        overrideRemoteHost?: string;
+    }) => Promise<import("../endpoint-context").EndpointContext>;
+    readonly realtime: {
+        readonly client: import("../realtime/realtime-client").RealtimeClient;
+        readonly server: import("../realtime/realtime-server").RealtimeServer;
+    };
 };
 export { BaseContext };

package/websql/lib/base-classes/base-injector.d.ts

@@ -17,9 +17,14 @@ export declare class BaseInjector<CloneT extends BaseClass = any> {
      */
     _(): Promise<void>;
     /**
+     * @deprecated use ctx instead
      * Current endpoint context
      */
     get __endpoint_context__(): EndpointContext;
+    /**
+     * get  current endpoint context
+     */
+    get ctx(): EndpointContext;
     /**
      * inject crud repo for entity
      */

package/websql/lib/base-classes/base.d.ts

@@ -6,7 +6,6 @@ import * as abstractEntity from './base-abstract-entity';
 import * as repository from './base-repository';
 import * as provider from './base-provider';
 import * as baseclass from './base-class';
-import * as baseSubscriber from './base-subscriber';
 import * as baseSubscriberEntity from './base-subscriber-for-entity';
 export declare namespace Base {
     export import Controller = controller.BaseController;
@@ -16,7 +15,6 @@ export declare namespace Base {
     export import Provider = provider.BaseProvider;
     export import Class = baseclass.BaseClass;
     export import Repository = repository.BaseRepository;
-    export import Subscriber = baseSubscriber.BaseSubscriber;
     export import SubscriberForEntity = baseSubscriberEntity.BaseSubscriberForEntity;
     const Context: {
         types: {
@@ -31,6 +29,13 @@ export declare namespace Base {
         readonly __refSync: import("../endpoint-context").EndpointContext;
         getClassInstance<T>(ctor: new (...args: any[]) => T): T;
         getClass<T>(ctor: new (...args: any[]) => T): new (...args: any[]) => T;
-        initialize: () => Promise<import("../endpoint-context").EndpointContext>;
+        initialize: (overrideOptions?: {
+            overrideHost?: string;
+            overrideRemoteHost?: string;
+        }) => Promise<import("../endpoint-context").EndpointContext>;
+        readonly realtime: {
+            readonly client: import("../realtime/realtime-client").RealtimeClient;
+            readonly server: import("../realtime/realtime-server").RealtimeServer;
+        };
     };
 }

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

@@ -11,9 +11,14 @@ export declare const createContext: <CTX extends Record<string, object>, CTRL ex
     readonly contexts: CTX;
     readonly contextName: string;
     /**
+     * @deprecated
      * - get reference to internal context
      */
     __ref(): Promise<EndpointContext>;
+    /**
+    * only for internal use
+    * @deprecated
+    */
     readonly __refSync: EndpointContext;
     getClassInstance<T>(ctor: new (...args: any[]) => T): T;
     getClass<T>(ctor: new (...args: any[]) => T): new (...args: any[]) => T;
@@ -21,5 +26,16 @@ export declare const createContext: <CTX extends Record<string, object>, CTRL ex
      * - create controller instances for context
      * - init database (if enable) + migation scripts
      */
-    initialize: () => Promise<EndpointContext>;
+    initialize: (overrideOptions?: {
+        overrideHost?: string;
+        overrideRemoteHost?: string;
+    }) => Promise<EndpointContext>;
+    /**
+     * realtime communication with server
+     * Udp socket.io (or ipc) based.
+     */
+    readonly realtime: {
+        readonly client: import("./realtime/realtime-client").RealtimeClient;
+        readonly server: import("./realtime/realtime-server").RealtimeServer;
+    };
 };

package/websql/lib/decorators/classes/subscriber-decorator.d.ts

@@ -1,6 +1,6 @@
 // @ts-nocheck
 import { Models } from '../../models';
+export declare function TaonSubscriber(options: TaonSubscriberOptions): any;
 export declare class TaonSubscriberOptions<T = any> extends Models.DecoratorAbstractOpt {
     allowedEvents?: (keyof T)[];
-}
-export declare function TaonSubscriber(options: TaonSubscriberOptions): any;
+}

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

@@ -1,6 +1,7 @@
 // @ts-nocheck
 import * as methods from './http-methods-decorators';
 import * as params from './http-params-decorators';
+import { Models } from 'ng2-rest/websql';
 export declare namespace Http {
     export import GET = methods.GET;
     export import POST = methods.POST;
@@ -8,6 +9,7 @@ export declare namespace Http {
     export import DELETE = methods.DELETE;
     export import PATCH = methods.PATCH;
     export import HEAD = methods.HEAD;
+    export import Response = Models.HttpResponse;
     namespace Param {
         export import Query = params.Query;
         export import Path = params.Path;

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

@@ -10,7 +10,6 @@ export declare class EndpointContext {
     private configFn;
     private static ngZone;
     static initNgZone(ngZone: NgZone): void;
-    static findForTraget(classFnOrObject: any): EndpointContext;
     disabledRealtime: boolean;
     /**
      * check whether context is inited
@@ -53,6 +52,8 @@ export declare class EndpointContext {
     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;
+        overrideHost?: string;
+        overrideRemoteHost?: string;
     }): Promise<void>;
     private getAutoGeneratedConfig;
     get ngZone(): any;
@@ -108,7 +109,7 @@ export declare class EndpointContext {
     initMetadata(): void;
     writeActiveRoutes(): void;
     get middlewares(): Models.MiddlewareType[];
-    private initMidleware;
+    private initMiddlewares;
     private initServer;
     /**
      * client can be browser or nodejs (when remote host)

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

@@ -8,7 +8,7 @@ export declare namespace ClassHelpers {
     const getName: (classFnOrObject: any) => string;
     const getOrginalClass: (classFnOrObject: any) => any;
     const getFullInternalName: (classFnOrObject: any) => string;
-    const getUniquKey: (classFnOrObject: any) => string;
+    const getUniqueKey: (classFnOrObject: any) => string;
     const isContextClassObject: (obj: any) => boolean;
     const setName: (target: Function, className: string) => void;
     const hasParentClassWithName: (target: Function, className: string, targets?: any[]) => boolean;

package/websql/lib/index.d.ts

@@ -12,10 +12,10 @@ import * as models from './models';
 import * as endpointContext from './endpoint-context';
 import * as allSymbols from './symbols';
 import { NgZone } from '@angular/core';
+export * from './ui';
 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';
@@ -37,21 +37,9 @@ export declare namespace Taon {
     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: {
@@ -66,7 +54,14 @@ export declare namespace Taon {
         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>;
+        initialize: (overrideOptions?: {
+            overrideHost?: string;
+            overrideRemoteHost?: string;
+        }) => Promise<endpointContext.EndpointContext>;
+        readonly realtime: {
+            readonly client: import("./realtime/realtime-client").RealtimeClient;
+            readonly server: import("./realtime/realtime-server").RealtimeServer;
+        };
     };
     const inject: <T>(entity: () => new (...args: any[]) => T) => T;
     const initNgZone: (ngZone: NgZone) => void;
@@ -100,7 +95,14 @@ export declare namespace Taon {
                 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>;
+                initialize: (overrideOptions?: {
+                    overrideHost?: string;
+                    overrideRemoteHost?: string;
+                }) => Promise<endpointContext.EndpointContext>;
+                readonly realtime: {
+                    readonly client: import("./realtime/realtime-client").RealtimeClient;
+                    readonly server: import("./realtime/realtime-server").RealtimeServer;
+                };
             };
         };
         readonly contextName: string;
@@ -108,6 +110,13 @@ export declare namespace Taon {
         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>;
+        initialize: (overrideOptions?: {
+            overrideHost?: string;
+            overrideRemoteHost?: string;
+        }) => Promise<endpointContext.EndpointContext>;
+        readonly realtime: {
+            readonly client: import("./realtime/realtime-client").RealtimeClient;
+            readonly server: import("./realtime/realtime-server").RealtimeServer;
+        };
     }>;
 }

package/websql/lib/inject.d.ts

@@ -1,9 +1,2 @@
 // @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>>;
+export declare const inject: <T>(entity: () => new (...args: any[]) => T) => T;

package/websql/lib/models.d.ts

@@ -4,7 +4,7 @@ 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)';
+    type FrameworkMode = 'backend-frontend(tcp+udp)' | 'remote-backend(tcp+udp)' | 'backend-frontend(ipc-electron)' | 'backend-frontend(websql-electron)' | 'backend-frontend(websql)';
     enum ClassType {
         ENTITY = "ENTITY",
         CONTROLLER = "CONTROLLER",
@@ -48,20 +48,28 @@ export declare namespace Models {
         resave?: boolean;
     };
     type ContectionOptionsLogs = {
-        http: boolean;
-        realtime: boolean;
-        framework: boolean;
-        db: boolean;
+        http?: boolean;
+        realtime?: boolean;
+        framework?: boolean;
+        db?: boolean;
     };
     interface ContextOptions<CONTEXTS, CONTROLLERS, ENTITIES, REPOSITORIES, PROVIDERS, SUBSCRIBERS> {
         contextName: string;
+        /**
+         * host/port for initing backend server
+         */
         host?: string;
         /**
-       * frontend host only needed when we are using
-       * withCredentials for axios
-       * and session cookie
-       */
+         * frontend host only needed when we are
+         * using withCredentials for axios
+         * and session cookie
+         * or realtime communication
+         */
         frontendHost?: string;
+        /**
+         * backend way of communication
+         * between taon backends/processes
+         */
         remoteHost?: string;
         useIpcWhenElectron?: boolean;
         contexts?: CONTEXTS;

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

@@ -5,7 +5,7 @@ import { RealtimeModels } from './realtime.models';
 import type { BaseEntity } from '../base-classes/base-entity';
 export declare class RealtimeClient {
     private core;
-    private subsmanagers;
+    private subsManagers;
     constructor(core: RealtimeCore);
     private init;
     /**
@@ -28,5 +28,11 @@ export declare class RealtimeClient {
      */
     listenChangesEntityObj<T extends BaseEntity>(entity: T, options?: RealtimeModels.ChangeOption): Observable<unknown>;
     listenChangesCustomEvent(customEvent: string): Observable<unknown>;
-    private getRoomIdFrom;
+    /**
+     * Trigger custom event on backend
+     * @param customEvent global event name
+     * @param dataToPush
+     */
+    triggerCustomEvent(customEvent: string, dataToPush?: any): void;
+    private getUniqueIdentifierForConnection;
 }

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

@@ -20,21 +20,21 @@ export declare class RealtimeCore {
     readonly server: RealtimeServer;
     readonly strategy: RealtimeStrategy;
     /**
-     * global FE socket
+     * global FE socket - only for established connection
      */
-    FE: SocketClient<DefaultEventsMap, DefaultEventsMap>;
+    conectSocketFE: SocketClient<DefaultEventsMap, DefaultEventsMap>;
     /**
      * socket for namespaces and rooms
      */
-    FE_REALTIME: SocketClient<DefaultEventsMap, DefaultEventsMap>;
+    socketFE: SocketClient<DefaultEventsMap, DefaultEventsMap>;
     /**
-     * global BE socket
+     * global BE socket - only for established connection
      */
-    BE: Server<DefaultEventsMap, DefaultEventsMap, DefaultEventsMap, any>;
+    connectSocketBE: Server<DefaultEventsMap, DefaultEventsMap, DefaultEventsMap, any>;
     /**
      * socket for namespaces and rooms
      */
-    BE_REALTIME: Server<DefaultEventsMap, DefaultEventsMap, DefaultEventsMap, any>;
+    socketBE: Server<DefaultEventsMap, DefaultEventsMap, DefaultEventsMap, any>;
     constructor(ctx: EndpointContext);
     private resolveStrategy;
     pathFor(namespace?: string): URL;

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

@@ -1,14 +1,19 @@
 // @ts-nocheck
 import { RealtimeCore } from './realtime-core';
 import type { BaseEntity } from '../base-classes/base-entity';
+import { Observable } from 'rxjs';
 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;
+    triggerEntityChanges(entityObjOrClass: Function, idToTrigger?: number | string): void;
+    triggerEntityPropertyChanges<ENTITY extends BaseEntity>(entityObjOrClass: new (...args: any[]) => ENTITY, property: keyof ENTITY | (keyof ENTITY)[], idToTrigger?: number | string): void;
+    triggerEntityTableChanges(entityClassOrInstance: Function | object): void;
     triggerCustomEvent(customEvent: string, dataToPush: any): void;
-    trigggerEntityTableChanges(entityClass: Function): void;
+    /**
+     * Listen to custom events from users
+     * @param customEvent  global event name
+     */
+    listenChangesCustomEvent(customEvent: string): Observable<any>;
 }

package/websql/lib/realtime/realtime-strategy/realtime-strategy-ipc.d.ts

@@ -1,8 +1,73 @@
 // @ts-nocheck
-import { Server } from 'socket.io';
+import { ServerOptions } from 'socket.io';
 import { EndpointContext } from '../../endpoint-context';
 import { RealtimeStrategy } from './realtime-strategy';
-import type { io } from 'socket.io-client';
+import type { ipcRenderer } from 'electron';
+import { RealtimeModels } from '../realtime.models';
+export declare class MockServerIpc {
+    contextName: string;
+    static serverByContextName: Map<string, MockServerIpc>;
+    static from(contextName: string): MockServerIpc;
+    namespacesByName: Map<string, MockNamespaceIpc>;
+    constructor(contextName: string);
+    of(namespace: string): MockNamespaceIpc;
+}
+export declare class MockNamespaceIpc {
+    /**
+     * Namespace name
+     */
+    name: string;
+    server: MockServerIpc;
+    electronClients: Set<Electron.WebContents>;
+    roomsByRoomName: {
+        [roomName: string]: Set<Electron.WebContents>;
+    };
+    private namespaceEventHandlers;
+    constructor(
+    /**
+     * Namespace name
+     */
+    name: string, server: MockServerIpc);
+    on(eventName: string, callback: RealtimeModels.EventHandler): any;
+    off(event: string, callback?: RealtimeModels.EventHandler): any;
+    emit(eventName: string, ...args: any[]): any;
+    to(roomName: string): RoomEmitterIpc;
+    in(roomName: string): RoomEmitterIpc;
+    join(webContents: Electron.WebContents, roomName: string): void;
+    leave(webContents: Electron.WebContents, roomName: string): void;
+    path(): string;
+    get nsp(): {
+        readonly name: string;
+    };
+}
+declare class RoomEmitterIpc {
+    private electronClients;
+    /**
+     * namespace name
+     */
+    private name;
+    private includeSender;
+    private sender;
+    constructor(electronClients: Set<Electron.WebContents>, 
+    /**
+     * namespace name
+     */
+    name: string, includeSender?: boolean, sender?: MockSocketIpc);
+    emit(eventName: string, ...args: any[]): void;
+}
+export declare class MockSocketIpc {
+    namespaceName: string;
+    ipcRenderer: typeof ipcRenderer;
+    private socketEventHandlers;
+    get name(): string;
+    /**
+     * @param namespaceName instead url for ipc
+     */
+    constructor(namespaceName: string);
+    on(eventName: string, callback: (event: any, ...args: any[]) => void): void;
+    off(event: string, callback?: (event: any, ...args: any[]) => void): void;
+    emit(event: string, ...args: any[]): void;
+}
 /**
  * Purpose:
  * - backend-browser communication between 2 processes in electron mode
@@ -10,14 +75,8 @@ import type { io } from 'socket.io-client';
 export declare class RealtimeStrategyIpc extends RealtimeStrategy {
     protected ctx: EndpointContext;
     toString(): string;
-    establishConnection(): void;
     constructor(ctx: EndpointContext);
-    contextsServers: {
-        [contextName: string]: Server;
-    };
-    contextsIO: {
-        [contextName: string]: typeof io;
-    };
-    get io(): any;
-    get Server(): any;
-}
+    ioServer(__: string, opt: ServerOptions): any;
+    get ioClient(): any;
+}
+export {};

package/websql/lib/realtime/realtime-strategy/realtime-strategy-mock.d.ts

@@ -1,6 +1,7 @@
 // @ts-nocheck
-import { EndpointContext } from '../../endpoint-context';
+import type { EndpointContext } from '../../endpoint-context';
 import { RealtimeStrategy } from './realtime-strategy';
+import { ServerOptions } from 'socket.io';
 /**
  * Purpose:
  * - browser-browser communication mock (in websql mode)
@@ -9,7 +10,6 @@ export declare class RealtimeStrategyMock extends RealtimeStrategy {
     protected ctx: EndpointContext;
     toString(): string;
     constructor(ctx: EndpointContext);
-    get Server(): any;
-    get io(): any;
-    establishConnection(): void;
+    ioServer(url: string, opt: ServerOptions): any;
+    get ioClient(): any;
 }

package/websql/lib/realtime/realtime-strategy/realtime-strategy-socket-io.d.ts

@@ -11,7 +11,6 @@ export declare class RealtimeStrategySocketIO extends RealtimeStrategy {
     protected ctx: EndpointContext;
     toString(): string;
     constructor(ctx: EndpointContext);
-    get Server(): any;
-    get io(): typeof io;
-    establishConnection(): void;
+    ioServer(...args: any[]): any;
+    get ioClient(): typeof io;
 }

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

@@ -1,13 +1,12 @@
 // @ts-nocheck
 import { EndpointContext } from '../../endpoint-context';
-import type { Server } from 'socket.io';
+import type { Server, ServerOptions } from 'socket.io';
 import type { io } from 'socket.io-client';
+import { DefaultEventsMap } from 'socket.io/dist/typed-events';
 export declare abstract class RealtimeStrategy {
     protected ctx: EndpointContext;
     constructor(ctx: EndpointContext);
-    private testTypes;
-    abstract establishConnection(): void;
-    abstract readonly io: typeof io;
-    abstract readonly Server: typeof Server;
+    get ioClient(): typeof io;
+    ioServer(url: string, opt: ServerOptions): Server<DefaultEventsMap, DefaultEventsMap, DefaultEventsMap, any>;
     abstract toString(): string;
 }

package/websql/lib/realtime/realtime.models.d.ts

@@ -11,4 +11,5 @@ export declare namespace RealtimeModels {
         property?: string;
         customEvent?: string;
     };
+    type EventHandler = (...args: any[]) => void;
 }

package/websql/lib/symbols.d.ts

@@ -1,41 +1,34 @@
 // @ts-nocheck
 export declare namespace Symbols {
-    const ctxInClassOrClassObj: unique symbol;
-    const classNameStaticProperty: string;
-    const fullClassNameStaticProperty: string;
-    const orignalClass: string;
-    const orignalClassClonesObj: string;
-    const classMethodsNames: string;
-    const REALTIME: {
-        NAMESPACE: (contextName: string) => string;
+    export const ctxInClassOrClassObj: unique symbol;
+    export const classNameStaticProperty: string;
+    export const fullClassNameStaticProperty: string;
+    export const orignalClass: string;
+    export const orignalClassClonesObj: string;
+    export const classMethodsNames: string;
+    /**
+     * for backendSocket.in(ROOM_NAME).emit(EVENT)
+     *
+     * Room names are uniqe..
+     * here I am limiting number of event for clients.
+     */
+    class Realtime {
+        NAMESPACE(contextName: string): string;
         TABLE_CHANGE(contextName: string, tableName: string): string;
-        /**
-         * for backendSocket.in(ROOM_NAME).emit(EVENT)
-         *
-         * Room names are uniqe..
-         * here I am limiting number of event for clients.
-         */
-        ROOM_NAME: {
-            CUSTOM(contextName: string, customEvent: string): string;
-            /**
-             * @LAST TODO
-             */
-            SUBSCRIBER_EVENT(contextName: string, className: string, propertyName: string): string;
-            UPDATE_ENTITY(contextName: string, className: string, entityId: number | string): string;
-            UPDATE_ENTITY_PROPERTY(contextName: string, className: string, property: string, entityId: number | string): string;
-            SUBSCRIBE: {
-                CUSTOM: (contextName: string) => string;
-                ENTITY_UPDATE_EVENTS: (contextName: string) => string;
-                ENTITY_PROPERTY_UPDATE_EVENTS: (contextName: string) => string;
-            };
-            UNSUBSCRIBE: {
-                CUSTOM: (contextName: string) => string;
-                ENTITY_UPDATE_EVENTS: (contextName: string) => string;
-                ENTITY_PROPERTY_UPDATE_EVENTS: (contextName: string) => string;
-            };
-        };
-    };
-    const metadata: {
+        readonly KEYroomSubscribe = "roomSubscribe";
+        readonly KEYroomUnsubscribe = "roomUnsubscribe";
+        ROOM_NAME_CUSTOM(contextName: string, customEvent: string): string;
+        ROOM_SUBSCRIBE_CUSTOM(contextName: string): string;
+        ROOM_UNSUBSCRIBE_CUSTOM(contextName: string): string;
+        ROOM_NAME_UPDATE_ENTITY(contextName: string, className: string, entityId: number | string): string;
+        ROOM_SUBSCRIBE_ENTITY_UPDATE_EVENTS(contextName: string): string;
+        ROOM_UNSUBSCRIBE_ENTITY_UPDATE_EVENTS(contextName: string): string;
+        ROOM_NAME_UPDATE_ENTITY_PROPERTY(contextName: string, className: string, property: string, entityId: number | string): string;
+        ROOM_SUBSCRIBE_ENTITY_PROPERTY_UPDATE_EVENTS(contextName: string): string;
+        ROOM_UNSUBSCRIBE_ENTITY_PROPERTY_UPDATE_EVENTS(contextName: string): string;
+    }
+    export const REALTIME: Realtime;
+    export const metadata: {
         className: string;
         options: {
             runtimeController: string;
@@ -47,7 +40,7 @@ export declare namespace Symbols {
             subscriber: string;
         };
     };
-    const old: {
+    export const old: {
         HAS_TABLE_IN_DB: symbol;
         MDC_KEY: string;
         WEBSQL_REST_PROGRESS_FUN: symbol;
@@ -70,4 +63,5 @@ export declare namespace Symbols {
             CLASS_NAME_MATCH: string;
         };
     };
+    export {};
 }

package/websql/lib/ui/directives/index.d.ts

@@ -0,0 +1,4 @@
+// @ts-nocheck
+export * from './taon-long-press.directive';
+export * from './taon-inject-html.directive';
+export * from './safe.pipe';

package/websql/lib/ui/directives/safe.pipe.d.ts

@@ -0,0 +1,11 @@
+// @ts-nocheck
+import { PipeTransform } from '@angular/core';
+import { DomSanitizer, SafeHtml, SafeStyle, SafeScript, SafeUrl, SafeResourceUrl } from '@angular/platform-browser';
+import * as i0 from "@angular/core";
+export declare class SafePipe implements PipeTransform {
+    protected sanitizer: DomSanitizer;
+    constructor(sanitizer: DomSanitizer);
+    transform(value: any, type: string): SafeHtml | SafeStyle | SafeScript | SafeUrl | SafeResourceUrl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SafePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SafePipe, "safe", true>;
+}

package/websql/lib/ui/directives/taon-inject-html.directive.d.ts

@@ -0,0 +1,10 @@
+// @ts-nocheck
+import { ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class TaonInjectHTMLDirective {
+    private host;
+    set taonInjectHTML(content: string);
+    constructor(host: ElementRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonInjectHTMLDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TaonInjectHTMLDirective, "[taonInjectHTML]", never, { "taonInjectHTML": { "alias": "taonInjectHTML"; "required": false; }; }, {}, never, never, true, never>;
+}