taon 21.0.18 → 21.0.29

package/browser-prod/types/taon-browser.d.ts

@@ -0,0 +1,2178 @@
+// @ts-nocheck
+import * as taon_browser from 'taon/browser';
+import * as express from 'express';
+import express__default, { Request, Response, Application } from 'express';
+import { Models as Models$1, RestResponseWrapper, TaonServerMiddlewareInterceptOptions, TaonClientMiddlewareInterceptOptions, HttpResponseError, RestErrorResponseWrapper, Mapping } from 'ng2-rest/browser-prod';
+export { TaonClientMiddlewareInterceptOptions, TaonServerMiddlewareInterceptOptions } from 'ng2-rest/browser-prod';
+import { Server } from 'http';
+import { DataSource, Repository, SaveOptions, DeepPartial, QueryDeepPartialEntity, InsertResult, UpsertOptions, FindOptionsWhere, UpdateResult, FindManyOptions, FindOneOptions, QueryRunner, SelectQueryBuilder, Table, RelationPath, MigrationInterface, EntitySubscriberInterface, InsertEvent, UpdateEvent, RemoveEvent, SoftRemoveEvent, RecoverEvent, TransactionStartEvent, TransactionCommitEvent, TransactionRollbackEvent } from 'taon-typeorm/browser-prod';
+export { AfterInsert, AfterLoad, AfterRecover, AfterRemove, AfterSoftRemove, AfterUpdate, BeforeInsert, BeforeRecover, BeforeRemove, BeforeSoftRemove, BeforeUpdate, Column, Connection, CreateDateColumn, Column as CustomColumn, DeleteDateColumn, Generated, Generated as GeneratedColumn, Index, JoinColumn, JoinTable, ManyToMany, ManyToOne, OneToMany, OneToOne, PrimaryColumn, PrimaryGeneratedColumn, Repository, TreeChildren, TreeParent, UpdateDateColumn, VersionColumn, VirtualColumn } from 'taon-typeorm/browser-prod';
+import { MySqlQuerySource } from 'taon-type-sql/browser-prod';
+import { CoreModels } from 'tnp-core/browser-prod';
+import * as i0 from '@angular/core';
+import { InjectionToken, ViewContainerRef } from '@angular/core';
+import { AxiosResponse } from 'axios';
+import * as rxjs from 'rxjs';
+import { Observable, Subscriber } from 'rxjs';
+import * as multer from 'multer';
+import * as _ngx_formly_core from '@ngx-formly/core';
+import { FieldWrapper, FieldArrayType, FormlyFormBuilder, FormlyFieldConfig } from '@ngx-formly/core';
+import { ServerOptions, Server as Server$1, DefaultEventsMap } from 'socket.io';
+import { io, Socket } from 'socket.io-client';
+import * as Electron from 'electron';
+import { ipcRenderer } from 'electron';
+
+declare abstract class TaonBaseCustomRepository extends TaonBaseInjector {
+}
+
+declare abstract class TaonBaseRepository<Entity extends {
+    id?: any;
+}> extends TaonBaseCustomRepository {
+    private REPOS_CACHE_KEY;
+    abstract entityClassResolveFn: () => any;
+    constructor(__entityClassResolveFn: () => any);
+    private __dbQuery;
+    get dbQuery(): MySqlQuerySource;
+    get connection(): DataSource;
+    protected get repository(): Repository<Entity>;
+    /**
+     * target for repository
+     */
+    get target(): Function;
+    /**
+     * alias to repository
+     */
+    protected get repo(): Repository<Entity>;
+    get repositoryExists(): boolean;
+    /**
+     * Checks if entity has an id.
+     * If entity composite compose ids, it will check them all.
+     */
+    hasId(entity: Entity): boolean;
+    /**
+     * Gets entity mixed id.
+     */
+    getId(entity: Entity): any;
+    /**
+      Saves a given entity in the database.
+     * If entity does not exist in the database then inserts, otherwise updates.
+     */
+    save(item: Entity, options?: SaveOptions & {
+        reload: false;
+    }): Promise<Entity>;
+    /**
+     * alias to save
+     * -> it will actuall create new entity in db
+     * in oposite to typeorm create method
+     */
+    /**
+     * Creates a new entity instance.
+     */
+    create(): Entity;
+    /**
+     * Creates new entities and copies all entity properties from given objects into their new entities.
+     * Note that it copies only properties that are present in entity schema.
+     */
+    create(entityLikeArray: DeepPartial<Entity>[]): Entity[];
+    /**
+     * Creates a new entity instance and copies all entity properties from this object into a new entity.
+     * Note that it copies only properties that are present in entity schema.
+     */
+    create(entityLike: DeepPartial<Entity>): Entity;
+    bulkSave(items: Entity[], options?: SaveOptions & {
+        reload: false;
+    }): Promise<Entity[]>;
+    /**
+     * @deprecated use bulkSave instead
+     */
+    bulkCreate(items: Entity[], options?: SaveOptions & {
+        reload: false;
+    }): Promise<Entity[]>;
+    /**
+     * Saves all given entities in the database.
+     * If entities do not exist in the database then inserts, otherwise updates.
+     */
+    /**
+     * Merges multiple entities (or entity-like objects) into a given entity.
+     */
+    merge(mergeIntoEntity: Entity, ...entityLikes: Entity[]): Entity;
+    /**
+     * Creates a new entity from the given plain javascript object. If entity already exist in the database, then
+     * it loads it (and everything related to it), replaces all values with the new ones from the given object
+     * and returns this new entity. This new entity is actually a loaded from the db entity with all properties
+     * replaced from the new object.
+     *
+     * Note that given entity-like object must have an entity id / primary key to find entity by.
+     * Returns undefined if entity with given id was not found.
+     */
+    preload(entityLike: Entity): Promise<Entity | undefined>;
+    /**
+     * Removes a given entities from the database.
+     */
+    remove(idOrEntity: number | string | Entity): Promise<Entity>;
+    /**
+     * alias to remove
+     */
+    delete(idOrEntity: number | string | Partial<Entity>): Promise<Entity>;
+    /**
+     * alias to removeById
+     */
+    deleteById(id: number | string): Promise<Entity>;
+    bulkRemove(idsOrEntities: (number | string | Entity)[]): Promise<Entity[]>;
+    bulkDelete(ids: (number | string | Entity)[]): Promise<Entity[]>;
+    /**
+     * Records the delete date of all given entities.
+     */
+    softRemove<T extends Entity>(entities: T[], options: SaveOptions & {
+        reload: false;
+    }): Promise<T[]>;
+    /**
+     * Records the delete date of all given entities.
+     */
+    softRemove<T extends Entity>(entities: T[], options?: SaveOptions): Promise<(T & Entity)[]>;
+    /**
+     * Records the delete date of a given entity.
+     */
+    softRemove<T extends Entity>(entity: T, options: SaveOptions & {
+        reload: false;
+    }): Promise<T>;
+    /**
+     * Recovers all given entities in the database.
+     */
+    recover<T extends Entity>(entities: T[], options: SaveOptions & {
+        reload: false;
+    }): Promise<T[]>;
+    /**
+     * Recovers all given entities in the database.
+     */
+    recover<T extends Entity>(entities: T[], options?: SaveOptions): Promise<(T & Entity)[]>;
+    /**
+     * Recovers a given entity in the database.
+     */
+    recover<T extends Entity>(entity: T, options: SaveOptions & {
+        reload: false;
+    }): Promise<T>;
+    /**
+     * Inserts a given entity into the database.
+     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
+     * Executes fast and efficient INSERT query.
+     * Does not check if entity exist in the database, so query will fail if duplicate entity is being inserted.
+     */
+    insert(entity: QueryDeepPartialEntity<Entity> | QueryDeepPartialEntity<Entity>[]): Promise<InsertResult>;
+    update(item: Entity): Promise<any>;
+    private allowedTypesToUpdate;
+    updateById<ENTITY = Entity>(id: number | string, item: Entity): Promise<ENTITY>;
+    bulkUpdate(items: Entity[]): Promise<any>;
+    /**
+     * Inserts a given entity into the database, unless a unique constraint conflicts then updates the entity
+     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
+     * Executes fast and efficient INSERT ... ON CONFLICT DO UPDATE/ON DUPLICATE KEY UPDATE query.
+     */
+    upsert(entityOrEntities: QueryDeepPartialEntity<Entity> | QueryDeepPartialEntity<Entity>[], conflictPathsOrOptions: string[] | UpsertOptions<Entity>): Promise<InsertResult>;
+    /**
+     * Records the delete date of entities by a given criteria.
+     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
+     * Executes fast and efficient SOFT-DELETE query.
+     * Does not check if entity exist in the database.
+     */
+    softDelete(criteria: string | string[] | number | number[] | Date | Date[] | FindOptionsWhere<Entity>): Promise<UpdateResult>;
+    /**
+     * Restores entities by a given criteria.
+     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
+     * Executes fast and efficient SOFT-DELETE query.
+     * Does not check if entity exist in the database.
+     */
+    restore(criteria: string | string[] | number | number[] | Date | Date[] | FindOptionsWhere<Entity>): Promise<UpdateResult>;
+    /**
+     * Counts entities that match given options.
+     * Useful for pagination.
+     */
+    count(options?: FindManyOptions<Entity>): Promise<number>;
+    /**
+     * Counts entities that match given conditions.
+     * Useful for pagination.
+     */
+    countBy(where: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[]): Promise<number>;
+    /**
+     * Finds entities that match given find options.
+     */
+    find(options?: FindManyOptions<Entity>): Promise<Entity[]>;
+    /**
+     * Finds entities that match given find options.
+     */
+    findBy(where: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[]): Promise<Entity[]>;
+    /**
+     * Finds entities that match given find options.
+     * Also counts all entities that match given conditions,
+     * but ignores pagination settings (from and take options).
+     */
+    findAndCount(options?: FindManyOptions<Entity>): Promise<[Entity[], number]>;
+    /**
+     * Finds entities that match given WHERE conditions.
+     * Also counts all entities that match given conditions,
+     * but ignores pagination settings (from and take options).
+     */
+    findAndCountBy(where: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[]): Promise<[Entity[], number]>;
+    /**
+     * Finds entities with ids.
+     * Optionally find options or conditions can be applied.
+     *
+     * @deprecated use `findBy` method instead in conjunction with `In` operator, for example:
+     *
+     * .findBy({
+     *     id: In([1, 2, 3])
+     * })
+     */
+    findByIds(ids: any[]): Promise<Entity[]>;
+    /**
+     * Finds first entity by a given find options.
+     * If entity was not found in the database - returns null.
+     */
+    findOne(options: FindOneOptions<Entity>): Promise<Entity | null>;
+    /**
+     * Finds first entity that matches given where condition.
+     * If entity was not found in the database - returns null.
+     */
+    findOneBy(where: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[]): Promise<Entity | null>;
+    /**
+     * Finds first entity that matches given id.
+     * If entity was not found in the database - returns null.
+     *
+     * @deprecated use `findOneBy` method instead in conjunction with `In` operator, for example:
+     *
+     * .findOneBy({
+     *     id: 1 // where "id" is your primary column name
+     * })
+     */
+    findOneById(id: number | string | Date): Promise<Entity | null>;
+    /**
+     * Finds first entity by a given find options.
+     * If entity was not found in the database - rejects with error.
+     */
+    findOneOrFail(options: FindOneOptions<Entity>): Promise<Entity>;
+    /**
+     * Finds first entity that matches given where condition.
+     * If entity was not found in the database - rejects with error.
+     */
+    findOneByOrFail(where: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[]): Promise<Entity>;
+    /**
+     * Executes a raw SQL query and returns a raw database results.
+     * Raw query execution is supported only by relational databases (MongoDB is not supported).
+     */
+    query(query: string, parameters?: any[]): Promise<any>;
+    /**
+     * Executes a raw SQL query and returns a raw database results.
+     * Raw query execution is supported only by relational databases (MongoDB is not supported).
+     */
+    createQueryBuilder(alias?: string, queryRunner?: QueryRunner): SelectQueryBuilder<Entity>;
+    /**
+     * Clears all the data from the given table/collection (truncates/drops it).
+     *
+     * Note: this method uses TRUNCATE and may not work as you expect in transactions on some platforms.
+     * @see https://stackoverflow.com/a/5972738/925151
+     */
+    clear(): Promise<void>;
+    /**
+     * Increments some column by provided value of the entities matched given conditions.
+     */
+    increment(conditions: FindOptionsWhere<Entity>, propertyPath: string, value: number | string): Promise<UpdateResult>;
+    /**
+     * Decrements some column by provided value of the entities matched given conditions.
+     */
+    decrement(conditions: FindOptionsWhere<Entity>, propertyPath: string, value: number | string): Promise<UpdateResult>;
+    /**
+     * @deprecated use findAndCount instead
+     */
+    getAll(): Promise<any>;
+    getBy(id: number | string): Promise<Entity>;
+}
+
+declare class TaonBaseInjector {
+    /**
+     * for proxy purposes
+     */
+    getOriginalPrototype: () => any;
+    /**
+     * for proxy purposes
+     */
+    getOriginalConstructor: () => any;
+    /**
+     * class initialization hook
+     * taon after class instace creation
+     */
+    _(): 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
+     */
+    injectRepo<T>(entityForCrud: new (...args: any[]) => T): TaonBaseRepository<T>;
+    injectCustomRepository<T extends TaonBaseCustomRepository>(cutomRepositoryClass: new (...args: any[]) => T): T;
+    /**
+     * aliast to this.injectRepository()
+     */
+    injectCustomRepo<T extends TaonBaseCustomRepository>(cutomRepositoryClass: new (...args: any[]) => T): T;
+    /**
+     * example usage:
+     * ...
+     * exampleController = this.injectController(ExampleController);
+     * ...
+     */
+    injectController<T>(ctor: new (...args: any[]) => T): T;
+    /**
+     * example usage:
+     * ...
+     * exampleSubscriber = this.injectSubscriber(ExampleSubscriber)
+     * ...
+     */
+    injectSubscriber<T>(ctor: new (...args: any[]) => T): T;
+    /**
+     * aliast to .injectController()
+     */
+    injectCtrl<T>(ctor: new (...args: any[]) => T): T;
+    /**
+     * inject middleware for context
+     */
+    injectMiddleware<T>(ctor: new (...args: any[]) => T): T;
+    /**
+     * inject provider for context
+     */
+    injectProvider<T>(ctor: new (...args: any[]) => T): T;
+    /**
+     * Inject: Controllers, Providers, Repositories, Services, etc.
+     * TODO  addd nest js injecting
+     */
+    private __inject;
+}
+
+type MigrationStatus = 'completed' | 'pending';
+declare class ContextDbMigrations {
+    private ctx;
+    readonly DEFAULT_MIGRATION_TABLE_NAME = "TAON_MIGRATION_META";
+    readonly MIGRATION_STATUS_COMPLETED: MigrationStatus;
+    readonly MIGRATION_STATUS_PENDING: MigrationStatus;
+    readonly table: Table;
+    constructor(ctx: EndpointContext);
+    ensureMigrationTableExists(): Promise<void>;
+    private logSelectALl;
+    revertMigrationToTimestamp(timestamp: number): Promise<any>;
+    clearMigrationTable(): Promise<any>;
+    markAllMigrationsAsApplied(): Promise<any>;
+    runAllNotCompletedMigrations(): Promise<any>;
+}
+
+declare class ContextsEndpointStorage {
+    SPECIAL_APP_READY_MESSAGE: string;
+    private taonEndpointContexts;
+    private static instance;
+    private constructor();
+    static get Instance(): ContextsEndpointStorage;
+    set(context: EndpointContext): void;
+    get arr(): EndpointContext[];
+    getBy(context: Partial<EndpointContext> | string): EndpointContext | undefined;
+}
+
+declare class TaonRestResponseWrapper extends RestResponseWrapper {
+}
+declare const BaseTaonClassesNames: readonly ["BaseCrudController", "BaseController", "BaseAbstractEntity", "BaseEntity", "BaseContext", "BaseCustomRepository", "BaseFileUploadMiddleware", "BaseMiddleware", "BaseClass", "BaseInjector", "BaseMigration", "BaseProvider", "BaseRepository", "BaseSubscriberForEntity", "BaseCliWorkerController", "PortsController", "PortsContext"];
+declare const TaonTempDatabasesFolder = "databases";
+declare const TaonTempRoutesFolder = "routes";
+declare namespace Models {
+    const DatabasesFolder = "databases";
+    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",
+        REPOSITORY = "REPOSITORY",
+        PROVIDER = "PROVIDER",
+        SUBSCRIBER = "SUBSCRIBER",
+        MIGRATION = "MIGRATION",
+        MIDDLEWARE = "MIDDLEWARE"
+    }
+    const ClassTypeKey: { [key in ClassType]: keyof ContextOptions<any, any, any, any, any, any, any, any>; };
+    type MiddlewareType = [Function, any[]];
+    /**
+     * DROP_DB+MIGRATIONS (default for development)
+     * Drop all tables + recreate them + run migrations
+     * synchronize: true , dropSchema: true
+     * use migrations: true
+     *
+     * MIGRATIONS (default for production)
+     * Do not drop tables, only run migrations
+     * synchronize: false, dropSchema: false
+     * use migrations: true
+     */
+    type DBRecreateMode = 'DROP_DB+MIGRATIONS' | 'PRESERVE_DATA+MIGRATIONS';
+    class DatabaseConfigTypeOrm {
+        /**
+         * database name
+         */
+        database?: string;
+        /**
+         * only for file base db: sqlite, sqljs
+         */
+        location?: string;
+        synchronize: boolean;
+        dropSchema: boolean;
+        type?: CoreModels.DatabaseType;
+        /**
+         * Persists db on disk/local-storage if serverless db
+         */
+        autoSave?: boolean;
+        /**
+         * for websql db mode
+         * true by default
+         */
+        useLocalForage?: boolean;
+        logging: boolean;
+        databasePort?: number;
+        databaseHost?: string;
+        databaseUsername?: string;
+        databasePassword?: string;
+    }
+    class DatabaseConfig extends DatabaseConfigTypeOrm {
+        /**
+         * Default value 'DROP_ALL'.
+         *
+         * Tell framework what is happening with db
+         * when context is starting.
+         */
+        recreateMode?: DBRecreateMode;
+        static from(databasePartialConfig: Partial<Omit<DatabaseConfig, 'synchronize' | 'dropSchema' | 'databaseConfigTypeORM'>>): DatabaseConfig;
+        get databaseConfigTypeORM(): DatabaseConfigTypeOrm;
+    }
+    type ISession = {
+        secret?: string;
+        saveUninitialized?: boolean;
+        /**
+         * max age of session
+         */
+        cookieMaxAge?: number;
+        secure?: boolean;
+        resave?: boolean;
+    };
+    type ConnectionOptionsLogs = {
+        http?: boolean;
+        realtime?: boolean;
+        framework?: boolean;
+        db?: boolean;
+        migrations?: boolean;
+        routes?: boolean;
+    };
+    interface ContextOptions<CONTEXTS, CONTROLLERS, ENTITIES, REPOSITORIES, PROVIDERS, SUBSCRIBERS, MIGRATIONS, MIDDLEWARES> {
+        appId?: string;
+        contextName: string;
+        /**
+         * if defined and different from contextName
+         * - context will NOT be initialized
+         */
+        activeContext?: string | null;
+        /**
+         * IMPORTANT! provide full url that starts with http:// or https://
+         * host/port for initing backend server
+         */
+        host?: string;
+        /**
+         * Needs to be specified in docker environment only
+         */
+        hostPortNumber?: number;
+        /**
+         * IMPORTANT! provide full url that starts with http:// or https://
+         * frontend host only needed when we are
+         * using withCredentials for axios
+         * and session cookie
+         * or realtime communication
+         */
+        frontendHost?: string;
+        /**
+         * Needs to be specified in docker environment only
+         */
+        frontendHostPortNumber?: number;
+        /**
+         * User ipc for communication between BE/FE
+         * when electron is used as a platform
+         * Default: true
+         */
+        useIpcWhenElectron?: boolean;
+        /**
+         * taon contexts here
+         * (module like structure)
+         */
+        contexts?: CONTEXTS;
+        /**
+         * taon controller here
+         * (glue between frontend and backend)
+         */
+        controllers?: CONTROLLERS;
+        /**
+         * taon entities
+         * (entities are used to create tables in db)
+         */
+        entities?: ENTITIES;
+        /**
+         * taon repositories
+         * (repositories are used to access data from db)
+         */
+        repositories?: REPOSITORIES;
+        /**
+         * taon providers
+         * (context singletons)
+         */
+        providers?: PROVIDERS;
+        /**
+         * taon subscribers
+         * (subscribers are used to listen to db events)
+         */
+        subscribers?: SUBSCRIBERS;
+        /**
+         * taon migrations
+         * (migrations are used to update db schema and achieve proper CI/CD)
+         */
+        migrations?: MIGRATIONS;
+        /**
+         * taon middlewares
+         * middlewares are used to intercept requests
+         * and responses in the context
+         */
+        middlewares?: MIDDLEWARES;
+        /**
+         * Config for express session
+         */
+        session?: ISession;
+        /**
+         * taon is not going to write .rest files to cwd()
+         */
+        skipWritingServerRoutes?: boolean;
+        /**
+         * TODO - this is still in progress
+         * @deprecated
+         */
+        productionMode?: boolean;
+        /**
+         * If you want your context to never be started as separated server
+         * use abstract: true
+         * @default: false
+         */
+        abstract?: boolean;
+        logs?: boolean | ConnectionOptionsLogs;
+        database?: boolean | Partial<DatabaseConfig>;
+        /**
+         * disable default realtime communication through TCP upgrade sockets
+         */
+        disabledRealtime?: boolean;
+        /**
+         * Will be removed soon - cloud will handle certs and https
+         * @deprecated
+         */
+        https?: {
+            key: string;
+            cert: string;
+        };
+        /**
+         * TODO - will be removed soon
+         * @deprecated
+         */
+        publicAssets?: {
+            serverPath: string;
+            locationOnDisk: string;
+        }[];
+        /**
+         * by default cwd === process.cwd()
+         */
+        cwd?: string;
+    }
+    namespace Http {
+        export import Rest = Models$1;
+        type ContextENDPOINT = {
+            target: Function;
+            initFN: Function;
+        };
+        type FormlyFromType = 'material' | 'bootstrap';
+        type ExpressContext<T> = (req: Request<any>, res: Response<any>) => 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> {
+            /**
+             * @deprecated use request() mehods instead
+             */
+            readonly received?: Rest.PromiseObservableMix<Rest.HttpResponse<T>>;
+            request?(axiosConfig?: Models$1.Ng2RestAxiosRequestConfig): Rest.PromiseObservableMix<Rest.HttpResponse<T>>;
+        }
+        interface AsyncResponse<T> {
+            (req?: Request<any>, res?: Response<any>): Promise<SyncResponse<T> | SyncResponseFunc<T>>;
+        }
+        type Response<T = string> = AsyncResponse<T> & ClientAction<T>;
+    }
+    interface StartParams {
+        port: number;
+        args: string[];
+        onlyMigrationRun?: boolean;
+        onlyMigrationRevertToTimestamp?: number;
+    }
+    interface TaonInitializeParams {
+        onlyMigrationRun?: boolean;
+        onlyMigrationRevertToTimestamp?: number;
+    }
+    interface TaonCtxCloneParams {
+        useAsRemoteContext?: boolean;
+        overrideRemoteHost?: string;
+        overrideHost?: string;
+        sourceContext?: EndpointContext;
+    }
+}
+
+declare class EndpointContext {
+    private originalConfig;
+    private configFn;
+    /**
+     * (@default: false)
+     * If TRUE context is NOT going to create db/express server/http endpoints
+     * PURPOSE OF THIS PROPERTY
+     * -> ONLY remote access from backend or frontend to specific backend
+     */
+    private readonly cloneOptions;
+    /**
+     * JUST FOR TESTING PURPOSES
+     */
+    readonly USE_MARIADB_MYSQL_IN_DOCKER: boolean;
+    disabledRealtime: boolean;
+    /**
+     * check whether context is inited
+     * (with init() function )
+     */
+    inited: boolean;
+    readonly dbMigrations: ContextDbMigrations;
+    private readonly localInstaceObjSymbol;
+    /**
+     * all instances of classes from context
+     * key is class name
+     */
+    readonly allClassesInstances: {};
+    private readonly classInstancesByNameObj;
+    private readonly objWithClassesInstancesArr;
+    readonly activeRoutes: {
+        expressPath: string;
+        method: Models.Http.Rest.HttpMethod;
+    }[];
+    get sourceContext(): EndpointContext | undefined;
+    readonly skipWritingServerRoutes: boolean;
+    private injectableTypesfromContexts;
+    private allTypesfromContexts;
+    expressApp: Application;
+    serverTcpUdp: Server;
+    databaseConfig?: Models.DatabaseConfigTypeOrm;
+    mode: Models.FrameworkMode;
+    readonly onlyMigrationRun?: boolean;
+    readonly onlyMigrationRevertToTimestamp?: number;
+    get isRunOrRevertOnlyMigrationAppStart(): boolean;
+    session?: Models.ISession;
+    connection: DataSource;
+    private entitiesTriggers;
+    private realtime;
+    get realtimeClient(): taon_browser.RealtimeClient;
+    get realtimeServer(): taon_browser.RealtimeServer;
+    /**
+     * available after init()
+     */
+    config: Models.ContextOptions<any, any, any, any, any, any, any, any>;
+    get logHttp(): boolean;
+    get logRealtime(): boolean;
+    get logFramework(): boolean;
+    get logRoutes(): boolean;
+    get logDb(): boolean;
+    get logMigrations(): boolean;
+    /**
+     * Inside docker there is not need for https secure server
+     */
+    readonly isRunningInsideDocker: boolean;
+    constructor(originalConfig: Models.ContextOptions<any, any, any, any, any, any, any, any>, configFn: (env: any) => Models.ContextOptions<any, any, any, any, any, any, any, any>, 
+    /**
+     * (@default: false)
+     * If TRUE context is NOT going to create db/express server/http endpoints
+     * PURPOSE OF THIS PROPERTY
+     * -> ONLY remote access from backend or frontend to specific backend
+     */
+    cloneOptions: Models.TaonCtxCloneParams);
+    init(options?: {
+        initFromRecrusiveContextResovle?: boolean;
+        onlyMigrationRun?: boolean;
+        onlyMigrationRevertToTimestamp?: number;
+    }): Promise<void>;
+    private getAutoGeneratedConfig;
+    startServer(): Promise<void>;
+    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?: TaonBaseInjector;
+        locaInstanceConstructorArgs?: ConstructorParameters<typeof ctor>;
+        parentInstanceThatWillGetInjectedStuff: object;
+    }): 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, MIDDLEWARES
+     */
+    getClassFunByClassName(className: string): Function;
+    getClassFunByClass(classFunction: Function): Function;
+    getClassFunByArr(classType: Models.ClassType): Function[];
+    private createInstances;
+    initClasses(): Promise<void>;
+    isActiveOn(classInstance: object): boolean;
+    get frontendHostUri(): URL;
+    get uri(): URL | undefined;
+    get uriProtocol(): string | undefined;
+    /**
+     * Examples
+     * http://localhost:3000
+     * https://localhost (from localhost:80)   *
+     */
+    get uriOrigin(): string | undefined;
+    /**
+     * Exampels
+     * http://localhost:3000/path/to/somewhere
+     * https://localhost/path/to/somewhere (from localhost:80)
+     */
+    get uriPathname(): string | undefined;
+    /**
+     * Examples
+     * http://localhost:3000/path/to/somewhere -> '/path/to/somewhere'
+     * http://localhost:3000 -> '' #
+     * https://localhost/path/to/  -> '/path/to/somewhere' # remove last slash
+     */
+    get uriPathnameOrNothingIfRoot(): string;
+    get uriPort(): string | undefined;
+    /**
+     * Port from uri as number
+     * @returns {Number | undefined}
+     */
+    get port(): Number | undefined;
+    get isHttpServer(): boolean;
+    /**
+     * Check if context is for remote only
+     */
+    get isRemoteHost(): boolean;
+    /**
+     * ipc/udp needs this
+     */
+    get contextName(): string;
+    /**
+     * ipc/udp needs this
+     */
+    get contextNameForCommunication(): string;
+    /**
+     * Check context type
+     */
+    get contextType(): 'normal' | 'remote' | 'abstract' | 'invalid';
+    get cwd(): string;
+    get activeContext(): string | null;
+    get appId(): string;
+    get publicAssets(): {
+        serverPath: string;
+        locationOnDisk: string;
+    }[];
+    get isProductionMode(): boolean;
+    get host(): string | undefined;
+    get origin(): string | undefined;
+    initSubscribers(): Promise<any>;
+    initEntities(): Promise<void>;
+    destroy(): Promise<void>;
+    initDatabaseConnection(): Promise<void>;
+    private updateCalculatedPathsForControllers;
+    private mergeControllerMethodsConfigs;
+    initControllersHook(ctxStorage: ContextsEndpointStorage): Promise<void>;
+    initControllers(): Promise<void>;
+    writeActiveRoutes(): void;
+    get middlewares(): Models.MiddlewareType[];
+    private initCustomClientMiddlewares;
+    private initCustomBackendMiddlewares;
+    private initBackendMiddlewares;
+    private initServer;
+    protected sendError(res: express.Response, error: unknown, req: express.Request, expressPath: string): void;
+    /**
+     * client can be browser or nodejs (when remote host)
+     */
+    private initClient;
+}
+
+/**
+ * for backendSocket.in(ROOM_NAME).emit(EVENT)
+ *
+ * Room names are uniqe..
+ * here I am limiting number of event for clients.
+ */
+declare class Realtime {
+    NAMESPACE(contextName: string): string;
+    TABLE_CHANGE(contextName: string, tableName: string): string;
+    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;
+}
+declare namespace Symbols {
+    const ctxInClassOrClassObj: unique symbol;
+    const classNameStaticProperty: string;
+    const fullClassNameStaticProperty: string;
+    const orignalClass: string;
+    const orignalClassClonesObj: string;
+    const classMethodsNames: string;
+    const REALTIME: Realtime;
+    const metadata: {
+        className: string;
+        options: {
+            controller: string;
+            entity: string;
+            repository: string;
+            provider: string;
+            subscriber: string;
+            migration: string;
+        };
+    };
+    const old: {
+        HAS_TABLE_IN_DB: symbol;
+        MDC_KEY: string;
+        WEBSQL_REST_PROGRESS_FUN: symbol;
+        WEBSQL_REST_PROGRESS_FUN_START: symbol;
+        WEBSQL_REST_PROGRESS_FUN_DONE: symbol;
+        WEBSQL_REST_PROGRESS_TIMEOUT: symbol;
+        X_TOTAL_COUNT: string;
+        CIRCURAL_OBJECTS_MAP_BODY: string;
+        CIRCURAL_OBJECTS_MAP_QUERY_PARAM: string;
+        MAPPING_CONFIG_HEADER: string;
+        MAPPING_CONFIG_HEADER_BODY_PARAMS: string;
+        MAPPING_CONFIG_HEADER_QUERY_PARAMS: string;
+        ENDPOINT_META_CONFIG: string;
+        CLASS_DECORATOR_CONTEXT: string;
+        SOCKET_MSG: string;
+        ANGULAR: {
+            INPUT_NAMES: symbol;
+        };
+        ERROR_MESSAGES: {
+            CLASS_NAME_MATCH: string;
+        };
+    };
+}
+
+/**
+ * @returns function that returns context function.
+ * Context function can be used to dynamically
+ * create context with specific configuration.
+ */
+declare const createContextTemplate: <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>, MIGRATION extends Record<string, new (...args: any[]) => any>, MIDDLEWARE extends Record<string, new (...args: any[]) => any>>(configFn: (env: any) => Models.ContextOptions<CTX, CTRL, ENTITY, REPO, PROVIDER, SUBSCRIBER, MIGRATION, MIDDLEWARE>) => () => {
+    readonly contextName: string;
+    readonly appId: string;
+    cloneAsRemote: (cloneOpt?: {
+        overrideRemoteHost?: string;
+    }) => /*elided*/ any;
+    cloneAsNormal: (cloneOpt?: {
+        overrideHost?: string;
+    }) => /*elided*/ any;
+    /**
+     * @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;
+    /**
+     * - create controller instances for context
+     * - init database (if enable) + migation scripts
+     */
+    initialize: (overrideOptions?: Models.TaonInitializeParams) => Promise<EndpointContext>;
+    /**
+     * realtime communication with server
+     * TCP(upgrade) socket.io (or ipc) based.
+     */
+    readonly realtime: {
+        readonly client: taon_browser.RealtimeClient;
+        readonly server: taon_browser.RealtimeServer;
+    };
+};
+declare 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>, MIGRATION extends Record<string, new (...args: any[]) => any>, MIDDLEWARES extends Record<string, new (...args: any[]) => any>>(configFn: (env: any) => Models.ContextOptions<CTX, CTRL, ENTITY, REPO, PROVIDER, SUBSCRIBER, MIGRATION, MIDDLEWARES>) => {
+    readonly contextName: string;
+    readonly appId: string;
+    cloneAsRemote: (cloneOpt?: {
+        overrideRemoteHost?: string;
+    }) => /*elided*/ any;
+    cloneAsNormal: (cloneOpt?: {
+        overrideHost?: string;
+    }) => /*elided*/ any;
+    /**
+     * @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;
+    /**
+     * - create controller instances for context
+     * - init database (if enable) + migation scripts
+     */
+    initialize: (overrideOptions?: Models.TaonInitializeParams) => Promise<EndpointContext>;
+    /**
+     * realtime communication with server
+     * TCP(upgrade) socket.io (or ipc) based.
+     */
+    readonly realtime: {
+        readonly client: taon_browser.RealtimeClient;
+        readonly server: taon_browser.RealtimeServer;
+    };
+};
+type TaonContext = ReturnType<typeof createContext>;
+
+type TaonEntityKeysToOmit = 'ctrl' | 'clone' | '__endpoint_context__' | 'ctx' | 'inject' | '_' | 'relation' | 'relations' | 'inject' | 'injectRepo' | 'injectCustomRepository' | 'injectCustomRepo' | 'injectController' | 'injectCtrl' | 'injectProvider' | 'injectMiddleware';
+declare const TaonEntityKeysToOmitArr: TaonEntityKeysToOmit[];
+
+declare let TAON_CONTEXT: InjectionToken<TaonContext>;
+declare let CURRENT_HOST_BACKEND_PORT: InjectionToken<number>;
+declare let CURRENT_HOST_URL: InjectionToken<string>;
+
+declare const apiPrefix = "api";
+
+/**
+ * @deprecated
+ */
+declare const getTransformFunction: (target: Function) => (entity: any) => any;
+/**
+ * @deprecated
+ */
+declare const singleTransform: (json: any) => any;
+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;
+}
+
+declare const getResponseValue: <T>(response: Models.Http.Response<T>, options?: {
+    req: Request<any>;
+    res: Response<any>;
+}) => Promise<T>;
+
+declare const inject: <T>(entity: () => new (...args: any[]) => T) => T;
+
+interface TaonAdditionalMiddlewareMethodInfo {
+    methodName: string;
+    expressPath: string;
+    httpRequestType: CoreModels.HttpMethod;
+}
+/**
+ * TODO
+ * - global provider available in all contexts
+ * - provider available in own context
+ */
+declare abstract class TaonBaseMiddleware extends TaonBaseInjector {
+}
+interface TaonBaseMiddleware {
+    /**
+     * Global interceptor for whole context
+     * backend request
+     */
+    interceptServer({ req, res, next, }: TaonServerMiddlewareInterceptOptions): Promise<void> | void;
+    /**
+     * Global interceptor for whole context
+     * client requests
+     */
+    interceptClient({ req, next, }: TaonClientMiddlewareInterceptOptions): Observable<AxiosResponse<any>>;
+    /**
+     * Specyfic controller method interceptor
+     */
+    interceptServerMethod({ req, res, next }: TaonServerMiddlewareInterceptOptions, { methodName, expressPath, httpRequestType, }: TaonAdditionalMiddlewareMethodInfo): Promise<void> | void;
+    /**
+     * Controller method frontned interceptor
+     * TODO not needed ?
+     */
+    interceptClientMethod({ req, next }: TaonClientMiddlewareInterceptOptions, { methodName, expressPath, httpRequestType, }: TaonAdditionalMiddlewareMethodInfo): Observable<AxiosResponse<any>>;
+}
+
+type TaonMiddlewareInheritanceObj = {
+    [parentMiddlewaresName: string]: typeof TaonBaseMiddleware;
+};
+type TaonMiddlewareFunction = (options: {
+    /**
+     * middlewares inherited from parent class
+     */
+    parentMiddlewares: TaonMiddlewareInheritanceObj;
+    /**
+     * Get real class name - needed when code is minified
+     */
+    className: (middlewareClass: Function) => string;
+}) => TaonMiddlewareInheritanceObj;
+interface TaonHttpDecoratorOptions {
+    /**
+     * @deprecated don't use in production - keep stuff encapsulated
+     * normally path is generated from method name and its params
+     */
+    path?: string;
+    /**
+     * If true, the path will be global
+     *
+     * ! BE CAREFUL ! global path IS NOT GLOBAL inside dockerized app
+     * (/api/contextName is automatically added to global path in docker)
+     *
+     * @deprecated don't use in production - keep stuff encapsulated
+     */
+    pathIsGlobal?: boolean;
+    overrideContentType?: CoreModels.ContentType;
+    overrideResponseType?: Models$1.ResponseTypeAxios;
+    /**
+     * Express will send response as HTML string with proper headers
+     */
+    overrideExpressSendAsHtml?: boolean;
+    middlewares?: TaonMiddlewareFunction;
+}
+declare function GET(pathOrOptions?: string | TaonHttpDecoratorOptions, pathIsGlobal?: boolean): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+/**
+ * Method for sending html website from text
+ * Example
+ *
+ * ```ts
+ * ...
+ * // in your taon controller
+ * ..Taon.Http.HTML()
+ * sendHtmlDummyWebsite(): Taon.ResponseHtml {
+ *  return  `
+      <html>
+        <head>
+          <title>Dummy website</title>
+        </head>
+        <body>
+          <h1>This is dummy website</h1>
+          <p>Served as HTML string from Taon controller method</p>
+        </body>
+      </html>
+ *  `; *
+ * }
+ * ...
+ * ```
+ */
+declare function HTML(pathOrOptions?: Pick<TaonHttpDecoratorOptions, 'path' | 'pathIsGlobal'>): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+declare function HEAD(pathOrOptions?: string | TaonHttpDecoratorOptions, pathIsGlobal?: boolean): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+declare function POST(pathOrOptions?: string | TaonHttpDecoratorOptions, pathIsGlobal?: boolean): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+declare function PUT(pathOrOptions?: string | TaonHttpDecoratorOptions, pathIsGlobal?: boolean): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+declare function PATCH(pathOrOptions?: string | TaonHttpDecoratorOptions, pathIsGlobal?: boolean): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+declare function DELETE(pathOrOptions?: string | TaonHttpDecoratorOptions, pathIsGlobal?: boolean): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+
+declare class ParamConfig {
+    paramName: string;
+    paramType: CoreModels.ParamType;
+    index: number;
+    defaultType: any;
+    expireInSeconds?: number;
+}
+
+/**
+ * @link './decorators/http/http-methods-decorators.ts' TaonHttpDecoratorOptions
+ */
+declare class MethodConfig implements Pick<TaonHttpDecoratorOptions, 'path' | 'middlewares'> {
+    methodName: string;
+    global?: boolean;
+    /**
+     * override default content type
+     */
+    contentType?: any;
+    /**
+     * override default axiso response type
+     */
+    responseType?: any;
+    overrideExpressSendAsHtml?: boolean;
+    path: string;
+    descriptor: PropertyDescriptor;
+    type: CoreModels.HttpMethod;
+    parameters: {
+        [paramName: string]: Partial<ParamConfig>;
+    };
+    /**
+     * Middlewares from controller method options
+     */
+    middlewares?: TaonMiddlewareFunction;
+    /**
+     * Calculated middlewares object from parents controllers
+     */
+    calculatedMiddlewaresMethodObj?: TaonMiddlewareInheritanceObj;
+    /**
+     * Middlewares array in proper order and ready to be used in
+     * express or in axios interceptors.
+     */
+    calculatedMiddlewares: (typeof TaonBaseMiddleware)[];
+}
+
+declare namespace Validators {
+    const classNameVlidation: (className: any, target: Function) => any;
+    const checkIfMethodsWithReponseTYpeAlowed: (methods: MethodConfig[], current: MethodConfig) => void;
+    const validateClassFunctions: (controllers: any[], entities: any[], proviers: any[], repositories: any[]) => void;
+    const preventUndefinedModel: (model: any, id: any) => void;
+}
+
+declare class TaonBaseClass<CloneT extends TaonBaseClass = any> {
+    /**
+     * class initialization hook
+     * taon after class instance creation
+     */
+    _(): Promise<void>;
+    /**
+     *
+     * @param overrideObjOrFn if object is provided it will override values in cloned object,
+     * if function is provided it will be called with old cloned values and should return
+     * object with values to override
+     * @returns cloned instance of the class
+     */
+    clone(overrideObjOrFn?: Partial<CloneT> | ((oldValues: Partial<CloneT>) => Partial<CloneT>)): CloneT;
+}
+
+declare abstract class TaonBaseEntity<
+/**
+ * type for cloning
+ */
+CloneT extends TaonBaseClass = any> extends TaonBaseClass<CloneT> {
+    /**
+     * simple check if relation is ok
+     */
+    relation(relationName: RelationPath<CloneT>): string;
+    /**
+     * simple check if relation is ok
+     */
+    relations(relationNames: RelationPath<CloneT>[]): string[];
+}
+
+declare abstract class TaonBaseAbstractEntity<CloneT extends TaonBaseClass = any> extends TaonBaseEntity<CloneT> {
+    id: string;
+    version: number;
+}
+type AbstractEntityOmitKeys<ENTITY> = Omit<ENTITY, 'id' | 'version' | '_' | 'clone'>;
+
+/**
+ * TODO prevent calling methods when not initialized
+ * with init(ctx)
+ */
+declare abstract class TaonBaseAngularService {
+    protected readonly platformId: Object;
+    protected readonly currentContext: TaonContext;
+    /**
+     * @deprecated
+     * current context host backend port (for localhost backend)
+     */
+    protected readonly CURRENT_HOST_BACKEND_PORT: number | undefined;
+    /**
+     * @deprecated
+     * current context host URL (for localhost backend)
+     */
+    protected readonly CURRENT_HOST_URL: string | undefined;
+    constructor();
+    /**
+     * Returns true if the application is running in SSR (server-side rendering) mode only.
+     */
+    get isSsrPlatform(): boolean;
+    /**
+     * Returns true if the application is running in browser-only mode.
+     */
+    get isBrowserPlatform(): boolean;
+    /**
+     * @deprecated
+     * Returns the host URL for the backend service
+     * that is running on localhost (normal NodeJS/ExpressJS mode).
+     */
+    get host(): string;
+    injectController<T>(ctor: new (...args: any[]) => T, 
+    /**
+     * optional override context
+     */
+    overrideCurrentContext?: TaonContext): T;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonBaseAngularService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TaonBaseAngularService>;
+}
+
+declare const TaonBaseContext: {
+    readonly contextName: string;
+    readonly appId: string;
+    cloneAsRemote: (cloneOpt?: {
+        overrideRemoteHost?: string;
+    }) => /*elided*/ any;
+    cloneAsNormal: (cloneOpt?: {
+        overrideHost?: string;
+    }) => /*elided*/ any;
+    __ref(): Promise<taon_browser.EndpointContext>;
+    readonly __refSync: taon_browser.EndpointContext;
+    getClassInstance<T>(ctor: new (...args: any[]) => T): T;
+    getClass<T>(ctor: new (...args: any[]) => T): new (...args: any[]) => T;
+    initialize: (overrideOptions?: taon_browser.Models.TaonInitializeParams) => Promise<taon_browser.EndpointContext>;
+    readonly realtime: {
+        readonly client: taon_browser.RealtimeClient;
+        readonly server: taon_browser.RealtimeServer;
+    };
+};
+
+interface MulterFileUploadResponse {
+    ok: boolean;
+    originalName: string;
+    /**
+     * name change to this to avoid confusion with originalname
+     * (similar to originalname with added uniq part)
+     */
+    savedAs: string;
+    size: number;
+    mimetype: string;
+}
+declare class TaonBaseController<UPLOAD_FILE_QUERY_PARAMS = {}> extends TaonBaseInjector {
+    /**
+     * Hook that is called when taon app is inited
+     * (all contexts are created and inited)
+     */
+    afterAllCtxInited(options: {
+        ctxStorage: ContextsEndpointStorage;
+    }): Promise<void>;
+    uploadFormDataToServer(formData: FormData, queryParams?: UPLOAD_FILE_QUERY_PARAMS): Models.Http.Response<MulterFileUploadResponse[]>;
+    /**
+     * Hook after file is uploaded
+     * through `uploadFormDataToServer` or `uploadLocalFileToServer`
+     */
+    protected afterFileUploadAction(file?: MulterFileUploadResponse, queryParams?: UPLOAD_FILE_QUERY_PARAMS): void | Promise<void>;
+    uploadLocalFileToServer(absFilePath: string, options?: Pick<Models.Http.Rest.Ng2RestAxiosRequestConfig, 'onUploadProgress'>, queryParams?: UPLOAD_FILE_QUERY_PARAMS): Promise<MulterFileUploadResponse[]>;
+    /**
+     * Easy way to wait for status change with http (1s default) pooling.
+     *
+     * example (in sub class):
+     * ```ts
+        async check() {
+            await this.waitForProperStatusChange({
+              request: () => this.uploadFormDataToServer(void 0, void 0).request(),
+              statusCheck: resp => resp.body.json[0].ok,
+            });
+          }
+     * ```
+     */
+    _waitForProperStatusChange<T>(options: {
+        actionName: string;
+        /**
+         * Request for pooling
+         */
+        request: (opt?: {
+            /**
+             * optional index number to identify request in logs
+             * (starts from 0 and increments by 1 on each try)
+             */
+            reqIndexNum?: number;
+            httpErrorsCount?: number;
+        }) => ReturnType<Models.Http.Response<T>['request']>;
+        poolingInterval?: number;
+        /**
+         * default infinite tries
+         */
+        maxTries?: number;
+        /**
+         * default infiniti allowed http errors
+         */
+        allowedHttpErrors?: number;
+        /**
+         * condition to be met
+         */
+        statusCheck?: (response: Awaited<ReturnType<typeof options.request>>) => boolean;
+        /**
+         * if return true.. loop will continue
+         * if false .. will exit the loop
+         */
+        loopRequestsOnBackendError?: (opt: {
+            unknownError: Error;
+            unknownHttpError: HttpResponseError<any>;
+            taonError: HttpResponseError<RestErrorResponseWrapper>;
+            reqIndexNum?: number;
+            httpErrorsCount?: number;
+        }) => boolean | Promise<boolean>;
+    }): Promise<void>;
+}
+
+/**
+ * Please override property entityClassFn with entity class.
+ */
+declare abstract class TaonBaseCrudController<Entity, UPLOAD_FILE_QUERY_PARAMS = {}> extends TaonBaseController<UPLOAD_FILE_QUERY_PARAMS> {
+    protected db: TaonBaseRepository<Entity>;
+    /**
+     * Please provide entity as class property entityClassFn:
+     * @returns class function
+     *
+     */
+    abstract entityClassResolveFn: () => any;
+    _(): Promise<void>;
+    bufforedChanges(id: number | string, property: string, alreadyLength?: number): Models.Http.Response<string | any[]>;
+    pagination(pageNumber?: number, pageSize?: number, search?: string): Models.Http.Response<Entity[]>;
+    getAll(): Models.Http.Response<Entity[]>;
+    getBy(id: number | string): Models.Http.Response<Entity>;
+    updateById(id: number | string, item: Entity): Models.Http.Response<Entity>;
+    patchById(id: number | string, item: Entity): Models.Http.Response<Entity>;
+    bulkUpdate(items: Entity[]): Models.Http.Response<Entity[]>;
+    deleteById(id: number | string): Models.Http.Response<Entity>;
+    bulkDelete(ids: (number | string)[]): Models.Http.Response<(number | string | Entity)[]>;
+    clearTable(): Models.Http.Response<void>;
+    save(item: Entity): Models.Http.Response<Entity>;
+    bulkCreate(items: Entity): Models.Http.Response<Entity[]>;
+}
+
+/**
+ * Configurable file upload middleware (multer based)
+ */
+declare class TaonBaseFileUploadMiddleware extends TaonBaseMiddleware {
+    interceptServerMethod({ req, res, next }: TaonServerMiddlewareInterceptOptions, { methodName, expressPath }: TaonAdditionalMiddlewareMethodInfo): Promise<void>;
+    uploadDir(): string;
+    storage(): multer.StorageEngine;
+    upload(): multer.Multer;
+    middleware(): express__default.RequestHandler;
+}
+
+declare class TaonBaseMigration extends TaonBaseInjector implements MigrationInterface {
+    /**
+     * by default is READY to run
+     */
+    isReadyToRun(): boolean;
+    getDescription(): string;
+    up(queryRunner: QueryRunner): Promise<any>;
+    down(queryRunner: QueryRunner): Promise<any>;
+}
+
+/**
+ * TODO
+ * - global provider available in all contexts
+ * - provider available in own context
+ */
+declare class TaonBaseProvider extends TaonBaseInjector {
+}
+
+declare abstract class TaonBaseSubscriberForEntity<Entity = any> extends TaonBaseInjector implements EntitySubscriberInterface {
+    abstract listenTo(): new (...args: any[]) => Entity;
+    /**
+     * Called after entity is loaded.
+     */
+    afterLoad(entity: any): void;
+    /**
+     * Called before query execution.
+     */
+    beforeQuery(event: any): void;
+    /**
+     * Called after query execution.
+     */
+    afterQuery(event: any): void;
+    /**
+     * Called before entity insertion.
+     */
+    beforeInsert(event: InsertEvent<any>): void;
+    /**
+     * Called after entity insertion.
+     */
+    afterInsert(event: InsertEvent<any>): void;
+    /**
+     * Called before entity update.
+     */
+    beforeUpdate(event: UpdateEvent<any>): void;
+    /**
+     * Called after entity update.
+     */
+    afterUpdate(event: UpdateEvent<any>): void;
+    /**
+     * Called before entity removal.
+     */
+    beforeRemove(event: RemoveEvent<any>): void;
+    /**
+     * Called after entity removal.
+     */
+    afterRemove(event: RemoveEvent<any>): void;
+    /**
+     * Called before entity removal.
+     */
+    beforeSoftRemove(event: SoftRemoveEvent<any>): void;
+    /**
+     * Called after entity removal.
+     */
+    afterSoftRemove(event: SoftRemoveEvent<any>): void;
+    /**
+     * Called before entity recovery.
+     */
+    beforeRecover(event: RecoverEvent<any>): void;
+    /**
+     * Called after entity recovery.
+     */
+    afterRecover(event: RecoverEvent<any>): void;
+    /**
+     * Called before transaction start.
+     */
+    beforeTransactionStart(event: TransactionStartEvent): void;
+    /**
+     * Called after transaction start.
+     */
+    afterTransactionStart(event: TransactionStartEvent): void;
+    /**
+     * Called before transaction commit.
+     */
+    beforeTransactionCommit(event: TransactionCommitEvent): void;
+    /**
+     * Called after transaction commit.
+     */
+    afterTransactionCommit(event: TransactionCommitEvent): void;
+    /**
+     * Called before transaction rollback.
+     */
+    beforeTransactionRollback(event: TransactionRollbackEvent): void;
+    /**
+     * Called after transaction rollback.
+     */
+    afterTransactionRollback(event: TransactionRollbackEvent): void;
+}
+
+declare class DecoratorAbstractOpt {
+    className: string;
+}
+
+declare class TaonControllerOptions<ControllerClass = any> extends DecoratorAbstractOpt {
+    /**
+     * typeorm realtime subscribtion // TODO disabled for now, does not make sense ?s
+     */
+    realtime?: boolean;
+    /**
+     * override default path for controller api
+     */
+    path?: string;
+    /**
+     * Middlewares to be applied to all methods in the controller
+     */
+    middlewares?: TaonMiddlewareFunction;
+}
+
+declare class ControllerConfig extends TaonControllerOptions {
+    methods: {
+        [methodName: string]: Partial<MethodConfig>;
+    };
+    /**
+     * Calculated path from parents controllers
+     */
+    calculatedPath?: string;
+    /**
+     * a way to transform entity before sending to browser
+     */
+    browserTransformFn?: (entity: any) => any;
+    /**
+     * Calculated middlewares object from parents controllers
+     */
+    calculatedMiddlewaresControllerObj?: TaonMiddlewareInheritanceObj;
+}
+declare const controllerConfigFrom: (partial: Partial<ControllerConfig>) => ControllerConfig;
+
+declare class DITaonContainer {
+    private static instances;
+    static resolve<T>(target: Function): T;
+    static inject<T>(target: new (...args: any[]) => T): T;
+}
+
+declare class FormlyHorizontalWrapper extends FieldWrapper {
+    fieldComponent: ViewContainerRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyHorizontalWrapper, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormlyHorizontalWrapper, "formly-horizontal-wrapper", never, {}, {}, never, never, false, never>;
+}
+
+declare class RepeatTypeComponent extends FieldArrayType {
+    get labelTemplate(): any;
+    constructor(builder: FormlyFormBuilder);
+    static ɵfac: i0.ɵɵFactoryDeclaration<RepeatTypeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RepeatTypeComponent, "formly-repeat-section", never, {}, {}, never, never, false, never>;
+}
+
+type FormlyInputType = 'input' | 'switch' | 'datepicker' | 'repeat' | 'group' | 'select';
+
+declare function getFromlyConfigFor(target: Function, options?: {
+    formType?: CoreModels.UIFramework;
+    keysPathesToInclude?: string[];
+    keysPathesToExclude?: string[];
+    parentModel?: string;
+    relativePath?: string;
+    level?: number;
+    maxLevel?: number;
+}): FormlyFieldConfig<_ngx_formly_core.FormlyFieldProps & {
+    [additionalProperties: string]: any;
+}>[];
+type FormlyArrayTransformFn = (fieldsArray: FormlyFieldConfig[], fieldObject?: {
+    [propKey: string]: FormlyFieldConfig;
+}) => FormlyFieldConfig[];
+
+declare function findTypeForEntity(entity: Function, isArray?: boolean): FormlyEntityType;
+type FormlyEntityType = {
+    name: string;
+    component: Function;
+    entity?: Function;
+    isArray?: boolean;
+};
+declare function typeFromEntity(component: Function, entity?: Function | Function[]): {
+    name: string;
+    component: Function;
+    entity: Function | Function[];
+    isArray: boolean;
+};
+declare function typeFromName(component: Function, name: string): {
+    name: string;
+    component: Function;
+};
+declare function RegisterComponentTypeForEntity(entity: Function | Function[]): any;
+declare function RegisterComponentType(className: string, ...optionslNames: string[]): any;
+declare function getRegisteredComponents(): FormlyEntityType[];
+
+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 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;
+    /**
+     * Express async handler for middleware functions.
+     */
+    const asyncHandler: (fn: any) => (req: any, res: any, next: any) => void;
+    const getMethodsNames: (classOrClassInstance: any, allMethodsNames?: any[]) => string[];
+    const getControllerConfigs: (target: Function, configs?: ControllerConfig[], callerTarget?: Function) => ControllerConfig[];
+    const ensureClassConfig: (target: Function) => Partial<ControllerConfig>;
+    const ensureMethodConfig: (target: any, propertyKey: string | symbol) => Partial<MethodConfig>;
+    const getClassConfig: (constructor: Function) => Partial<ControllerConfig> | undefined;
+}
+
+declare const cloneObj: <CloneT>(override: Partial<CloneT>, classFn: Function) => CloneT;
+
+declare namespace TaonHelpers {
+    const fillUpTo: (s: string, nCharacters: number) => string;
+    const isGoodPath: (p: string) => boolean;
+    const firstStringOrElemFromArray: (stringOrArrayOfString: string[] | string) => string;
+    const tryTransformParam: (param: any) => any;
+    const getExpressPath: (c: ControllerConfig, pathOrClassConfig: Partial<MethodConfig>) => string;
+    const defaultType: (value: any) => {};
+    const parseJSONwithStringJSONs: (object: Object, waring?: boolean) => Object;
+    const isPlainFileOrFolder: (filePath: any) => boolean;
+    const ipcKeyNameResponse: (target: Function, methodConfig: Partial<MethodConfig>, expressPath: string) => string;
+    const ipcKeyNameRequest: (target: Function, methodConfig: Partial<MethodConfig>, expressPath: string) => string;
+    const websqlMocks: (headers: any) => {
+        request: Express.Request;
+        response: Express.Response;
+    };
+}
+
+/**
+ * 100 default characters varchar
+ */
+declare const StringColumn: <T = string>(defaultValue?: T, length?: number) => PropertyDecorator;
+/**
+ * 100 characters varchar
+ */
+declare const String100Column: <T = string>(defaultValue?: T) => PropertyDecorator;
+/**
+ * 20 characters varchar
+ */
+declare const String20Column: <T = string>(defaultValue?: T) => PropertyDecorator;
+/**
+ * 45 characters varchar
+ */
+declare const String45Column: <T = string>(defaultValue?: T) => PropertyDecorator;
+/**
+ * 500 characters varchar
+ */
+declare const String500Column: <T = string>(defaultValue?: T) => PropertyDecorator;
+/**
+ * 200 characters varchar
+ */
+declare const String200Column: <T = string>(defaultValue?: T) => PropertyDecorator;
+declare const NumberColumn: () => PropertyDecorator;
+declare const DecimalNumberColumn: () => PropertyDecorator;
+declare const SimpleJsonColumn: () => PropertyDecorator;
+declare const BooleanColumn: (defaultValue: boolean | null) => PropertyDecorator;
+declare const DateTimeColumn: (defaultValue?: boolean | null) => PropertyDecorator;
+
+/**
+ * Server for realtime communication
+ * you can trigger:
+ * - entity changes (any property in table changed)
+ * - entity custom property changes (specific property changed)
+ * - entity table changes (new instance added, instance removed)
+ * - custom events
+ *
+ * and also listen to:
+ * - custom events from yourself
+ */
+declare class RealtimeServer {
+    private core;
+    constructor(core: RealtimeCore);
+    private init;
+    private triggerChanges;
+    triggerEntityChanges(entityObjOrClass: Function | object, 
+    /**
+     * value of unique key property of entity instance
+     * (this value is not needed if entityObjOrClass is instance of entity)
+     */
+    idToTrigger?: number | string): void;
+    triggerEntityPropertyChanges(entityObjOrClass: Function | object, 
+    /**
+     * property name or array of property names that changed
+     * for entity instance
+     */
+    property: string | string[], 
+    /**
+     * value of unique key property of entity instance
+     * (this value is not needed if entityObjOrClass is instance of entity)
+     */
+    idToTrigger?: number | string): void;
+    triggerEntityTableChanges(entityClassOrInstance: Function | object): void;
+    triggerCustomEvent(customEvent: string, dataToPush: any): void;
+    /**
+     * Listen to custom events from users
+     * @param customEvent  global event name
+     */
+    listenChangesCustomEvent(customEvent: string): Observable<any>;
+}
+
+declare abstract class RealtimeStrategy {
+    protected ctx: EndpointContext;
+    constructor(ctx: EndpointContext);
+    get ioClient(): typeof io;
+    ioServer(url: string, opt: ServerOptions): Server$1<DefaultEventsMap, DefaultEventsMap, DefaultEventsMap, any>;
+    abstract toString(): string;
+}
+
+declare namespace RealtimeModels {
+    type SubsManagerOpt = {
+        core: RealtimeCore;
+        customEvent: string;
+        roomName: string;
+        property: string;
+    };
+    interface ChangeOption {
+        /**
+         * Specify property name to listen changes on that property only;
+         */
+        property?: string;
+        /**
+         * Override custom event name to listen
+         */
+        customEvent?: string;
+        /**
+         * Value from entity object.
+         * Key for this value is usually id or unique key
+         * property defined in entity decorator.
+         * TODO @LAST IMPLEMENT unique key support
+         */
+        idOrUniqValue?: any;
+    }
+    type EventHandler = (...args: any[]) => void;
+}
+
+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;
+}
+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;
+}
+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
+ */
+declare class RealtimeStrategyIpc extends RealtimeStrategy {
+    protected ctx: EndpointContext;
+    toString(): string;
+    constructor(ctx: EndpointContext);
+    ioServer(__: string, opt: ServerOptions): any;
+    get ioClient(): any;
+}
+
+/**
+ * Purpose:
+ * - browser-browser communication mock (in websql mode)
+ */
+declare class RealtimeStrategyMock extends RealtimeStrategy {
+    protected ctx: EndpointContext;
+    toString(): string;
+    constructor(ctx: EndpointContext);
+    ioServer(url: string, opt: ServerOptions): any;
+    get ioClient(): any;
+}
+
+/**
+ * Purpose:
+ * - backend-browser communication
+ * - backend-backend communication
+ */
+declare class RealtimeStrategySocketIO extends RealtimeStrategy {
+    protected ctx: EndpointContext;
+    toString(): string;
+    constructor(ctx: EndpointContext);
+    ioServer(...args: any[]): any;
+    get ioClient(): typeof 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)
+ */
+declare class RealtimeCore {
+    ctx: EndpointContext;
+    readonly allHttpMethods: string[];
+    readonly client: RealtimeClient;
+    readonly server: RealtimeServer;
+    readonly strategy: RealtimeStrategy;
+    /**
+     * global FE socket - only for established connection
+     */
+    conectSocketFE: Socket<DefaultEventsMap, DefaultEventsMap>;
+    /**
+     * socket for namespaces and rooms
+     */
+    socketFE: Socket<DefaultEventsMap, DefaultEventsMap>;
+    /**
+     * global BE socket - only for established connection
+     */
+    connectSocketBE: Server$1<DefaultEventsMap, DefaultEventsMap, DefaultEventsMap, any>;
+    /**
+     * socket for namespaces and rooms
+     */
+    socketBE: Server$1<DefaultEventsMap, DefaultEventsMap, DefaultEventsMap, any>;
+    constructor(ctx: EndpointContext);
+    private resolveStrategy;
+    pathFor(namespace?: string): URL;
+}
+
+/**
+ * Client for realtime communication
+ * you can listen to:
+ * - entity changes (any property in table changed)
+ * - entity custom property changes (specific property changed)
+ * - entity table changes (new instance added, instance removed)
+ * - custom events
+ */
+declare class RealtimeClient {
+    private core;
+    private subsManagers;
+    constructor(core: RealtimeCore);
+    private init;
+    /**
+     * Usage:
+     * myContext.realtimeClient.listenChangesEntity(myEntityInstance);
+     *
+     *
+     * Changes trigger on backend needs to be done manually.. example code:
+     *
+     * myContext.realtimeServer.triggerEntityChanges(myEntityInstance);
+     * ...
+     */
+    listenChangesEntity<RESULT = any>(entityClassFnOrObj: Function | object, options?: RealtimeModels.ChangeOption): Observable<RESULT>;
+    /**
+     * Listen changes entity table
+     * Example: for pagination, lists update ...
+     */
+    listenChangesEntityTable<RESULT = any>(entityClassFn: Function): Observable<RESULT>;
+    listenChangesCustomEvent<RESULT = any>(customEvent: string): Observable<RESULT>;
+    /**
+     * Trigger custom event on backend
+     * @param customEvent global event name
+     * @param dataToPush
+     */
+    triggerCustomEvent(customEvent: string, dataToPush?: any): void;
+    private getUniqueIdentifierForConnection;
+}
+
+declare class RealtimeSubsManager {
+    private options;
+    private isListening;
+    private observers;
+    constructor(options: RealtimeModels.SubsManagerOpt);
+    startListenIfNotStarted(realtime: Socket<DefaultEventsMap, DefaultEventsMap>): void;
+    add(observer: Subscriber<any>): void;
+    remove(observer: Subscriber<any>): void;
+    private update;
+}
+
+/**
+ * Controller decorator
+ */
+declare function TaonController<ControllerClass = any>(options?: TaonControllerOptions<ControllerClass>): (constructor: Function) => void;
+
+/**
+ * Entity decorator
+ */
+declare function TaonEntity<T = any>(options?: TaonEntityOptions<T>): (constructor: Function) => void;
+declare class TaonEntityOptions<T = any> extends DecoratorAbstractOpt {
+    /**
+     * default unique property is "id"
+     * for your entity it may be something else
+     */
+    uniqueKeyProp?: string;
+    createTable?: boolean;
+    defaultModelValues?: Mapping.ModelValue<T>;
+    defaultModelMapping?: Mapping.Mapping<T>;
+    defaultModelMappingDeep?: {
+        [lodashPathes: string]: string | [string];
+    };
+}
+
+/**
+ * Provider decorator
+ */
+declare function TaonMiddleware<T = any>(options?: TaonMiddlewareOptions<T>): (constructor: Function) => void;
+declare class TaonMiddlewareOptions<T = any> extends DecoratorAbstractOpt {
+}
+
+/**
+ * Migration decorator
+ */
+declare function TaonMigration(options: TaonMigrationOptions): any;
+declare class TaonMigrationOptions<T = any> extends DecoratorAbstractOpt {
+}
+
+/**
+ * Provider decorator
+ */
+declare function TaonProvider<T = any>(options?: TaonProviderOptions<T>): (constructor: Function) => void;
+declare class TaonProviderOptions<T = any> extends DecoratorAbstractOpt {
+}
+
+/**
+ * Repository decorator
+ */
+declare function TaonRepository(options: TaonRepositoryOptions): (constructor: Function) => void;
+declare class TaonRepositoryOptions<T = any> extends DecoratorAbstractOpt {
+}
+
+/**
+ * Subscriber decorator
+ */
+declare function TaonSubscriber<T = any>(options: TaonSubscriberOptions<T>): any;
+declare class TaonSubscriberOptions<T = any> extends DecoratorAbstractOpt {
+    allowedEvents?: (keyof T)[];
+}
+
+/**
+ * @deprecated use Taon.Http.Param.Path (is more safe and cleaner)
+ */
+declare function Path(name: string): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+declare function Query(name?: string): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+declare function Cookie(name: string, expireInSecond?: number): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+declare function Header(name?: string): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+declare function Body(name?: string): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+
+declare class TaonAdminService {
+    private static _instance;
+    static get Instance(): TaonAdminService;
+    scrollableEnabled: boolean;
+    private onEditMode;
+    onEditMode$: rxjs.Observable<unknown>;
+    adminPanelIsOpen: boolean;
+    draggablePopupMode: boolean;
+    draggablePopupModeFullScreen: boolean;
+    /**
+     * Property used in taon
+     */
+    keepWebsqlDbDataAfterReload: boolean;
+    constructor();
+    setEditMode(value: boolean): void;
+    setKeepWebsqlDbDataAfterReload(value: boolean): void;
+    enabledTabs: any[];
+    hide(): void;
+    show(): void;
+    logout(): void;
+}
+
+declare namespace Taon {
+    /**
+     * Remove global taon loader from env.ts [loading.preAngularBootstrap]
+     */
+    const removeLoader: (afterMS?: number) => Promise<void>;
+    const error: (opt: Pick<RestErrorResponseWrapper, "message" | "status" | "details" | "code"> | string) => void;
+    type ResponseHtml = Models.Http.Response<string>;
+    export import Response = Models.Http.Response;
+    export import StartParams = Models.StartParams;
+    const getResponseValue: <T>(response: Response<T>, options?: {
+        req: express.Request<any>;
+        res: express.Response<any>;
+    }) => Promise<T>;
+    const isBrowser: boolean;
+    const isNode: boolean;
+    const isWebSQL: boolean;
+    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>, MIGRATION extends Record<string, new (...args: any[]) => any>, MIDDLEWARES extends Record<string, new (...args: any[]) => any>>(configFn: (env: any) => Models.ContextOptions<CTX, CTRL, ENTITY, REPO, PROVIDER, SUBSCRIBER, MIGRATION, MIDDLEWARES>) => {
+        readonly contextName: string;
+        readonly appId: string;
+        cloneAsRemote: (cloneOpt?: {
+            overrideRemoteHost?: string;
+        }) => /*elided*/ any;
+        cloneAsNormal: (cloneOpt?: {
+            overrideHost?: string;
+        }) => /*elided*/ any;
+        __ref(): Promise<EndpointContext>;
+        readonly __refSync: EndpointContext;
+        getClassInstance<T>(ctor: new (...args: any[]) => T): T;
+        getClass<T>(ctor: new (...args: any[]) => T): new (...args: any[]) => T;
+        initialize: (overrideOptions?: Models.TaonInitializeParams) => Promise<EndpointContext>;
+        readonly realtime: {
+            readonly client: taon_browser.RealtimeClient;
+            readonly server: taon_browser.RealtimeServer;
+        };
+    };
+    const createContextTemplate: <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>, MIGRATION extends Record<string, new (...args: any[]) => any>, MIDDLEWARE extends Record<string, new (...args: any[]) => any>>(configFn: (env: any) => Models.ContextOptions<CTX, CTRL, ENTITY, REPO, PROVIDER, SUBSCRIBER, MIGRATION, MIDDLEWARE>) => () => {
+        readonly contextName: string;
+        readonly appId: string;
+        cloneAsRemote: (cloneOpt?: {
+            overrideRemoteHost?: string;
+        }) => /*elided*/ any;
+        cloneAsNormal: (cloneOpt?: {
+            overrideHost?: string;
+        }) => /*elided*/ any;
+        __ref(): Promise<EndpointContext>;
+        readonly __refSync: EndpointContext;
+        getClassInstance<T>(ctor: new (...args: any[]) => T): T;
+        getClass<T>(ctor: new (...args: any[]) => T): new (...args: any[]) => T;
+        initialize: (overrideOptions?: Models.TaonInitializeParams) => Promise<EndpointContext>;
+        readonly realtime: {
+            readonly client: taon_browser.RealtimeClient;
+            readonly server: taon_browser.RealtimeServer;
+        };
+    };
+    const inject: <T>(entity: () => new (...args: any[]) => T) => T;
+    const symbols: typeof Symbols;
+    /**
+     * @deprecated
+     * use createContext instead
+     */
+    const init: (options: {
+        host: string;
+        entities: Function[];
+        controllers: Function[];
+    }) => Promise<{
+        readonly contextName: string;
+        readonly appId: string;
+        cloneAsRemote: (cloneOpt?: {
+            overrideRemoteHost?: string;
+        }) => /*elided*/ any;
+        cloneAsNormal: (cloneOpt?: {
+            overrideHost?: string;
+        }) => /*elided*/ any;
+        __ref(): Promise<EndpointContext>;
+        readonly __refSync: EndpointContext;
+        getClassInstance<T>(ctor: new (...args: any[]) => T): T;
+        getClass<T>(ctor: new (...args: any[]) => T): new (...args: any[]) => T;
+        initialize: (overrideOptions?: Models.TaonInitializeParams) => Promise<EndpointContext>;
+        readonly realtime: {
+            readonly client: taon_browser.RealtimeClient;
+            readonly server: taon_browser.RealtimeServer;
+        };
+    }>;
+}
+declare const TAON_FLATTEN_MAPPING: {
+    'taon/src': {
+        'Taon.Http.GET': string;
+        'Taon.Http.POST': string;
+        'Taon.Http.PUT': string;
+        'Taon.Http.DELETE': string;
+        'Taon.Http.PATCH': string;
+        'Taon.Http.HEAD': string;
+        'Taon.Http.HTML': string;
+        'Taon.Http.Response': string;
+        'Taon.Http.Param.Query': string;
+        'Taon.Http.Param.Path': string;
+        'Taon.Http.Param.Body': string;
+        'Taon.Http.Param.Cookie': string;
+        'Taon.Http.Param.Header': string;
+        'Taon.Base.Controller': string;
+        'Taon.Base.CrudController': string;
+        'Taon.Base.Entity': string;
+        'Taon.Base.AbstractEntity': string;
+        'Taon.Base.AbstractEntityOmitKeys': string;
+        'Taon.Base.Provider': string;
+        'Taon.Base.Class': string;
+        'Taon.Base.Repository': string;
+        'Taon.Base.CustomRepository': string;
+        'Taon.Base.SubscriberForEntity': string;
+        'Taon.Base.Migration': string;
+        'Taon.Base.Middleware': string;
+        'Taon.Base.AngularService': string;
+        'Taon.Base.Context': string;
+        'Taon.Controller': string;
+        'Taon.Entity': string;
+        'Taon.Provider': string;
+        'Taon.Repository': string;
+        'Taon.Subscriber': string;
+        'Taon.Migration': string;
+        'Taon.Middleware': string;
+        'Taon.Orm.Repository': string;
+        'Taon.Orm.Connection': string;
+        'Taon.Orm.ListenEvent.AfterInsert': string;
+        'Taon.Orm.ListenEvent.AfterLoad': string;
+        'Taon.Orm.ListenEvent.AfterRecover': string;
+        'Taon.Orm.ListenEvent.AfterRemove': string;
+        'Taon.Orm.ListenEvent.AfterSoftRemove': string;
+        'Taon.Orm.ListenEvent.AfterUpdate': string;
+        'Taon.Orm.ListenEvent.BeforeInsert': string;
+        'Taon.Orm.ListenEvent.BeforeRecover': string;
+        'Taon.Orm.ListenEvent.BeforeRemove': string;
+        'Taon.Orm.ListenEvent.BeforeSoftRemove': string;
+        'Taon.Orm.ListenEvent.BeforeUpdate': string;
+        'Taon.Orm.Tree.Children': string;
+        'Taon.Orm.Tree.Parent': string;
+        'Taon.Orm.Column.Generated': string;
+        'Taon.Orm.Column.Primary': string;
+        'Taon.Orm.Column.Index': string;
+        'Taon.Orm.Column.CreateDate': string;
+        'Taon.Orm.Column.UpdateDate': string;
+        'Taon.Orm.Column.DeleteDate': string;
+        'Taon.Orm.Column.Custom': string;
+        'Taon.Orm.Column.String': string;
+        'Taon.Orm.Column.String100': string;
+        'Taon.Orm.Column.String45': string;
+        'Taon.Orm.Column.String500': string;
+        'Taon.Orm.Column.String200': string;
+        'Taon.Orm.Column.Number': string;
+        'Taon.Orm.Column.DecimalNumber': string;
+        'Taon.Orm.Column.SimpleJson': string;
+        'Taon.Orm.Column.Boolean': string;
+        'Taon.Orm.Column.DateTIme': string;
+        'Taon.Orm.Column.Version': string;
+        'Taon.Orm.Column.Virtual': string;
+        'Taon.Orm.Join.Table': string;
+        'Taon.Orm.Join.Column': string;
+        'Taon.Orm.Relation.OneToMany': string;
+        'Taon.Orm.Relation.OneToOne': string;
+        'Taon.Orm.Relation.ManyToMany': string;
+        'Taon.Orm.Relation.ManyToOne': string;
+    };
+    'taon-storage/src': {
+        'Stor.Property.In.LocalStorage': string;
+        'Stor.Property.In.IndexedDb': string;
+        'Stor.In.LocalStorage': string;
+        'Stor.In.IndexedDb': string;
+        'Stor.property.in.localstorage': string;
+        'Stor.property.in.indexedb': string;
+        'Stor.property.in.indexedDb': string;
+        'Stor.proper.in.localstorage': string;
+        'Stor.proper.in.indexedb': string;
+    };
+};
+
+export { BaseTaonClassesNames, Body, BooleanColumn, CURRENT_HOST_BACKEND_PORT, CURRENT_HOST_URL, ClassHelpers, ContextDbMigrations, ContextsEndpointStorage, ControllerConfig, Cookie, DELETE, DITaonContainer, DateTimeColumn, DecimalNumberColumn, DecoratorAbstractOpt, EndpointContext, EntityProcess, FormlyHorizontalWrapper, GET, HEAD, HTML, Header, MethodConfig, MockNamespaceIpc, MockServerIpc, MockSocketIpc, Models, NumberColumn, PATCH, POST, PUT, ParamConfig, Path, Query, RealtimeClient, RealtimeCore, RealtimeModels, RealtimeServer, RealtimeStrategy, RealtimeStrategyIpc, RealtimeStrategyMock, RealtimeStrategySocketIO, RealtimeSubsManager, RegisterComponentType, RegisterComponentTypeForEntity, RepeatTypeComponent, SimpleJsonColumn, String100Column, String200Column, String20Column, String45Column, String500Column, StringColumn, Symbols, TAON_CONTEXT, TAON_FLATTEN_MAPPING, Taon, TaonAdminService, TaonBaseAbstractEntity, TaonBaseAngularService, TaonBaseClass, TaonBaseContext, TaonBaseController, TaonBaseCrudController, TaonBaseCustomRepository, TaonBaseEntity, TaonBaseFileUploadMiddleware, TaonBaseInjector, TaonBaseMiddleware, TaonBaseMigration, TaonBaseProvider, TaonBaseRepository, TaonBaseSubscriberForEntity, TaonController, TaonControllerOptions, TaonEntity, TaonEntityKeysToOmitArr, TaonEntityOptions, TaonHelpers, TaonMiddleware, TaonMiddlewareOptions, TaonMigration, TaonMigrationOptions, TaonProvider, TaonProviderOptions, TaonRepository, TaonRepositoryOptions, TaonRestResponseWrapper, TaonSubscriber, TaonSubscriberOptions, TaonTempDatabasesFolder, TaonTempRoutesFolder, Validators, apiPrefix, cloneObj, controllerConfigFrom, createContext, createContextTemplate, findTypeForEntity, getFromlyConfigFor, getRegisteredComponents, getResponseValue, getTransformFunction, inject, singleTransform, typeFromEntity, typeFromName };
+export type { AbstractEntityOmitKeys, FormlyArrayTransformFn, FormlyEntityType, FormlyInputType, MigrationStatus, MulterFileUploadResponse, TaonAdditionalMiddlewareMethodInfo, TaonContext, TaonEntityKeysToOmit, TaonHttpDecoratorOptions, TaonMiddlewareFunction, TaonMiddlewareInheritanceObj };