tnp-helpers 18.0.24 → 18.0.25

package/lib/project/abstract/artifacts/vscode-plugin/artifact-vscode-plugin.d.ts

@@ -0,0 +1,33 @@
+import { EnvOptions, ReleaseType } from '../../../../options';
+import type { Project } from '../../project';
+import { BaseArtifact } from '../base-artifact';
+export declare class ArtifactVscodePlugin extends BaseArtifact<{
+    vscodeVsixOutPath: string;
+}, {
+    releaseProjPath: string;
+    releaseType: ReleaseType;
+}> {
+    constructor(project: Project);
+    readonly appVscodeJsName = "app.vscode.js";
+    getTmpVscodeProjPath(releaseType?: ReleaseType): string;
+    private getDestExtensionJs;
+    get vcodeProjectUpdatePackageJsonFilename(): string;
+    private get extensionVsixName();
+    clearPartial(clearOption: EnvOptions): Promise<any>;
+    initPartial(initOptions: EnvOptions): Promise<void>;
+    buildPartial(buildOptions: EnvOptions): Promise<{
+        vscodeVsixOutPath: string;
+    }>;
+    releasePartial(releaseOptions: EnvOptions): Promise<{
+        releaseProjPath: string;
+        releaseType: ReleaseType;
+    }>;
+    /**
+     * TODO move this to local release
+     */
+    private installLocally;
+    createVscePackage({ showInfo, args, }?: {
+        showInfo?: boolean;
+        args?: string;
+    }): Promise<void>;
+}

package/lib/project/abstract/artifacts/vscode-plugin/index.d.ts

@@ -0,0 +1 @@
+export * from './artifact-vscode-plugin';

package/lib/project/abstract/framework.d.ts

@@ -0,0 +1,61 @@
+import { CoreModels } from 'tnp-core';
+import { BaseFeatureForProject } from 'tnp-helpers';
+import type { Project } from './project';
+export declare class Framework extends BaseFeatureForProject<Project> {
+    get isUnknownNpmProject(): boolean;
+    /**
+     * TODO make this more robust
+     */
+    get isTnp(): boolean;
+    /**
+     * Core project with basic tested functionality
+     */
+    get isCoreProject(): boolean;
+    get isContainerWithLinkedProjects(): boolean;
+    /**
+     * is normal or smart container
+     */
+    get isContainer(): boolean;
+    get isContainerCoreProject(): boolean;
+    get isContainerCoreProjectTempProj(): boolean;
+    get isContainerChild(): boolean;
+    /**
+     * Standalone project ready for publish on npm
+     * Types of standalone project:
+     * - isomorphic-lib : backend/fronded ts library with server,app preview
+     * - angular-lib: frontend ui lib with angular preview
+     */
+    get isStandaloneProject(): boolean;
+    get frameworkVersion(): CoreModels.FrameworkVersion;
+    get frameworkVersionMinusOne(): CoreModels.FrameworkVersion;
+    frameworkVersionEquals(version: CoreModels.FrameworkVersion): boolean;
+    frameworkVersionAtLeast(version: CoreModels.FrameworkVersion): boolean;
+    frameworkVersionLessThanOrEqual(version: CoreModels.FrameworkVersion): boolean;
+    frameworkVersionLessThan(version: CoreModels.FrameworkVersion): boolean;
+    private get containerDataFromNodeModulesLink();
+    get coreProject(): Project;
+    get isLinkToNodeModulesDifferentThanCoreContainer(): boolean;
+    /**
+     * Get automatic core container for project
+     * WHEN NODE_MODULES BELONG TO TNP -> it uses tnp core container
+     */
+    get coreContainer(): Project;
+    /**
+     * project stores node_modules with compiles npm lib
+     */
+    getTempProjectNameForCopyTo(): string;
+    /**
+     * @deprecated use project.npmPackageName
+     * get actual npm package name from project
+     */
+    get universalPackageName(): string;
+    get allNpmPackagesNames(): string[];
+    /**
+     * get all npm packages names that can be
+     * obtainer from project
+     */
+    get packageNamesFromProject(): string[];
+    get __npmPackageName(): string;
+    get __npmPackageNameAndVersion(): string;
+    global(globalPackageName: string, packageOnly?: boolean): Promise<string>;
+}

package/lib/project/abstract/git.d.ts

@@ -0,0 +1,26 @@
+import { BaseGit } from 'tnp-helpers';
+import { EnvOptions } from '../../options';
+import type { Project } from './project';
+export declare class Git extends BaseGit<Project> {
+    /**
+     * @overload
+     */
+    isUsingActionCommit(): boolean;
+    /**
+     *
+     * @param newVersion
+     * @param pushWithoutAsking
+     */
+    tagAndPushToGitRepo(newVersion: string, releaseOptions: EnvOptions): Promise<void>;
+    /**
+     * @deprecated
+     */
+    __removeTagAndCommit(autoReleaseUsingConfig: boolean): void;
+    useGitBranchesWhenCommitingAndPushing(): boolean;
+    useGitBranchesAsMetadataForCommits(): boolean;
+    protected _beforePushProcessAction(setOrigin: 'ssh' | 'http'): Promise<void>;
+    protected _beforePullProcessAction(setOrigin: 'ssh' | 'http'): Promise<void>;
+    automaticallyAddAllChangesWhenPushingToGit(): boolean;
+    duringPushWarnIfProjectNotOnSpecyficDevBranch(): string;
+    getDefaultDevelopmentBranch(): string;
+}

package/lib/project/abstract/library-build.d.ts

@@ -0,0 +1,9 @@
+import { BaseLibraryBuild } from 'tnp-helpers';
+import type { Project } from './project';
+/**
+ * TODO implement this some day - taon is handling out of box angular projects
+ * => should be easy to implement
+ *
+ * this is only for angular/typescript projects - not isomorphic projects
+ */ export declare class LibraryBuild extends BaseLibraryBuild<Project> {
+}

package/lib/project/abstract/linked-projects.d.ts

@@ -0,0 +1,4 @@
+import { BaseLinkedProjects } from 'tnp-helpers';
+import type { Project } from './project';
+export declare class LinkedProjects extends BaseLinkedProjects<Project> {
+}

package/lib/project/abstract/linter.d.ts

@@ -0,0 +1,9 @@
+import { BaseFeatureForProject } from 'tnp-helpers';
+import type { Project } from './project';
+export declare class Linter// @ts-ignore TODO weird inheritance problem
+ extends BaseFeatureForProject<Project> {
+    init(): Promise<void>;
+    get lintFiles(): Record<string, any>;
+    protected recreateLintConfiguration(): void;
+    get shouldNotEnableLintAndPrettier(): boolean;
+}

package/lib/project/abstract/node-modules.d.ts

@@ -0,0 +1,35 @@
+import { CoreModels } from 'tnp-core';
+import { BaseNodeModules } from 'tnp-helpers';
+import type { NpmHelpers } from './npm-helpers';
+import type { Project } from './project';
+export declare class NodeModules extends BaseNodeModules {
+    project: Project;
+    npmHelpers: NpmHelpers;
+    constructor(project: Project, npmHelpers: NpmHelpers);
+    /**
+     * OVERRIDDEN METHOD for taon use case
+     */
+    reinstall(options?: Omit<CoreModels.NpmInstallOptions, 'pkg'>): Promise<void>;
+    linkFromCoreContainer(): Promise<void>;
+    get shouldDedupePackages(): boolean;
+    /**
+     * BIG TODO Organization project when compiled in dist folder
+     * should store backend files in lib folder
+     */
+    get compiledProjectFilesAndFolders(): string[];
+    updateFromReleaseDist(sourceOfCompiledProject: Project): Promise<void>;
+    dedupe(selectedPackages?: string[]): void;
+    dedupeCount(selectedPackages?: string[]): void;
+    private get packagesToDedupe();
+    /**
+     * Remove already compiled package from node_modules
+     * in project with the same name
+     *
+     * let say we have project "my-project" and we want to remove
+     * "my-project" from node_modules of "my-project"
+     *
+     * This helper is helpful when we want to minified whole library
+     * into single file (using ncc)
+     */
+    removeOwnPackage(actionwhenNotInNodeModules: () => {}): Promise<void>;
+}

package/lib/project/abstract/npm-helpers.d.ts

@@ -0,0 +1,22 @@
+import { BaseNpmHelpers } from 'tnp-helpers';
+import { NodeModules } from './node-modules';
+import { PackageJSON } from './package-json';
+import type { Project } from './project';
+export declare class NpmHelpers extends BaseNpmHelpers<Project> {
+    _nodeModulesType: any;
+    _packageJsonType: any;
+    readonly packageJson: PackageJSON;
+    readonly nodeModules: NodeModules;
+    constructor(project: Project);
+    /**
+     * @deprecated
+     */
+    get lastNpmVersion(): string | undefined;
+    checkProjectReadyForNpmRelease(): void;
+    /**
+     * check whether node_modules installed
+     * or linked from core container
+     * @returns boolean - true if linked from core container
+     */
+    get useLinkAsNodeModules(): boolean;
+}

package/lib/project/abstract/package-json.d.ts

@@ -0,0 +1,14 @@
+import { CoreModels } from 'tnp-core';
+import { BasePackageJson, BaseJsonFileReaderOptions } from 'tnp-helpers';
+import { PackageJson } from 'type-fest';
+import type { Project } from './project';
+export declare class PackageJSON extends BasePackageJson {
+    private project;
+    KEY_TNP_PACKAGE_JSON: string;
+    constructor(options: Omit<BaseJsonFileReaderOptions<PackageJson>, 'fileName'>, project: Project);
+    private updateDataFromTaonJson;
+    private setDataFromCoreContainer;
+    recreateBin(): any;
+    saveToDisk(purpose?: string): void;
+    resolvePossibleNewVersion(releaseVersionBumpType: CoreModels.ReleaseVersionType): string;
+}

package/lib/project/abstract/packages-recognition.d.ts

@@ -0,0 +1,16 @@
+import { BaseFeatureForProject } from 'tnp-helpers';
+import type { Project } from './project';
+export declare class PackagesRecognition extends BaseFeatureForProject<Project> {
+    private get coreContainer();
+    inMemoryIsomorphicLibs: any[];
+    constructor(project: Project);
+    get jsonPath(): string;
+    get libsFromJson(): string[];
+    start(reasonToSearchPackages?: string): Promise<void>;
+    resolveAndAddIsomorphicLibsToMemory(libsNames: string[], informAboutDiff?: boolean): void;
+    /**
+     * main source of isomorphic libs
+     */
+    get allIsomorphicPackagesFromMemory(): string[];
+    protected checkIsomorphic(node_modules: string, packageName: string): boolean;
+}

package/lib/project/abstract/project-resolve.d.ts

@@ -0,0 +1,37 @@
+import { CoreModels } from 'tnp-core';
+import { BaseProjectResolver } from 'tnp-helpers';
+import type { Project } from './project';
+import { TaonProjectsWorker } from './taon-worker/taon.worker';
+export declare class TaonProjectResolve extends BaseProjectResolver<Project> {
+    protected classFn: typeof Project;
+    cliToolName: string;
+    taonProjectsWorker: TaonProjectsWorker;
+    private hasResolveCoreDepsAndFolder;
+    constructor(classFn: typeof Project, cliToolName: string);
+    typeFrom(location: string): CoreModels.LibType;
+    /**
+     * TODO use base resolve
+     */
+    From(locationOfProj: string | string[]): Project;
+    nearestTo<T = Project>(absoluteLocation: string, options?: {
+        type?: CoreModels.LibType;
+        findGitRoot?: boolean;
+        onlyOutSideNodeModules?: boolean;
+    }): T;
+    get Tnp(): Project;
+    by(libraryType: CoreModels.NewFactoryType, version?: CoreModels.FrameworkVersion): Project;
+    private get projectsInUserFolder();
+    /**
+     * taon sync command
+     */
+    sync({ syncFromCommand }?: {
+        syncFromCommand?: boolean;
+    }): void;
+    private reinstallActiveFrameworkContainers;
+    initialCheck(): void;
+    private pathResolved;
+    private resolveCoreProjectsPathes;
+    private get taonProjectsRelative();
+    angularMajorVersionForCurrentCli(): number;
+    taonTagToCheckoutForCurrentCliVersion(cwd: string): string;
+}

package/lib/project/abstract/project.d.ts

@@ -0,0 +1,63 @@
+import { CoreModels } from 'tnp-core';
+import { BaseProject } from 'tnp-helpers';
+import { EnvOptions } from '../../options';
+import { EnvironmentConfig } from './artifacts/__helpers__/environment-config/environment-config';
+import { ArtifactManager } from './artifacts/artifacts-manager';
+import { Framework } from './framework';
+import { Git } from './git';
+import { Linter } from './linter';
+import { NodeModules } from './node-modules';
+import { NpmHelpers } from './npm-helpers';
+import { PackageJSON } from './package-json';
+import { PackagesRecognition } from './packages-recognition';
+import { TaonProjectResolve } from './project-resolve';
+import { QuickFixes } from './quick-fixes';
+import type { ReleaseProcess } from './release-process';
+import { TaonJson } from './taonJson';
+import { Vscode } from './vscode';
+export declare class Project extends BaseProject<Project, CoreModels.LibType> {
+    static ins: TaonProjectResolve;
+    readonly type: CoreModels.LibType;
+    readonly vsCodeHelpers: Vscode;
+    readonly releaseProcess: ReleaseProcess;
+    readonly npmHelpers: NpmHelpers;
+    get packageJson(): PackageJSON;
+    get nodeModules(): NodeModules;
+    readonly linter: Linter;
+    readonly framework: Framework;
+    readonly quickFixes: QuickFixes;
+    readonly artifactsManager: ArtifactManager;
+    readonly git: Git;
+    readonly taonJson: TaonJson;
+    readonly packagesRecognition: PackagesRecognition;
+    readonly environmentConfig: EnvironmentConfig;
+    constructor(location?: string);
+    struct(initOptions?: EnvOptions): Promise<void>;
+    init(initOptions?: EnvOptions): Promise<void>;
+    build(buildOptions?: EnvOptions): Promise<void>;
+    release(releaseOptions: EnvOptions): Promise<void>;
+    lint(lintOptions?: any): Promise<void>;
+    clear(clearOptions?: Partial<EnvOptions>): Promise<void>;
+    /**
+     * @deprecated
+     */
+    get tnpCurrentCoreContainer(): Project;
+    /**
+     * @overload
+     */
+    get name(): string;
+    /**
+     * @overload
+     */
+    get nameForNpmPackage(): string;
+    info(): Promise<void>;
+    /**
+     * @overload
+     */
+    get ins(): TaonProjectResolve;
+    /**
+     * @overload
+     */
+    get children(): Project[];
+    get isMonorepo(): boolean;
+}

package/lib/project/abstract/quick-fixes.d.ts

@@ -0,0 +1,18 @@
+import { BaseQuickFixes } from 'tnp-helpers';
+import type { Project } from '../abstract/project';
+export declare class QuickFixes extends BaseQuickFixes<Project> {
+    recreateTempSourceNecessaryFilesForTesting(): void;
+    makeSureDistFolderExists(): void;
+    missingAngularLibFiles(): void;
+    removeBadTypesInNodeModules(): void;
+    addMissingSrcFolderToEachProject(): void;
+    get nodeModulesPkgsReplacements(): string[];
+    /**
+     * FIX for missing npm packages from npmjs.com
+     *
+     * Extract each file: node_modules-<package Name>.zip
+     * to node_modules folder before instalation.
+     * This will prevent packages deletion from npm
+     */
+    unpackNodeModulesPackagesZipReplacements(): void;
+}

package/lib/project/abstract/release-process/index.d.ts

@@ -0,0 +1 @@
+export * from './release-process';

package/lib/project/abstract/release-process/release-process.d.ts

@@ -0,0 +1,26 @@
+import { CoreModels } from 'tnp-core';
+import { BaseReleaseProcess } from 'tnp-helpers';
+import { ReleaseArtifactTaon, EnvOptions, ReleaseType } from '../../../options';
+import type { Project } from '../project';
+/**
+ * manage standalone or container release process
+ */ export declare class ReleaseProcess extends BaseReleaseProcess<Project> {
+    constructor(project: Project);
+    displayReleaseProcessMenu(envOptions: EnvOptions): Promise<void>;
+    releaseByType(releaseType: ReleaseType, envOptions: EnvOptions): Promise<void>;
+    getEnvNamesByArtifact(artifact: ReleaseArtifactTaon): {
+        envName: CoreModels.EnvironmentNameTaon;
+        envNumber?: number | undefined;
+    }[];
+    displayProjectsSelectionMenu(envOptions: EnvOptions): Promise<Project[]>;
+    displaySelectArtifactsMenu(envOptions: EnvOptions, selectedProjects: Project[], allowedArtifacts?: ReleaseArtifactTaon[] | undefined): Promise<ReleaseArtifactTaon[]>;
+    startRelease(envOptions?: EnvOptions): Promise<void>;
+    releaseArtifacts(releaseType: ReleaseType, releaseArtifactsTaon: ReleaseArtifactTaon[], selectedProjects: Project[], envOptions: EnvOptions): Promise<void>;
+    /**
+     * does not matter if container is releasing standalone
+     * or organization packages -> release commit is pushed
+     */
+    pushReleaseCommits(): Promise<any>;
+    private getReleaseHeader;
+    private getColoredTextItem;
+}

package/lib/project/abstract/taon-worker/taon-build.controller.d.ts

@@ -0,0 +1,5 @@
+import { Taon } from 'taon';
+import { TaonBuild } from './taon-build.entity';
+export declare class TaonBuildController extends Taon.Base.CrudController<TaonBuild> {
+    entityClassResolveFn: () => typeof TaonBuild;
+}

package/lib/project/abstract/taon-worker/taon-build.entity.d.ts

@@ -0,0 +1,8 @@
+import { Taon } from 'taon';
+import { EnvOptions } from '../../../options';
+export declare class TaonBuild extends Taon.Base.AbstractEntity {
+    static from(opt: Omit<TaonBuild, 'id' | 'version' | '_' | 'clone'>): TaonBuild;
+    processInfoPort: number;
+    projectLocation: string;
+    type: EnvOptions;
+}

package/lib/project/abstract/taon-worker/taon-env.entity.d.ts

@@ -0,0 +1,10 @@
+import { Taon } from 'taon';
+export type TaonEnvType = 'dev' | 'prod' | 'test' | 'stage';
+export declare class TaonEnv extends Taon.Base.AbstractEntity {
+    static from(obj: {
+        name: string;
+        type: TaonEnvType;
+    }): TaonEnv;
+    type: TaonEnvType;
+    name: string;
+}

package/lib/project/abstract/taon-worker/taon-project.entity.d.ts

@@ -0,0 +1,8 @@
+import { Taon } from 'taon';
+import { CoreModels } from 'tnp-core';
+export declare class TaonProject extends Taon.Base.Entity {
+    static from(opt: Omit<TaonProject, 'id' | 'version' | '_' | 'clone'>): TaonProject;
+    location: string;
+    type: CoreModels.LibType;
+    isTemporary: boolean;
+}

package/lib/project/abstract/taon-worker/taon.context.d.ts

@@ -0,0 +1,56 @@
+import { TaonProjectsController } from './taon.controller';
+export declare const TaonProjectsContext: {
+    types: {
+        readonly controllers: {
+            TaonProjectsController: typeof TaonProjectsController;
+        };
+        readonly repositories: Record<string, new (...args: any[]) => any>;
+        readonly providers: Record<string, new (...args: any[]) => any>;
+        readonly subscribers: Record<string, new (...args: any[]) => any>;
+        readonly migrations: {
+            TaonProjectsContext_1737301724542_addingSampleData: typeof import("../../../../migrations/1737301724542_addingSampleData").TaonProjectsContext_1737301724542_addingSampleData;
+        };
+    };
+    readonly contexts: {
+        BaseContext: {
+            types: {
+                readonly controllers: Record<string, new (...args: any[]) => any>;
+                readonly repositories: Record<string, new (...args: any[]) => any>;
+                readonly providers: Record<string, new (...args: any[]) => any>;
+                readonly subscribers: Record<string, new (...args: any[]) => any>;
+                readonly migrations: Record<string, new (...args: any[]) => any>;
+            };
+            readonly contexts: Record<string, object>;
+            readonly contextName: string;
+            __ref(): Promise<import("taon/source/lib/endpoint-context").EndpointContext>;
+            readonly __refSync: import("taon/source/lib/endpoint-context").EndpointContext;
+            getClassInstance<T>(ctor: new (...args: any[]) => T): T;
+            getClass<T>(ctor: new (...args: any[]) => T): new (...args: any[]) => T;
+            initialize: (overrideOptions?: {
+                overrideHost?: string;
+                overrideRemoteHost?: string;
+                onlyMigrationRun?: boolean;
+                onlyMigrationRevertToTimestamp?: number;
+            }) => Promise<import("taon/source/lib/endpoint-context").EndpointContext>;
+            readonly realtime: {
+                readonly client: import("taon/source/lib/realtime/realtime-client").RealtimeClient;
+                readonly server: import("taon/source/lib/realtime/realtime-server").RealtimeServer;
+            };
+        };
+    };
+    readonly contextName: string;
+    __ref(): Promise<import("taon/source/lib/endpoint-context").EndpointContext>;
+    readonly __refSync: import("taon/source/lib/endpoint-context").EndpointContext;
+    getClassInstance<T>(ctor: new (...args: any[]) => T): T;
+    getClass<T>(ctor: new (...args: any[]) => T): new (...args: any[]) => T;
+    initialize: (overrideOptions?: {
+        overrideHost?: string;
+        overrideRemoteHost?: string;
+        onlyMigrationRun?: boolean;
+        onlyMigrationRevertToTimestamp?: number;
+    }) => Promise<import("taon/source/lib/endpoint-context").EndpointContext>;
+    readonly realtime: {
+        readonly client: import("taon/source/lib/realtime/realtime-client").RealtimeClient;
+        readonly server: import("taon/source/lib/realtime/realtime-server").RealtimeServer;
+    };
+};

package/lib/project/abstract/taon-worker/taon.controller.d.ts

@@ -0,0 +1,7 @@
+import { Taon } from 'taon';
+import { BaseCliWorkerController } from 'tnp-helpers';
+import { TaonEnv } from './taon-env.entity';
+export declare class TaonProjectsController extends BaseCliWorkerController {
+    taonEnvRepo: Taon.Base.Repository<TaonEnv>;
+    getEnvironments(): Taon.Response<TaonEnv[]>;
+}

package/lib/project/abstract/taon-worker/taon.worker.d.ts

@@ -0,0 +1,40 @@
+import { BaseCliWorker } from 'tnp-helpers';
+import type { TaonProjectResolve } from '../project-resolve';
+import { TaonProjectsController } from './taon.controller';
+export declare class TaonProjectsWorker extends BaseCliWorker {
+    protected readonly ins: TaonProjectResolve;
+    constructor(
+    /**
+     * unique id for service
+     */
+    serviceID: string, 
+    /**
+     * external command that will start service
+     */
+    startCommand: string, ins: TaonProjectResolve);
+    private taonProjectsController;
+    getControllerForRemoteConnection(): Promise<TaonProjectsController>;
+    /**
+     * start normally process
+     * this will crash if process already started
+     */
+    startNormallyInCurrentProcess(options?: {
+        healthCheckRequestTrys?: number;
+    }): Promise<void>;
+    protected headerText(): Promise<string>;
+    protected header(): Promise<void>;
+    getWorkerTerminalActions(): {
+        previewPorts: {
+            name: string;
+            action: () => Promise<void>;
+        };
+        tcpUdPorts: {
+            name: string;
+            action: () => Promise<void>;
+        };
+        emptyAction: {
+            name: string;
+            action: () => Promise<void>;
+        };
+    };
+}

package/lib/project/abstract/taonJson.d.ts

@@ -0,0 +1,49 @@
+import { CoreModels } from 'tnp-core';
+import { BaseFeatureForProject, BasePackageJson } from 'tnp-helpers';
+import { Models } from '../../models';
+import type { Project } from './project';
+export declare class TaonJson extends BaseFeatureForProject<Project> {
+    private readonly data?;
+    /**
+     * package.json override
+     */
+    readonly overridePackageJsonManager: BasePackageJson;
+    constructor(project: Project, defaultValue?: Partial<Models.TaonJson>);
+    get exists(): boolean;
+    preserveOldTaonProps(): void;
+    preservePropsFromPackageJson(): void;
+    saveToDisk(purpose?: string): void;
+    get type(): CoreModels.LibType;
+    /**
+     * Resource to include in npm lib
+     * (relative paths to files or folders)
+     */
+    get resources(): string[];
+    /**
+     * deps to inlculde in npm lib
+     * (relative paths to files or folders)
+     */
+    get dependenciesNamesForNpmLib(): string[];
+    /**
+     * Peer deps to inlculde in npm lib
+     * (relative paths to files or folders)
+     */
+    get peerDependenciesNamesForNpmLib(): string[];
+    setType(type: CoreModels.LibType): void;
+    setFrameworkVersion(frameworkVersionArg: CoreModels.FrameworkVersion): Promise<void>;
+    get isUsingOwnNodeModulesInsteadCoreContainer(): boolean;
+    get shouldGenerateAutogenIndexFile(): boolean;
+    get isMonorepo(): boolean;
+    get isOrganization(): boolean;
+    get nameWhenInsideOrganiation(): string | undefined;
+    get overrideNpmName(): string | undefined;
+    get isCoreProject(): boolean;
+    get frameworkVersion(): CoreModels.FrameworkVersion | undefined;
+    linkTo(destination: string): void;
+    /**
+     * so I can release same npm lib with different name
+     */
+    get additionalNpmNames(): string[];
+    get autoReleaseConfigAllowedItems(): Models.TaonAutoReleaseItem[];
+    set autoReleaseConfigAllowedItems(items: Models.TaonAutoReleaseItem[]);
+}