tnp 21.0.301 → 21.0.302

package/full-dts/project/abstract/artifacts/npm-lib-and-cli-tool/tools/build-isomorphic-lib/code-cut/code-split-process.enum.d.ts

@@ -0,0 +1,53 @@
+// @ts-nocheck
+import { UtilsTypescript } from 'tnp-helpers/src';
+import type { BrowserCodeCut } from './browser-code-cut';
+export declare const CallBackProcess: (fun: (imp: UtilsTypescript.TsImportExport, isomorphicLibraries: string[], currentProjectName: string, currentProjectNpmName: string, browserCodeCut: BrowserCodeCut, relativeFilesToProcess: Map<string, boolean>, appendImports: (importToAppend: Pick<UtilsTypescript.TsImportExport, "cleanEmbeddedPathToFile" | "importElements">) => void) => boolean) => (imp: UtilsTypescript.TsImportExport, isomorphicLibraries: string[], currentProjectName: string, currentProjectNpmName: string, browserCodeCut: BrowserCodeCut, relativeFilesToProcess: Map<string, boolean>, appendImports: (importToAppend: Pick<UtilsTypescript.TsImportExport, "cleanEmbeddedPathToFile" | "importElements">) => void) => boolean;
+/**
+ * TODO In progress documentation for whole code split process
+ */
+export declare namespace CodeSplitProcess {
+    namespace Before {
+        namespace Split {
+            const ImportExport: {
+                PREVENT_IMPORTING_IN_LIB_FROM_SRC_INDEX: (imp: UtilsTypescript.TsImportExport, isomorphicLibraries: string[], currentProjectName: string, currentProjectNpmName: string, browserCodeCut: BrowserCodeCut, relativeFilesToProcess: Map<string, boolean>, appendImports: (importToAppend: Pick<UtilsTypescript.TsImportExport, "cleanEmbeddedPathToFile" | "importElements">) => void) => boolean;
+                /**
+                 * name => nameForNpmPackage
+                 * my-lib => @my-org/my-lib
+                 * my-lib => my-custom-npm-lib
+                 */
+                NAME_TO_NPM_NAME: (imp: UtilsTypescript.TsImportExport, isomorphicLibraries: string[], currentProjectName: string, currentProjectNpmName: string, browserCodeCut: BrowserCodeCut, relativeFilesToProcess: Map<string, boolean>, appendImports: (importToAppend: Pick<UtilsTypescript.TsImportExport, "cleanEmbeddedPathToFile" | "importElements">) => void) => boolean;
+                WITH_LIB_TO_SRC: (imp: UtilsTypescript.TsImportExport, isomorphicLibraries: string[], currentProjectName: string, currentProjectNpmName: string, browserCodeCut: BrowserCodeCut, relativeFilesToProcess: Map<string, boolean>, appendImports: (importToAppend: Pick<UtilsTypescript.TsImportExport, "cleanEmbeddedPathToFile" | "importElements">) => void) => boolean;
+                WITH_SOURCE_TO_SRC: (imp: UtilsTypescript.TsImportExport, isomorphicLibraries: string[], currentProjectName: string, currentProjectNpmName: string, browserCodeCut: BrowserCodeCut, relativeFilesToProcess: Map<string, boolean>, appendImports: (importToAppend: Pick<UtilsTypescript.TsImportExport, "cleanEmbeddedPathToFile" | "importElements">) => void) => boolean;
+                NOTHING_TO_SRC: (imp: UtilsTypescript.TsImportExport, isomorphicLibraries: string[], currentProjectName: string, currentProjectNpmName: string, browserCodeCut: BrowserCodeCut, relativeFilesToProcess: Map<string, boolean>, appendImports: (importToAppend: Pick<UtilsTypescript.TsImportExport, "cleanEmbeddedPathToFile" | "importElements">) => void) => boolean;
+                DEEP_TO_SHORT_SRC: (imp: UtilsTypescript.TsImportExport, isomorphicLibraries: string[], currentProjectName: string, currentProjectNpmName: string, browserCodeCut: BrowserCodeCut, relativeFilesToProcess: Map<string, boolean>, appendImports: (importToAppend: Pick<UtilsTypescript.TsImportExport, "cleanEmbeddedPathToFile" | "importElements">) => void) => boolean;
+                BROWSER_TO_SRC: (imp: UtilsTypescript.TsImportExport, isomorphicLibraries: string[], currentProjectName: string, currentProjectNpmName: string, browserCodeCut: BrowserCodeCut, relativeFilesToProcess: Map<string, boolean>, appendImports: (importToAppend: Pick<UtilsTypescript.TsImportExport, "cleanEmbeddedPathToFile" | "importElements">) => void) => boolean;
+                WEBSQL_TO_SRC: (imp: UtilsTypescript.TsImportExport, isomorphicLibraries: string[], currentProjectName: string, currentProjectNpmName: string, browserCodeCut: BrowserCodeCut, relativeFilesToProcess: Map<string, boolean>, appendImports: (importToAppend: Pick<UtilsTypescript.TsImportExport, "cleanEmbeddedPathToFile" | "importElements">) => void) => boolean;
+            };
+        }
+    }
+    namespace DURING {
+        namespace BACKEND {
+            const SPLIT: {
+                FOR_APP_STANDALONE: (imp: UtilsTypescript.TsImportExport) => void;
+                FOR_APP_ORGANIZATION: (imp: UtilsTypescript.TsImportExport) => void;
+                FOR_LIB_STANDALONE: (imp: UtilsTypescript.TsImportExport) => void;
+                FOR_LIB_ORGANIZATION: (imp: UtilsTypescript.TsImportExport) => void;
+                FOR_FULL_DTS_STANDALONE: (imp: UtilsTypescript.TsImportExport) => void;
+                FOR_FULL_DTS_ORGANIZATION: (imp: UtilsTypescript.TsImportExport) => void;
+            };
+        }
+        namespace CLIENT {
+            const SPLIT: {
+                WEBSQL_FOR_LIB: (imp: UtilsTypescript.TsImportExport) => void;
+                WEBSQL_FOR_APP: (imp: UtilsTypescript.TsImportExport) => void;
+                BROWSER_FOR_LIB: (imp: UtilsTypescript.TsImportExport) => void;
+                BROWSER_FOR_APP: (imp: UtilsTypescript.TsImportExport) => void;
+            };
+        }
+    }
+    namespace AFTER {
+        const SPLIT: {
+            MODULE_FOR_ORGANIZATION: string;
+        };
+    }
+}

package/full-dts/project/abstract/artifacts/npm-lib-and-cli-tool/tools/success-build-observer.d.ts

@@ -0,0 +1,15 @@
+// @ts-nocheck
+import { BehaviorSubject } from 'rxjs';
+import { BaseFeatureForProject } from 'tnp-helpers/src';
+import { Project } from '../../../project';
+export declare class SuccessBuildObserver extends BaseFeatureForProject<Project> {
+    notify: BehaviorSubject<Partial<{
+        backendCommonJSBuildOK: boolean;
+        browserAnuglarBuildOK: boolean;
+        websqlAnuglarBuildOK: boolean;
+    }>>;
+    private builds;
+    debouceSuccess: (() => Promise<void>) & import("lodash").Cancelable;
+    start(): void;
+    get allBuildAreOK(): boolean;
+}

package/full-dts/project/abstract/artifacts/npm-lib-and-cli-tool/tools/success-observer.d.ts

@@ -0,0 +1 @@
+// @ts-nocheck

package/full-dts/project/abstract/artifacts/npm-lib-and-cli-tool/tools/taon-build-state-machine.d.ts

@@ -0,0 +1,18 @@
+// @ts-nocheck
+export type JsPrimitive = string | number | boolean | null | undefined | bigint | symbol;
+export declare class TaonStateMachine<T extends JsPrimitive = JsPrimitive> {
+    private readonly config;
+    private _currentValue;
+    constructor(config: {
+        debugMode?: boolean;
+        defaultValue: T;
+        allowedStateMap?: Map<T, T[]>;
+        modifyStateBeforeSetting?: (nextState: T, currentState: T, debugMode: boolean) => T;
+        effect?: (nextState: T, previousState: T, debugMode: boolean) => void | Promise<void>;
+        throwOnInvalidTransition?: boolean;
+    });
+    get debugMode(): boolean;
+    get currentValue(): T;
+    canSet(nextStateRaw: T): boolean;
+    set(nextStateRaw: T): boolean;
+}

package/full-dts/project/abstract/taon-worker/dev-build/dev-build.constants.d.ts

@@ -0,0 +1,3 @@
+// @ts-nocheck
+import type { DevBuild } from './dev-build.entity';
+export declare const DevBuildDefaultsValues: Partial<DevBuild>;

package/full-dts/project/abstract/taon-worker/dev-build/dev-build.entity.d.ts

@@ -0,0 +1,6 @@
+// @ts-nocheck
+import { TaonBaseAbstractEntity } from 'taon/src';
+export declare class DevBuild extends TaonBaseAbstractEntity<DevBuild> {
+    description?: string;
+    modificationDate?: string;
+}

package/full-dts/project/abstract/taon-worker/dev-builds/dev-builds-api.service.d.ts

@@ -0,0 +1,8 @@
+// @ts-nocheck
+import { Observable } from 'rxjs';
+import { TaonBaseAngularService } from 'taon/src';
+import { DevBuildsController } from './dev-builds.controller';
+export declare class DevBuildsApiService extends TaonBaseAngularService {
+    protected devBuildsController: DevBuildsController;
+    hello(): Observable<string>;
+}

package/full-dts/project/abstract/taon-worker/dev-builds/dev-builds.abstract.context.d.ts

@@ -0,0 +1,20 @@
+// @ts-nocheck
+export declare const DevBuildsContext: {
+    readonly contextName: string;
+    readonly appId: string;
+    cloneAsRemote: (cloneOpt?: {
+        overrideRemoteHost?: string;
+    }) => /*elided*/ any;
+    cloneAsNormal: (cloneOpt?: {
+        overrideHost?: string;
+    }) => /*elided*/ any;
+    __ref(): Promise<import("taon/src").EndpointContext>;
+    readonly __refSync: import("taon/src").EndpointContext;
+    getClassInstance<T>(ctor: new (...args: any[]) => T): T;
+    getClass<T>(ctor: new (...args: any[]) => T): new (...args: any[]) => T;
+    initialize: (overrideOptions?: import("taon/src").Models.TaonInitializeParams) => Promise<import("taon/src").EndpointContext>;
+    readonly realtime: {
+        readonly client: import("taon/src").RealtimeClient;
+        readonly server: import("taon/src").RealtimeServer;
+    };
+};

package/full-dts/project/abstract/taon-worker/dev-builds/dev-builds.constants.d.ts

@@ -0,0 +1,3 @@
+// @ts-nocheck
+import type { DevBuilds } from './dev-builds.entity';
+export declare const DevBuildsDefaultsValues: Partial<DevBuilds>;

package/full-dts/project/abstract/taon-worker/dev-builds/dev-builds.controller.d.ts

@@ -0,0 +1,9 @@
+// @ts-nocheck
+import { Taon, TaonBaseCrudController } from 'taon/src';
+import { DevBuilds } from './dev-builds.entity';
+import { DevBuildsRepository } from './dev-builds.repository';
+export declare class DevBuildsController extends TaonBaseCrudController<DevBuilds> {
+    entityClassResolveFn: () => typeof DevBuilds;
+    devBuildsRepository: DevBuildsRepository;
+    helloWord(yourName: string): Taon.Response<string>;
+}

package/full-dts/project/abstract/taon-worker/dev-builds/dev-builds.entity.d.ts

@@ -0,0 +1,6 @@
+// @ts-nocheck
+import { TaonBaseAbstractEntity } from 'taon/src';
+export declare class DevBuilds extends TaonBaseAbstractEntity<DevBuilds> {
+    description?: string;
+    modificationDate?: string;
+}

package/full-dts/project/abstract/taon-worker/dev-builds/dev-builds.repository.d.ts

@@ -0,0 +1,10 @@
+// @ts-nocheck
+import { TaonBaseRepository } from 'taon/src';
+import { DevBuilds } from './dev-builds.entity';
+export declare class DevBuildsRepository extends TaonBaseRepository<DevBuilds> {
+    entityClassResolveFn: () => typeof DevBuilds;
+    /**
+     * TODO remove this demo example method
+     */
+    countEntitesWithEvenId(): Promise<number>;
+}

package/full-dts/project/abstract/taon-worker/dev-builds/index.d.ts

@@ -0,0 +1,6 @@
+// @ts-nocheck
+export * from './dev-builds-api.service';
+export * from './dev-builds.constants';
+export * from './dev-builds.entity';
+export * from './dev-builds.controller';
+export * from './dev-builds.abstract.context';

package/full-dts/project/abstract/taon-worker/dev-mode/dev-mode.constants.d.ts

@@ -0,0 +1,3 @@
+// @ts-nocheck
+import type { DevMode } from './dev-mode.entity';
+export declare const DevModeDefaultsValues: Partial<DevMode>;

package/full-dts/project/abstract/taon-worker/dev-mode/dev-mode.entity.d.ts

@@ -0,0 +1,5 @@
+// @ts-nocheck
+import { TaonBaseAbstractEntity } from 'taon/src';
+export declare class DevMode extends TaonBaseAbstractEntity<DevMode> {
+    description?: string;
+}

package/full-dts/project/abstract/taon-worker/instances/index.d.ts

@@ -0,0 +1,6 @@
+// @ts-nocheck
+export * from './instances-api.service';
+export * from './instances.defaults-values';
+export * from './instances';
+export * from './instances.controller';
+export * from './instances.context';

package/full-dts/project/abstract/taon-worker/instances/instances-api.service.d.ts

@@ -0,0 +1,8 @@
+// @ts-nocheck
+import { Observable } from 'rxjs';
+import type { Instances } from './instances';
+import { TaonBaseAngularService } from 'taon/src';
+export declare class InstancesApiService extends TaonBaseAngularService {
+    private instancesController;
+    get allMyEntities$(): Observable<Instances[]>;
+}

package/full-dts/project/abstract/taon-worker/instances/instances.context.d.ts

@@ -0,0 +1,20 @@
+// @ts-nocheck
+export declare const InstancesContext: () => {
+    readonly contextName: string;
+    readonly appId: string;
+    cloneAsRemote: (cloneOpt?: {
+        overrideRemoteHost?: string;
+    }) => /*elided*/ any;
+    cloneAsNormal: (cloneOpt?: {
+        overrideHost?: string;
+    }) => /*elided*/ any;
+    __ref(): Promise<import("taon/src").EndpointContext>;
+    readonly __refSync: import("taon/src").EndpointContext;
+    getClassInstance<T>(ctor: new (...args: any[]) => T): T;
+    getClass<T>(ctor: new (...args: any[]) => T): new (...args: any[]) => T;
+    initialize: (overrideOptions?: import("taon/src").Models.TaonInitializeParams) => Promise<import("taon/src").EndpointContext>;
+    readonly realtime: {
+        readonly client: import("taon/src").RealtimeClient;
+        readonly server: import("taon/src").RealtimeServer;
+    };
+};

package/full-dts/project/abstract/taon-worker/instances/instances.controller.d.ts

@@ -0,0 +1,11 @@
+// @ts-nocheck
+import { Taon } from 'taon/src';
+import { TaonBaseCliWorkerController } from 'tnp-helpers/src';
+import { Instances } from './instances';
+import { InstancesRepository } from './instances.repository';
+export declare class InstancesController extends TaonBaseCliWorkerController {
+    instancesRepository: InstancesRepository;
+    getEntities(): Taon.Response<Instances[]>;
+    delete(id: string): Taon.Response<Instances>;
+    insertEntity(entity: Instances): Taon.Response<Instances>;
+}

package/full-dts/project/abstract/taon-worker/instances/instances.d.ts

@@ -0,0 +1,10 @@
+// @ts-nocheck
+import { TaonBaseAbstractEntity } from 'taon/src';
+export declare class Instances extends TaonBaseAbstractEntity<Instances> {
+    /**
+     * zip file with docker-compose and other files
+     * needed to deploy this deployment
+     */
+    ipAddress: string;
+    name: string;
+}

package/full-dts/project/abstract/taon-worker/instances/instances.defaults-values.d.ts

@@ -0,0 +1,3 @@
+// @ts-nocheck
+import type { Instances } from './instances';
+export declare const InstancesDefaultsValues: Partial<Instances>;

package/full-dts/project/abstract/taon-worker/instances/instances.repository.d.ts

@@ -0,0 +1,7 @@
+// @ts-nocheck
+import { Instances } from './instances';
+import { TaonBaseRepository } from 'taon/src';
+export declare class InstancesRepository extends TaonBaseRepository<Instances> {
+    entityClassResolveFn: () => typeof Instances;
+    testMethod(): void;
+}

package/full-dts/project/abstract/taon-worker/instances/instances.terminal-ui.d.ts

@@ -0,0 +1,12 @@
+// @ts-nocheck
+import { CoreModels } from 'tnp-core/src';
+import { BaseCliWorkerTerminalUI, BaseWorkerTerminalActionReturnType } from 'tnp-helpers/src';
+import { InstancesWorker } from './instances.worker';
+export declare class InstancesTerminalUI extends BaseCliWorkerTerminalUI<InstancesWorker> {
+    headerText(): Promise<string>;
+    textHeaderStyle(): CoreModels.CfontStyle;
+    getWorkerTerminalActions(options?: {
+        exitIsOnlyReturn?: boolean;
+        chooseAction?: boolean;
+    }): BaseWorkerTerminalActionReturnType;
+}

package/full-dts/project/abstract/taon-worker/instances/instances.worker.d.ts

@@ -0,0 +1,19 @@
+// @ts-nocheck
+import { BaseCliWorker } from 'tnp-helpers/src';
+import { InstancesController } from './instances.controller';
+import { InstancesTerminalUI } from './instances.terminal-ui';
+export declare class InstancesWorker extends BaseCliWorker<InstancesController, InstancesTerminalUI> {
+    workerContextTemplate: any;
+    terminalUI: InstancesTerminalUI;
+    controllerClass: typeof InstancesController;
+    constructor(
+    /**
+     * unique id for service
+     */
+    serviceID: string, 
+    /**
+     * external command that will start service
+     */
+    startCommandFn: () => string);
+    startNormallyInCurrentProcess(): Promise<void>;
+}

package/full-dts/project/abstract/taon-worker/processes/index.d.ts

@@ -0,0 +1,6 @@
+// @ts-nocheck
+export * from './processes-api.service';
+export * from './processes.defaults-values';
+export * from './processes';
+export * from './processes.controller';
+export * from './processes.context';

package/full-dts/project/abstract/taon-worker/processes/processes-api.service.d.ts

@@ -0,0 +1,6 @@
+// @ts-nocheck
+import { TaonBaseAngularService } from 'taon/src';
+import { ProcessesController } from './processes.controller';
+export declare class ProcessesApiService extends TaonBaseAngularService {
+    protected processesController: ProcessesController;
+}

package/full-dts/project/abstract/taon-worker/processes/processes.context.d.ts

@@ -0,0 +1,20 @@
+// @ts-nocheck
+export declare const ProcessesContext: () => {
+    readonly contextName: string;
+    readonly appId: string;
+    cloneAsRemote: (cloneOpt?: {
+        overrideRemoteHost?: string;
+    }) => /*elided*/ any;
+    cloneAsNormal: (cloneOpt?: {
+        overrideHost?: string;
+    }) => /*elided*/ any;
+    __ref(): Promise<import("taon/src").EndpointContext>;
+    readonly __refSync: import("taon/src").EndpointContext;
+    getClassInstance<T>(ctor: new (...args: any[]) => T): T;
+    getClass<T>(ctor: new (...args: any[]) => T): new (...args: any[]) => T;
+    initialize: (overrideOptions?: import("taon/src").Models.TaonInitializeParams) => Promise<import("taon/src").EndpointContext>;
+    readonly realtime: {
+        readonly client: import("taon/src").RealtimeClient;
+        readonly server: import("taon/src").RealtimeServer;
+    };
+};

package/full-dts/project/abstract/taon-worker/processes/processes.controller.d.ts

@@ -0,0 +1,14 @@
+// @ts-nocheck
+import { Taon } from 'taon/src';
+import { TaonBaseCrudController } from 'taon/src';
+import { Processes } from './processes';
+export declare class ProcessesController extends TaonBaseCrudController<Processes> {
+    entityClassResolveFn: () => typeof Processes;
+    private processesRepository;
+    getByProcessID(processId: number | string): Taon.Response<Processes>;
+    getByUniqueParams(cwd: string, command: string): Taon.Response<Processes>;
+    triggerStart(processId: number | string, processName?: string): Taon.Response<void>;
+    triggerStop(processId: number | string, deleteAfterKill?: boolean): Taon.Response<void>;
+    waitUntilProcessDeleted(processId: string | number): Promise<void>;
+    waitUntilProcessStopped(processId: string | number): Promise<void>;
+}

package/full-dts/project/abstract/taon-worker/processes/processes.d.ts

@@ -0,0 +1,25 @@
+// @ts-nocheck
+import { TaonBaseAbstractEntity } from 'taon/src';
+import { ProcessesState } from './processes.models';
+export declare class Processes extends TaonBaseAbstractEntity<Processes> {
+    command: string;
+    cwd: string;
+    state: ProcessesState;
+    pid: number;
+    ppid: number;
+    conditionProcessActiveStdout: string[];
+    conditionProcessActiveStderr: string[];
+    /**
+     * last 40 lines of output
+     * (combined stdout + stderr)
+     */
+    outputLast40lines: string;
+    /**
+     * absolute path to file where stdout + stderr is logged
+     */
+    fileLogAbsPath: string;
+    get previewString(): string;
+    fullPreviewString(options?: {
+        boldValues?: boolean;
+    }): string;
+}

package/full-dts/project/abstract/taon-worker/processes/processes.defaults-values.d.ts

@@ -0,0 +1,3 @@
+// @ts-nocheck
+import type { Processes } from './processes';
+export declare const ProcessesDefaultsValues: Partial<Processes>;

package/full-dts/project/abstract/taon-worker/processes/processes.models.d.ts

@@ -0,0 +1,34 @@
+// @ts-nocheck
+export declare enum ProcessesState {
+    /**
+     * Process has not been started yet, only entity exists in the DB
+     */
+    NOT_STARTED = "not-started",
+    /**
+     * child_process is being started
+     */
+    STARTING = "starting",
+    /**
+     * Process is running and proper processActiveMessages displayed in
+     * output (stdout / stderr)
+     */
+    ACTIVE = "active",
+    /**
+     * Process is being killed
+     */
+    KILLING = "killing",
+    /**
+     * Process killed after being active
+     */
+    KILLED = "killed",
+    /**
+     * Process ended with error (exit code different than 0)
+     */
+    ENDED_WITH_ERROR = "ended-with-error",
+    /**
+     * Process ended ok (exit code 0)
+     */
+    ENDED_OK = "ended-ok"
+}
+export declare const ProcessesStatesAllowedStart: ProcessesState[];
+export declare const ProcessesStatesAllowedStop: ProcessesState[];

package/full-dts/project/abstract/taon-worker/processes/processes.repository.d.ts

@@ -0,0 +1,19 @@
+// @ts-nocheck
+import { Processes } from './processes';
+import { TaonBaseRepository } from 'taon/src';
+export declare class ProcessesRepository extends TaonBaseRepository<Processes> {
+    entityClassResolveFn: () => typeof Processes;
+    private processFileLoggers;
+    getByProcessID(processId: number | string): Promise<Processes | null>;
+    getByUniqueParams({ cwd, command, }: {
+        cwd: string;
+        command: string;
+    }): Promise<Processes | null>;
+    triggerStart(processId: string | number, options?: {
+        processName?: string;
+    }): Promise<void>;
+    triggerStop(processId: string | number, options?: {
+        deleteAfterKill?: boolean;
+    }): Promise<void>;
+    private getAndUpdateProcess;
+}

package/full-dts/project/abstract/taon-worker/processes/processes.terminal-ui.d.ts

@@ -0,0 +1,20 @@
+// @ts-nocheck
+import { CoreModels } from 'tnp-core/src';
+import { BaseCliWorkerTerminalUI, BaseWorkerTerminalActionReturnType } from 'tnp-helpers/src';
+import { Processes } from './processes';
+import { ProcessesController } from './processes.controller';
+import { ProcessesWorker } from './processes.worker';
+export declare class ProcessesTerminalUI extends BaseCliWorkerTerminalUI<ProcessesWorker> {
+    protected headerText(): Promise<string>;
+    protected textHeaderStyle(): CoreModels.CfontStyle;
+    getDummyProcessParams(): Promise<{
+        command: string;
+        cwd: string;
+    }>;
+    protected refetchProcess(process: Processes, processesController: ProcessesController): Promise<Processes>;
+    protected crudMenuForSingleProcess(processFromDb: Processes, processesController: ProcessesController): Promise<void>;
+    getWorkerTerminalActions(options?: {
+        exitIsOnlyReturn?: boolean;
+        chooseAction?: boolean;
+    }): BaseWorkerTerminalActionReturnType;
+}

package/full-dts/project/abstract/taon-worker/processes/processes.utils.d.ts

@@ -0,0 +1,7 @@
+// @ts-nocheck
+import { ProcessesController } from './processes.controller';
+export declare namespace ProcessesUtils {
+    const displayRealtimeProgressMonitor: (processId: number | string, processesController: ProcessesController, options?: {
+        resolveWhenTextInOutput?: string;
+    }) => Promise<void>;
+}

package/full-dts/project/abstract/taon-worker/processes/processes.worker.controller.d.ts

@@ -0,0 +1,4 @@
+// @ts-nocheck
+import { TaonBaseCliWorkerController } from 'tnp-helpers/src';
+export declare class ProcessesWorkerController extends TaonBaseCliWorkerController {
+}

package/full-dts/project/abstract/taon-worker/processes/processes.worker.d.ts

@@ -0,0 +1,19 @@
+// @ts-nocheck
+import { BaseCliWorker } from 'tnp-helpers/src';
+import { ProcessesTerminalUI } from './processes.terminal-ui';
+import { ProcessesWorkerController } from './processes.worker.controller';
+export declare class ProcessesWorker extends BaseCliWorker<ProcessesWorkerController, ProcessesTerminalUI> {
+    workerContextTemplate: any;
+    terminalUI: ProcessesTerminalUI;
+    controllerClass: typeof ProcessesWorkerController;
+    constructor(
+    /**
+     * unique id for service
+     */
+    serviceID: string, 
+    /**
+     * external command that will start service
+     */
+    startCommandFn: () => string);
+    startNormallyInCurrentProcess(): Promise<void>;
+}

package/full-dts/project/abstract/taon-worker/taon-isomorphic-pkgs-detection.repository.d.ts

@@ -0,0 +1,5 @@
+// @ts-nocheck
+import { TaonBaseCustomRepository } from 'taon/src';
+export declare class TaonIsomorphicPkgsDetectionRepository extends TaonBaseCustomRepository {
+    detectPackagesForContainer: ((nodeModulesPath: string) => Promise<void>) & import("lodash").Cancelable;
+}

package/full-dts/project/abstract/taon-worker/traefik/traefik.models.d.ts

@@ -0,0 +1,21 @@
+// @ts-nocheck
+export interface TraefikConfig {
+    http: {
+        routers: Record<string, TraefikRouter>;
+        services: Record<string, TraefikService>;
+    };
+}
+export interface TraefikRouter {
+    rule: string;
+    service: string;
+    entryPoints: string[];
+    tls?: Record<string, any> | null;
+}
+export interface TraefikService {
+    loadBalancer: {
+        servers: TraefikServer[];
+    };
+}
+export interface TraefikServer {
+    url: string;
+}

package/full-dts/project/abstract/taon-worker/traefik/traefik.provider.d.ts

@@ -0,0 +1,41 @@
+// @ts-nocheck
+import { TaonCloudStatus } from '../taon.models';
+import type { TaonProjectsWorker } from '../taon.worker';
+import { TraefikServiceProvider } from './treafik-service.provider';
+export declare class TraefikProvider {
+    private taonProjectsWorker;
+    service: TraefikServiceProvider;
+    readonly cloudIps: string[];
+    protected taonCloudStatus: TaonCloudStatus;
+    protected reverseProxyNetworkName: string;
+    get cloudIsEnabled(): boolean;
+    get isDevMode(): boolean;
+    /**
+     * Path to traefik docker compose cwd where
+     * compose will be started
+     */
+    get pathToTraefikComposeDestCwd(): string;
+    /**
+     * Path to traefik docker compose template files
+     */
+    private get pathToTraefikComposeSourceTemplateFilesCwd();
+    constructor(taonProjectsWorker: TaonProjectsWorker);
+    protected setEnabledMode(): void;
+    protected checkIfDockerEnabled(): Promise<boolean>;
+    protected deleteTraefikNetwork(): Promise<void>;
+    protected makeSureTraefikNetworkCreated(): Promise<void>;
+    protected selectModeExplain(): Promise<void>;
+    protected selectMode(options?: {}): Promise<TaonCloudStatus>;
+    protected checkIfTraefikIsRunning(options?: {
+        waitUntilHealthy?: boolean;
+        maxTries?: number;
+    }): Promise<boolean>;
+    protected selectCloudIps(): Promise<boolean>;
+    protected areCloudIpsValid(): Promise<boolean>;
+    initialCloudStatusCheck(): Promise<void>;
+    restartTraefik(options?: {
+        hardRestart?: boolean;
+    }): Promise<void>;
+    startTraefik(): Promise<boolean>;
+    stopTraefik(): Promise<void>;
+}

package/full-dts/project/abstract/taon-worker/traefik/treafik-service.provider.d.ts

@@ -0,0 +1,42 @@
+// @ts-nocheck
+import { BaseCliWorker } from 'tnp-helpers/src';
+import { TraefikProvider } from './traefik.provider';
+export declare class TraefikServiceProvider {
+    private traefikProvider;
+    constructor(traefikProvider: TraefikProvider);
+    protected get dynamicServicesRelativePathPart(): string;
+    protected getRuleFromIp(options: {
+        publicOrLocalIp: string;
+        worker?: BaseCliWorker<any, any>;
+    }): string;
+    protected yamlPathForServiceName(options: {
+        ipAsServiceName: string;
+    }): string;
+    getIpFromYml(): string | undefined;
+    initServiceReadme(): void;
+    registerWorkers(publicOrLocalIp: string, workers: BaseCliWorker<any, any>[], options?: {
+        /**
+         * If true, Traefik will be restarted after registering the service
+         */
+        restartTraefikAfterRegister?: boolean;
+    }): Promise<void>;
+    /**
+     * @deprecated
+     */
+    register(publicOrLocalIp: string, localhostPort: number, options?: {
+        /**
+         * If true, Traefik will be restarted after registering the service
+         */
+        restartTraefikAfterRegister?: boolean;
+    }): Promise<boolean>;
+    /**
+     * Remove traefik routes for service
+     * @param serviceId service name to unregister (kebab-case)
+     */
+    unregister(publicOrLocalIp: string): Promise<void>;
+    /**
+     * Check if a service is already registered in Traefik
+     * (by verifying if dynamic YAML config exists)
+     */
+    isRegistered(publicOrLocalIp: string): Promise<boolean>;
+}

package/full-dts/test-async.d.ts

@@ -0,0 +1,2 @@
+// @ts-nocheck
+export declare function testAsyncTs(): void;