nativescript 9.1.0-alpha.16 → 9.1.0-alpha.17

package/bin/tns

@@ -2,11 +2,75 @@
 
 "use strict";
 var path = require("path"),
-	pathToLib = path.join(__dirname, "..", "lib"),
+	fs = require("fs"),
+	// In the published package dist/ is the root, so lib/ already sits next to
+	// bin/. In a source checkout lib/ holds only TypeScript and the compiled
+	// output lives under dist/.
+	distLib = path.join(__dirname, "..", "dist", "lib"),
+	pathToLib = fs.existsSync(distLib)
+		? distLib
+		: path.join(__dirname, "..", "lib"),
 	pathToCommon = path.join(pathToLib, "common");
 
 require(path.join(pathToCommon, "verify-node-version")).verifyNodeVersion();
 
+// Prefer a project-local CLI install when one is resolvable from the current
+// directory: the project pins its own nativescript version, and running the
+// invoked (typically global) copy against it means two CLI versions
+// disagreeing about one project. The probe must never break the CLI - any
+// failure falls through to the invoked copy. Opt out per invocation with
+// --no-local-cli or NS_CLI_NO_LOCAL=1; NS_CLI_LOCAL_DELEGATED marks the
+// handed-off process so the local copy never delegates again.
+var noLocalFlagIndex = process.argv.indexOf("--no-local-cli");
+if (noLocalFlagIndex !== -1) {
+	process.argv.splice(noLocalFlagIndex, 1);
+}
+
+if (
+	!process.env.NS_CLI_LOCAL_DELEGATED &&
+	!process.env.NS_CLI_NO_LOCAL &&
+	noLocalFlagIndex === -1
+) {
+	var localEntry = null;
+	var localVersion = null;
+	var localDir = null;
+	try {
+		var localPackageJsonPath = require.resolve("nativescript/package.json", {
+			paths: [process.cwd()],
+		});
+		var ownPackageJsonPath = path.join(__dirname, "..", "package.json");
+		// realpath both sides so an npm-linked or symlinked install of the
+		// same copy is not mistaken for a different one.
+		if (
+			fs.realpathSync(localPackageJsonPath) !==
+			fs.realpathSync(ownPackageJsonPath)
+		) {
+			localDir = path.dirname(localPackageJsonPath);
+			var candidate = path.join(localDir, "bin", "tns");
+			if (fs.existsSync(candidate)) {
+				localEntry = candidate;
+				localVersion = require(localPackageJsonPath).version;
+			}
+		}
+	} catch (err) {
+		// No local install resolvable from cwd - run the invoked copy.
+	}
+
+	if (localEntry) {
+		process.env.NS_CLI_LOCAL_DELEGATED = "1";
+		// stderr, so scripts parsing stdout (e.g. `ns --version`) are unaffected.
+		console.error(
+			"Using the project-local nativescript@" +
+				localVersion +
+				" (" +
+				localDir +
+				").",
+		);
+		require(localEntry);
+		return;
+	}
+}
+
 var pathToCliExecutable = path.join(pathToLib, "nativescript-cli.js");
 
 require(pathToCliExecutable);

package/config/config.json

@@ -4,5 +4,6 @@
 	"ANDROID_DEBUG_UI_MAC": "Google Chrome",
 	"USE_POD_SANDBOX": false,
 	"DISABLE_HOOKS": false,
-	"GA_TRACKING_ID": "UA-111455-44"
+	"GA_MEASUREMENT_ID": "G-T4P12SN9HJ",
+	"GA_API_SECRET": "I1m5adz4TrW2a1AX279pMA"
 }

package/config/test-deps-versions-generated.json

@@ -3,7 +3,7 @@
   "karma": "6.4.4",
   "karma-coverage": "2.2.1",
   "karma-nativescript-launcher": "1.0.0",
-  "mocha": "11.7.6",
+  "mocha": "11.8.0",
   "karma-mocha": "2.0.1",
   "karma-chai": "0.1.0",
   "karma-jasmine": "4.0.2",

package/contracts/package.json

@@ -0,0 +1,4 @@
+{
+	"main": "../lib/contracts/index.js",
+	"types": "../lib/contracts/index.d.ts"
+}

package/docs/man_pages/project/testing/build-android.md

@@ -13,7 +13,7 @@ Builds the project for Android and produces an APK that you can manually deploy
 
 Usage | Synopsis
 ---|---
-General | `$ ns build android [--compileSdk <API Level>] [--key-store-path <File Path> --key-store-password <Password> --key-store-alias <Name> --key-store-alias-password <Password>] [--release] [--static-bindings] [--copy-to <File Path>] [--env.*]] [--aab]`
+General | `$ ns build android [--compileSdk <API Level>] [--key-store-path <File Path> --key-store-password <Password> --key-store-alias <Name> --key-store-alias-password <Password>] [--release] [--copy-to <File Path>] [--env.*]] [--aab]`
 
 ### Options
 

package/lib/android-tools-info.d.ts

@@ -0,0 +1,19 @@
+import { IAndroidToolsInfo, IOptions, IAndroidToolsInfoData, IAndroidToolsInfoValidateInput, IAndroidToolsInfoOptions } from "./declarations";
+import { IErrors, IProjectDir } from "./common/declarations";
+export declare class AndroidToolsInfo implements IAndroidToolsInfo {
+    private $errors;
+    private $logger;
+    private $options;
+    protected $staticConfig: Config.IStaticConfig;
+    constructor($errors: IErrors, $logger: ILogger, $options: IOptions, $staticConfig: Config.IStaticConfig);
+    getToolsInfo(config: IProjectDir): IAndroidToolsInfoData;
+    validateInfo(options?: IAndroidToolsInfoValidateInput): boolean;
+    validateTargetSdk(options: IAndroidToolsInfoOptions): boolean;
+    validateJavacVersion(installedJavacVersion: string, options?: IAndroidToolsInfoOptions): boolean;
+    getPathToAdbFromAndroidHome(): Promise<string>;
+    validateAndroidHomeEnvVariable(options?: IAndroidToolsInfoOptions): boolean;
+    private shouldGenerateTypings;
+    private printMessage;
+    private getCompileSdkVersion;
+    private getTargetSdk;
+}

package/lib/base-package-manager.d.ts

@@ -0,0 +1,28 @@
+import { INodePackageManager, INodePackageManagerInstallOptions, INpmInstallResultInfo, INpmsResult, INpmPackageNameParts } from "./declarations";
+import { IDictionary, IChildProcess, IFileSystem, IHostInfo } from "./common/declarations";
+export declare abstract class BasePackageManager implements INodePackageManager {
+    protected $childProcess: IChildProcess;
+    protected $fs: IFileSystem;
+    private $hostInfo;
+    private $pacoteService;
+    private packageManager;
+    abstract install(packageName: string, pathToSave: string, config: INodePackageManagerInstallOptions): Promise<INpmInstallResultInfo>;
+    abstract uninstall(packageName: string, config?: IDictionary<string | boolean>, path?: string): Promise<string>;
+    abstract view(packageName: string, config: Object): Promise<any>;
+    abstract search(filter: string[], config: IDictionary<string | boolean>): Promise<string>;
+    abstract searchNpms(keyword: string): Promise<INpmsResult>;
+    abstract getRegistryPackageData(packageName: string): Promise<any>;
+    abstract getCachePath(): Promise<string>;
+    constructor($childProcess: IChildProcess, $fs: IFileSystem, $hostInfo: IHostInfo, $pacoteService: IPacoteService, packageManager: string);
+    isRegistered(packageName: string): Promise<boolean>;
+    getPackageNameParts(fullPackageName: string): Promise<INpmPackageNameParts>;
+    getPackageFullName(packageNameParts: INpmPackageNameParts): Promise<string>;
+    protected getPackageManagerExecutableName(): string;
+    protected processPackageManagerInstall(packageName: string, params: string[], opts: {
+        cwd: string;
+        isInstallingAllDependencies: boolean;
+    }): Promise<INpmInstallResultInfo>;
+    protected getFlagsString(config: any, asArray: boolean): any;
+    private isTgz;
+    private isURL;
+}

package/lib/bootstrap.js

@@ -28,6 +28,7 @@ yok_1.injector.require("iOSProvisionService", "./services/ios-provision-service"
 yok_1.injector.require("xcconfigService", "./services/xcconfig-service");
 yok_1.injector.require("iOSSigningService", "./services/ios/ios-signing-service");
 yok_1.injector.require("spmService", "./services/ios/spm-service");
+yok_1.injector.require("spmPbxprojService", "./services/ios/spm-pbxproj-service");
 yok_1.injector.require("xcodebuildArgsService", "./services/ios/xcodebuild-args-service");
 yok_1.injector.require("xcodebuildCommandService", "./services/ios/xcodebuild-command-service");
 yok_1.injector.require("xcodebuildService", "./services/ios/xcodebuild-service");
@@ -210,5 +211,5 @@ yok_1.injector.requireCommand([
     "native|add|swift",
     "native|add|objective-c",
 ], "./commands/native-add");
-yok_1.injector.requireCommand(["widget", "widget|ios"], "./commands/widget");
+yok_1.injector.requireCommand(["widget|ios"], "./commands/widget");
 require("./key-commands/bootstrap");

package/lib/bun-package-manager.d.ts

@@ -0,0 +1,16 @@
+import { BasePackageManager } from "./base-package-manager";
+import { INodePackageManagerInstallOptions, INpmInstallResultInfo, INpmsResult } from "./declarations";
+import { IChildProcess, IErrors, IFileSystem, IHostInfo, Server } from "./common/declarations";
+export declare class BunPackageManager extends BasePackageManager {
+    private $errors;
+    private $logger;
+    private $httpClient;
+    constructor($childProcess: IChildProcess, $errors: IErrors, $fs: IFileSystem, $hostInfo: IHostInfo, $logger: ILogger, $httpClient: Server.IHttpClient, $pacoteService: IPacoteService);
+    install(packageName: string, pathToSave: string, config: INodePackageManagerInstallOptions): Promise<INpmInstallResultInfo>;
+    uninstall(packageName: string, config?: any, cwd?: string): Promise<string>;
+    view(packageName: string, config: Object): Promise<any>;
+    search(filter: string[], config: any): Promise<string>;
+    searchNpms(keyword: string): Promise<INpmsResult>;
+    getRegistryPackageData(packageName: string): Promise<any>;
+    getCachePath(): Promise<string>;
+}

package/lib/color.d.ts

@@ -0,0 +1,39 @@
+import { styleText } from "node:util";
+export type StyleFormat = "reset" | "bold" | "dim" | "italic" | "underline" | "blink" | "inverse" | "hidden" | "strikethrough" | "doubleunderline" | "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white" | "gray" | "redBright" | "greenBright" | "yellowBright" | "blueBright" | "magentaBright" | "cyanBright" | "whiteBright" | "bgBlack" | "bgRed" | "bgGreen" | "bgYellow" | "bgBlue" | "bgMagenta" | "bgCyan" | "bgWhite" | "bgGray" | "bgRedBright" | "bgGreenBright" | "bgYellowBright" | "bgBlueBright" | "bgMagentaBright" | "bgCyanBright" | "bgWhiteBright";
+export type Color = StyleFormat;
+export declare const color: {
+    reset: (text: string) => string;
+    bold: (text: string) => string;
+    dim: (text: string) => string;
+    italic: (text: string) => string;
+    underline: (text: string) => string;
+    inverse: (text: string) => string;
+    hidden: (text: string) => string;
+    strikethrough: (text: string) => string;
+    black: (text: string) => string;
+    red: (text: string) => string;
+    blue: (text: string) => string;
+    magenta: (text: string) => string;
+    cyan: (text: string) => string;
+    white: (text: string) => string;
+    gray: (text: string) => string;
+    yellow: (text: string) => string;
+    green: (text: string) => string;
+    grey: (text: string) => string;
+    bgBlack: (text: string) => string;
+    bgBlackBright: (text: string) => string;
+    bgRed: (text: string) => string;
+    bgGreen: (text: string) => string;
+    bgYellow: (text: string) => string;
+    bgBlue: (text: string) => string;
+    bgMagenta: (text: string) => string;
+    bgCyan: (text: string) => string;
+    bgWhite: (text: string) => string;
+    cyanBright: (text: string) => string;
+    whiteBright: (text: string) => string;
+    greenBright: (text: string) => string;
+    yellowBright: (text: string) => string;
+    redBright: (text: string) => string;
+    styleText: typeof styleText;
+};
+export declare const stripColors: (text: string) => string;

package/lib/commands/add-platform.d.ts

@@ -0,0 +1,14 @@
+import { ValidatePlatformCommandBase } from "./command-base";
+import { IProjectData } from "../definitions/project";
+import { IOptions, IPlatformCommandHelper, IPlatformValidationService } from "../declarations";
+import { IPlatformsDataService } from "../definitions/platform";
+import { ICommandParameter, ICommand } from "../common/definitions/commands";
+import { IErrors } from "../common/declarations";
+export declare class AddPlatformCommand extends ValidatePlatformCommandBase implements ICommand {
+    private $platformCommandHelper;
+    private $errors;
+    allowedParameters: ICommandParameter[];
+    constructor($options: IOptions, $platformCommandHelper: IPlatformCommandHelper, $platformValidationService: IPlatformValidationService, $projectData: IProjectData, $platformsDataService: IPlatformsDataService, $errors: IErrors);
+    execute(args: string[]): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+}

package/lib/commands/apple-login.d.ts

@@ -0,0 +1,14 @@
+import { ICommand, ICommandParameter } from "../common/definitions/commands";
+import { IErrors } from "../common/declarations";
+import { IInjector } from "../common/definitions/yok";
+import { IApplePortalSessionService } from "../services/apple-portal/definitions";
+export declare class AppleLogin implements ICommand {
+    private $applePortalSessionService;
+    private $errors;
+    private $injector;
+    private $logger;
+    private $prompter;
+    allowedParameters: ICommandParameter[];
+    constructor($applePortalSessionService: IApplePortalSessionService, $errors: IErrors, $injector: IInjector, $logger: ILogger, $prompter: IPrompter);
+    execute(args: string[]): Promise<void>;
+}

package/lib/commands/appstore-list.d.ts

@@ -0,0 +1,21 @@
+import { IProjectData } from "../definitions/project";
+import { IPlatformValidationService, IOptions } from "../declarations";
+import { ICommand, ICommandParameter } from "../common/definitions/commands";
+import { IInjector } from "../common/definitions/yok";
+import { IErrors } from "../common/declarations";
+import { IApplePortalApplicationService, IApplePortalSessionService } from "../services/apple-portal/definitions";
+export declare class ListiOSApps implements ICommand {
+    private $injector;
+    private $applePortalApplicationService;
+    private $applePortalSessionService;
+    private $logger;
+    private $projectData;
+    private $devicePlatformsConstants;
+    private $platformValidationService;
+    private $errors;
+    private $prompter;
+    private $options;
+    allowedParameters: ICommandParameter[];
+    constructor($injector: IInjector, $applePortalApplicationService: IApplePortalApplicationService, $applePortalSessionService: IApplePortalSessionService, $logger: ILogger, $projectData: IProjectData, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $platformValidationService: IPlatformValidationService, $errors: IErrors, $prompter: IPrompter, $options: IOptions);
+    execute(args: string[]): Promise<void>;
+}

package/lib/commands/appstore-upload.d.ts

@@ -0,0 +1,25 @@
+import { BuildController } from "../controllers/build-controller";
+import { IProjectData } from "../definitions/project";
+import { IITMSTransporterService, IOptions, IPlatformValidationService } from "../declarations";
+import { ICommand, ICommandParameter } from "../common/definitions/commands";
+import { IInjector } from "../common/definitions/yok";
+import { IHostInfo, IErrors } from "../common/declarations";
+import { IApplePortalSessionService } from "../services/apple-portal/definitions";
+export declare class PublishIOS implements ICommand {
+    private $applePortalSessionService;
+    private $injector;
+    private $itmsTransporterService;
+    private $logger;
+    private $projectData;
+    private $options;
+    private $prompter;
+    private $devicePlatformsConstants;
+    private $hostInfo;
+    private $errors;
+    private $buildController;
+    private $platformValidationService;
+    allowedParameters: ICommandParameter[];
+    constructor($applePortalSessionService: IApplePortalSessionService, $injector: IInjector, $itmsTransporterService: IITMSTransporterService, $logger: ILogger, $projectData: IProjectData, $options: IOptions, $prompter: IPrompter, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $hostInfo: IHostInfo, $errors: IErrors, $buildController: BuildController, $platformValidationService: IPlatformValidationService);
+    execute(args: string[]): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+}

package/lib/commands/build.d.ts

@@ -0,0 +1,58 @@
+import { ValidatePlatformCommandBase } from "./command-base";
+import { IProjectData } from "../definitions/project";
+import { IOptions, IPlatformValidationService, IAndroidBundleValidatorHelper } from "../declarations";
+import { IPlatformsDataService } from "../definitions/platform";
+import { IBuildController, IBuildDataService } from "../definitions/build";
+import { IMigrateController } from "../definitions/migrate";
+import { IErrors } from "../common/declarations";
+import { OptionType } from "../common/enums";
+import { ICommandParameter, ICommand } from "../common/definitions/commands";
+export declare abstract class BuildCommandBase extends ValidatePlatformCommandBase {
+    protected $errors: IErrors;
+    protected $devicePlatformsConstants: Mobile.IDevicePlatformsConstants;
+    protected $buildController: IBuildController;
+    private $buildDataService;
+    protected $logger: ILogger;
+    constructor($options: IOptions, $errors: IErrors, $projectData: IProjectData, $platformsDataService: IPlatformsDataService, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $buildController: IBuildController, $platformValidationService: IPlatformValidationService, $buildDataService: IBuildDataService, $logger: ILogger);
+    dashedOptions: {
+        watch: {
+            type: OptionType;
+            default: boolean;
+            hasSensitiveValue: boolean;
+        };
+        hmr: {
+            type: OptionType;
+            default: boolean;
+            hasSensitiveValue: boolean;
+        };
+    };
+    executeCore(args: string[]): Promise<string>;
+    protected validatePlatform(platform: string): void;
+    protected validateArgs(args: string[], platform: string): Promise<boolean>;
+}
+export declare class BuildIosCommand extends BuildCommandBase implements ICommand {
+    protected $options: IOptions;
+    protected $migrateController: IMigrateController;
+    allowedParameters: ICommandParameter[];
+    constructor($options: IOptions, $errors: IErrors, $projectData: IProjectData, $platformsDataService: IPlatformsDataService, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $buildController: IBuildController, $platformValidationService: IPlatformValidationService, $logger: ILogger, $buildDataService: IBuildDataService, $migrateController: IMigrateController);
+    execute(args: string[]): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+}
+export declare class BuildAndroidCommand extends BuildCommandBase implements ICommand {
+    protected $options: IOptions;
+    protected $errors: IErrors;
+    protected $androidBundleValidatorHelper: IAndroidBundleValidatorHelper;
+    protected $logger: ILogger;
+    private $migrateController;
+    allowedParameters: ICommandParameter[];
+    constructor($options: IOptions, $errors: IErrors, $projectData: IProjectData, platformsDataService: IPlatformsDataService, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $buildController: IBuildController, $platformValidationService: IPlatformValidationService, $androidBundleValidatorHelper: IAndroidBundleValidatorHelper, $buildDataService: IBuildDataService, $logger: ILogger, $migrateController: IMigrateController);
+    execute(args: string[]): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+}
+export declare class BuildVisionOsCommand extends BuildIosCommand implements ICommand {
+    protected $options: IOptions;
+    protected $migrateController: IMigrateController;
+    constructor($options: IOptions, $errors: IErrors, $projectData: IProjectData, $platformsDataService: IPlatformsDataService, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $buildController: IBuildController, $platformValidationService: IPlatformValidationService, $logger: ILogger, $buildDataService: IBuildDataService, $migrateController: IMigrateController);
+    execute(args: string[]): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+}

package/lib/commands/clean.d.ts

@@ -0,0 +1,21 @@
+import { ICommand, ICommandParameter } from "../common/definitions/commands";
+import { IProjectCleanupService, IProjectConfigService, IProjectService } from "../definitions/project";
+import { IOptions, IStaticConfig } from "../declarations";
+import { ITerminalSpinnerService } from "../definitions/terminal-spinner-service";
+import { IChildProcess } from "../common/declarations";
+export declare class CleanCommand implements ICommand {
+    private $projectCleanupService;
+    private $projectConfigService;
+    private $terminalSpinnerService;
+    private $projectService;
+    private $prompter;
+    private $logger;
+    private $options;
+    private $childProcess;
+    private $staticConfig;
+    allowedParameters: ICommandParameter[];
+    constructor($projectCleanupService: IProjectCleanupService, $projectConfigService: IProjectConfigService, $terminalSpinnerService: ITerminalSpinnerService, $projectService: IProjectService, $prompter: IPrompter, $logger: ILogger, $options: IOptions, $childProcess: IChildProcess, $staticConfig: IStaticConfig);
+    execute(args: string[]): Promise<void>;
+    private cleanMultipleProjects;
+    private getNSProjectPathsInDirectory;
+}

package/lib/commands/command-base.d.ts

@@ -0,0 +1,16 @@
+import { IProjectData } from "../definitions/project";
+import { IOptions, IPlatformValidationService } from "../declarations";
+import { IPlatformsDataService } from "../definitions/platform";
+import { ICommandParameter, ICanExecuteCommandOptions } from "../common/definitions/commands";
+export declare abstract class ValidatePlatformCommandBase {
+    protected $options: IOptions;
+    protected $platformsDataService: IPlatformsDataService;
+    protected $platformValidationService: IPlatformValidationService;
+    protected $projectData: IProjectData;
+    constructor($options: IOptions, $platformsDataService: IPlatformsDataService, $platformValidationService: IPlatformValidationService, $projectData: IProjectData);
+    abstract allowedParameters: ICommandParameter[];
+    abstract execute(args: string[]): Promise<void>;
+    canExecuteCommandBase(platform: string, options?: ICanExecuteCommandOptions): Promise<boolean>;
+    private validatePlatformBase;
+    private canExecuteCommand;
+}

package/lib/commands/config.d.ts

@@ -0,0 +1,30 @@
+import { ICommand, ICommandParameter } from "../common/definitions/commands";
+import { IProjectConfigService } from "../definitions/project";
+import { IErrors } from "../common/declarations";
+export declare class ConfigListCommand implements ICommand {
+    private $projectConfigService;
+    private $logger;
+    allowedParameters: ICommandParameter[];
+    constructor($projectConfigService: IProjectConfigService, $logger: ILogger);
+    execute(args: string[]): Promise<void>;
+    private getValueString;
+}
+export declare class ConfigGetCommand implements ICommand {
+    private $projectConfigService;
+    private $logger;
+    private $errors;
+    allowedParameters: ICommandParameter[];
+    constructor($projectConfigService: IProjectConfigService, $logger: ILogger, $errors: IErrors);
+    execute(args: string[]): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+}
+export declare class ConfigSetCommand implements ICommand {
+    private $projectConfigService;
+    private $logger;
+    private $errors;
+    allowedParameters: ICommandParameter[];
+    constructor($projectConfigService: IProjectConfigService, $logger: ILogger, $errors: IErrors);
+    execute(args: string[]): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+    private getConvertedValue;
+}

package/lib/commands/create-project.d.ts

@@ -0,0 +1,42 @@
+import { IProjectService } from "../definitions/project";
+import { IOptions } from "../declarations";
+import { ICommand, ICommandParameter } from "../common/definitions/commands";
+import { IErrors } from "../common/declarations";
+export declare class CreateProjectCommand implements ICommand {
+    private $projectService;
+    private $logger;
+    private $errors;
+    private $options;
+    private $prompter;
+    private $stringParameter;
+    enableHooks: boolean;
+    allowedParameters: ICommandParameter[];
+    private static BlankTemplateKey;
+    private static BlankTemplateDescription;
+    private static BlankTsTemplateKey;
+    private static BlankTsTemplateDescription;
+    private static BlankVisionTemplateKey;
+    private static BlankVisionTemplateDescription;
+    private static HelloWorldTemplateKey;
+    private static HelloWorldTemplateDescription;
+    private static DrawerTemplateKey;
+    private static DrawerTemplateDescription;
+    private static TabsTemplateKey;
+    private static TabsTemplateDescription;
+    private isInteractionIntroShown;
+    private createdProjectData;
+    constructor($projectService: IProjectService, $logger: ILogger, $errors: IErrors, $options: IOptions, $prompter: IPrompter, $stringParameter: ICommandParameter);
+    execute(args: string[]): Promise<void>;
+    private interactiveFlavorAndTemplateSelection;
+    private interactiveFlavorSelection;
+    private printInteractiveCreationIntroIfNeeded;
+    private interactiveTemplateSelection;
+    private getJsTemplates;
+    private getTsTemplates;
+    private getNgTemplates;
+    private getReactTemplates;
+    private getSolidTemplates;
+    private getSvelteTemplates;
+    private getVueTemplates;
+    postCommandAction(args: string[]): Promise<void>;
+}

package/lib/commands/debug.d.ts

@@ -0,0 +1,53 @@
+import { ValidatePlatformCommandBase } from "./command-base";
+import { IProjectData } from "../definitions/project";
+import { IPlatformValidationService, IOptions } from "../declarations";
+import { IPlatformsDataService } from "../definitions/platform";
+import { IDebugDataService, IDebugController } from "../definitions/debug";
+import { IMigrateController } from "../definitions/migrate";
+import { ICommandParameter, ICommand } from "../common/definitions/commands";
+import { IErrors, ISysInfo } from "../common/declarations";
+import { ICleanupService } from "../definitions/cleanup-service";
+import { IInjector } from "../common/definitions/yok";
+export declare class DebugPlatformCommand extends ValidatePlatformCommandBase implements ICommand {
+    private platform;
+    protected $devicesService: Mobile.IDevicesService;
+    protected $logger: ILogger;
+    protected $errors: IErrors;
+    private $debugDataService;
+    private $debugController;
+    private $liveSyncCommandHelper;
+    private $migrateController;
+    allowedParameters: ICommandParameter[];
+    constructor(platform: string, $devicesService: Mobile.IDevicesService, $platformValidationService: IPlatformValidationService, $projectData: IProjectData, $options: IOptions, $platformsDataService: IPlatformsDataService, $cleanupService: ICleanupService, $logger: ILogger, $errors: IErrors, $debugDataService: IDebugDataService, $debugController: IDebugController, $liveSyncCommandHelper: ILiveSyncCommandHelper, $migrateController: IMigrateController);
+    execute(args: string[]): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+}
+export declare class DebugIOSCommand implements ICommand {
+    protected $errors: IErrors;
+    private $devicePlatformsConstants;
+    private $platformValidationService;
+    private $options;
+    private $injector;
+    private $sysInfo;
+    private $projectData;
+    private get debugPlatformCommand();
+    allowedParameters: ICommandParameter[];
+    constructor($errors: IErrors, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $platformValidationService: IPlatformValidationService, $options: IOptions, $injector: IInjector, $sysInfo: ISysInfo, $projectData: IProjectData, $iosDeviceOperations: IIOSDeviceOperations, $iOSSimulatorLogProvider: Mobile.IiOSSimulatorLogProvider);
+    execute(args: string[]): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+    private isValidTimeoutOption;
+    platform: string;
+}
+export declare class DebugAndroidCommand implements ICommand {
+    protected $errors: IErrors;
+    private $devicePlatformsConstants;
+    private $injector;
+    private $projectData;
+    private $options;
+    private get debugPlatformCommand();
+    allowedParameters: ICommandParameter[];
+    constructor($errors: IErrors, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $injector: IInjector, $projectData: IProjectData, $options: IOptions);
+    execute(args: string[]): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+    platform: string;
+}

package/lib/commands/deploy.d.ts

@@ -0,0 +1,32 @@
+import { ValidatePlatformCommandBase } from "./command-base";
+import { DeployCommandHelper } from "../helpers/deploy-command-helper";
+import { IProjectData } from "../definitions/project";
+import { IPlatformValidationService, IOptions } from "../declarations";
+import { IPlatformsDataService } from "../definitions/platform";
+import { IMigrateController } from "../definitions/migrate";
+import { ICommand, ICommandParameter } from "../common/definitions/commands";
+import { IErrors } from "../common/declarations";
+import { OptionType } from "../common/enums";
+export declare class DeployOnDeviceCommand extends ValidatePlatformCommandBase implements ICommand {
+    private $platformCommandParameter;
+    private $errors;
+    private $mobileHelper;
+    private $deployCommandHelper;
+    private $migrateController;
+    allowedParameters: ICommandParameter[];
+    dashedOptions: {
+        watch: {
+            type: OptionType;
+            default: boolean;
+            hasSensitiveValue: boolean;
+        };
+        hmr: {
+            type: OptionType;
+            default: boolean;
+            hasSensitiveValue: boolean;
+        };
+    };
+    constructor($platformValidationService: IPlatformValidationService, $platformCommandParameter: ICommandParameter, $options: IOptions, $projectData: IProjectData, $errors: IErrors, $mobileHelper: Mobile.IMobileHelper, $platformsDataService: IPlatformsDataService, $deployCommandHelper: DeployCommandHelper, $migrateController: IMigrateController);
+    execute(args: string[]): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+}

package/lib/commands/embedding/embed.d.ts

@@ -0,0 +1,27 @@
+import { ICommand, ICommandParameter } from "../../common/definitions/commands";
+import { PrepareCommand } from "../prepare";
+import { PrepareController } from "../../controllers/prepare-controller";
+import { IOptions, IPlatformValidationService } from "../../declarations";
+import { IProjectConfigService, IProjectData } from "../../definitions/project";
+import { IPlatformsDataService } from "../../definitions/platform";
+import { PrepareDataService } from "../../services/prepare-data-service";
+import { IMigrateController } from "../../definitions/migrate";
+import { IFileSystem } from "../../common/declarations";
+export declare class EmbedCommand extends PrepareCommand implements ICommand {
+    $options: IOptions;
+    $prepareController: PrepareController;
+    $platformValidationService: IPlatformValidationService;
+    $projectData: IProjectData;
+    $platformCommandParameter: ICommandParameter;
+    $platformsDataService: IPlatformsDataService;
+    $prepareDataService: PrepareDataService;
+    $migrateController: IMigrateController;
+    private $logger;
+    private $fs;
+    private $projectConfigService;
+    constructor($options: IOptions, $prepareController: PrepareController, $platformValidationService: IPlatformValidationService, $projectData: IProjectData, $platformCommandParameter: ICommandParameter, $platformsDataService: IPlatformsDataService, $prepareDataService: PrepareDataService, $migrateController: IMigrateController, $logger: ILogger, $fs: IFileSystem, $projectConfigService: IProjectConfigService);
+    private resolveHostProjectPath;
+    execute(args: string[]): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+    private getEmbedConfigForKey;
+}

package/lib/commands/extensibility/install-extension.d.ts

@@ -0,0 +1,10 @@
+import { ICommand, IStringParameterBuilder, ICommandParameter } from "../../common/definitions/commands";
+import { IExtensibilityService } from "../../common/definitions/extensibility";
+export declare class InstallExtensionCommand implements ICommand {
+    private $extensibilityService;
+    private $stringParameterBuilder;
+    private $logger;
+    constructor($extensibilityService: IExtensibilityService, $stringParameterBuilder: IStringParameterBuilder, $logger: ILogger);
+    execute(args: string[]): Promise<void>;
+    allowedParameters: ICommandParameter[];
+}

package/lib/commands/extensibility/list-extensions.d.ts

@@ -0,0 +1,9 @@
+import { ICommand, ICommandParameter } from "../../common/definitions/commands";
+import { IExtensibilityService } from "../../common/definitions/extensibility";
+export declare class ListExtensionsCommand implements ICommand {
+    private $extensibilityService;
+    private $logger;
+    constructor($extensibilityService: IExtensibilityService, $logger: ILogger);
+    execute(args: string[]): Promise<void>;
+    allowedParameters: ICommandParameter[];
+}

package/lib/commands/extensibility/uninstall-extension.d.ts

@@ -0,0 +1,10 @@
+import { ICommand, IStringParameterBuilder, ICommandParameter } from "../../common/definitions/commands";
+import { IExtensibilityService } from "../../common/definitions/extensibility";
+export declare class UninstallExtensionCommand implements ICommand {
+    private $extensibilityService;
+    private $stringParameterBuilder;
+    private $logger;
+    constructor($extensibilityService: IExtensibilityService, $stringParameterBuilder: IStringParameterBuilder, $logger: ILogger);
+    execute(args: string[]): Promise<void>;
+    allowedParameters: ICommandParameter[];
+}