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

package/lib/commands/fonts.d.ts

@@ -0,0 +1,12 @@
+import { IProjectConfigService, IProjectData } from "../definitions/project";
+import { ICommand, ICommandParameter } from "../common/definitions/commands";
+import { IFileSystem } from "../common/declarations";
+export declare class FontsCommand implements ICommand {
+    private $projectData;
+    private $fs;
+    private $logger;
+    private $projectConfigService;
+    allowedParameters: ICommandParameter[];
+    constructor($projectData: IProjectData, $fs: IFileSystem, $logger: ILogger, $projectConfigService: IProjectConfigService);
+    execute(args: string[]): Promise<void>;
+}

package/lib/commands/generate-assets.d.ts

@@ -0,0 +1,29 @@
+import { IProjectData } from "../definitions/project";
+import { IOptions, IAssetsGenerationService } from "../declarations";
+import { ICommand, ICommandParameter, IStringParameterBuilder } from "../common/definitions/commands";
+import { IInjector } from "../common/definitions/yok";
+export declare abstract class GenerateCommandBase implements ICommand {
+    protected $options: IOptions;
+    protected $injector: IInjector;
+    protected $projectData: IProjectData;
+    protected $stringParameterBuilder: IStringParameterBuilder;
+    protected $assetsGenerationService: IAssetsGenerationService;
+    allowedParameters: ICommandParameter[];
+    constructor($options: IOptions, $injector: IInjector, $projectData: IProjectData, $stringParameterBuilder: IStringParameterBuilder, $assetsGenerationService: IAssetsGenerationService);
+    execute(args: string[]): Promise<void>;
+    protected abstract generate(imagePath: string, background?: string): Promise<void>;
+}
+export declare class GenerateIconsCommand extends GenerateCommandBase implements ICommand {
+    protected $options: IOptions;
+    protected $projectData: IProjectData;
+    protected $stringParameterBuilder: IStringParameterBuilder;
+    constructor($options: IOptions, $injector: IInjector, $projectData: IProjectData, $stringParameterBuilder: IStringParameterBuilder, $assetsGenerationService: IAssetsGenerationService);
+    protected generate(imagePath: string, background?: string): Promise<void>;
+}
+export declare class GenerateSplashScreensCommand extends GenerateCommandBase implements ICommand {
+    protected $options: IOptions;
+    protected $projectData: IProjectData;
+    protected $stringParameterBuilder: IStringParameterBuilder;
+    constructor($options: IOptions, $injector: IInjector, $projectData: IProjectData, $stringParameterBuilder: IStringParameterBuilder, $assetsGenerationService: IAssetsGenerationService);
+    protected generate(imagePath: string, background?: string): Promise<void>;
+}

package/lib/commands/generate-help.d.ts

@@ -0,0 +1,8 @@
+import { ICommandParameter, ICommand } from "../common/definitions/commands";
+import { IHelpService } from "../common/declarations";
+export declare class GenerateHelpCommand implements ICommand {
+    private $helpService;
+    allowedParameters: ICommandParameter[];
+    constructor($helpService: IHelpService);
+    execute(args: string[]): Promise<void>;
+}

package/lib/commands/generate.d.ts

@@ -0,0 +1,12 @@
+import { ICommand, ICommandParameter } from "../common/definitions/commands";
+import { IErrors } from "../common/declarations";
+export declare class GenerateCommand implements ICommand {
+    private $logger;
+    private $errors;
+    allowedParameters: ICommandParameter[];
+    constructor($logger: ILogger, $errors: IErrors);
+    execute(_rawArgs: string[]): Promise<void>;
+    canExecute(rawArgs: string[]): Promise<boolean>;
+    private validateExecutionOptions;
+    private setExecutionOptions;
+}

package/lib/commands/hooks/common.d.ts

@@ -0,0 +1,22 @@
+import { IProjectData } from "../../definitions/project";
+import { IPluginData } from "../../definitions/plugins";
+import { ICommandParameter } from "../../common/definitions/commands";
+import { IErrors, IFileSystem } from "../../common/declarations";
+export declare const LOCK_FILE_NAME = "nativescript-lock.json";
+export interface OutputHook {
+    type: string;
+    hash: string;
+}
+export interface OutputPlugin {
+    name: string;
+    hooks: OutputHook[];
+}
+export declare class HooksVerify {
+    protected $projectData: IProjectData;
+    protected $errors: IErrors;
+    protected $fs: IFileSystem;
+    protected $logger: ILogger;
+    allowedParameters: ICommandParameter[];
+    constructor($projectData: IProjectData, $errors: IErrors, $fs: IFileSystem, $logger: ILogger);
+    protected verifyHooksLock(plugins: IPluginData[], hooksLockPath: string): Promise<void>;
+}

package/lib/commands/hooks/hooks-lock.d.ts

@@ -0,0 +1,24 @@
+import { IProjectData } from "../../definitions/project";
+import { IPluginsService } from "../../definitions/plugins";
+import { ICommand, ICommandParameter } from "../../common/definitions/commands";
+import { IErrors, IFileSystem } from "../../common/declarations";
+import { HooksVerify } from "./common";
+export declare class HooksLockPluginCommand implements ICommand {
+    private $pluginsService;
+    private $projectData;
+    private $errors;
+    private $fs;
+    private $logger;
+    allowedParameters: ICommandParameter[];
+    constructor($pluginsService: IPluginsService, $projectData: IProjectData, $errors: IErrors, $fs: IFileSystem, $logger: ILogger);
+    execute(): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+    private writeHooksLockFile;
+}
+export declare class HooksVerifyPluginCommand extends HooksVerify implements ICommand {
+    private $pluginsService;
+    allowedParameters: ICommandParameter[];
+    constructor($pluginsService: IPluginsService, $projectData: IProjectData, $errors: IErrors, $fs: IFileSystem, $logger: ILogger);
+    execute(): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+}

package/lib/commands/hooks/hooks.d.ts

@@ -0,0 +1,17 @@
+import { IProjectData } from "../../definitions/project";
+import { IPluginsService } from "../../definitions/plugins";
+import { ICommand, ICommandParameter } from "../../common/definitions/commands";
+import { IErrors, IFileSystem } from "../../common/declarations";
+import { HooksVerify } from "./common";
+export declare class HooksPluginCommand extends HooksVerify implements ICommand {
+    private $pluginsService;
+    allowedParameters: ICommandParameter[];
+    constructor($pluginsService: IPluginsService, $projectData: IProjectData, $errors: IErrors, $fs: IFileSystem, $logger: ILogger);
+    execute(args: string[]): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+}
+export declare class HooksListPluginCommand extends HooksPluginCommand {
+    allowedParameters: ICommandParameter[];
+    constructor($pluginsService: IPluginsService, $projectData: IProjectData, $errors: IErrors, $fs: IFileSystem, $logger: ILogger);
+    execute(): Promise<void>;
+}

package/lib/commands/info.d.ts

@@ -0,0 +1,8 @@
+import { IInfoService } from "../declarations";
+import { ICommand, ICommandParameter } from "../common/definitions/commands";
+export declare class InfoCommand implements ICommand {
+    private $infoService;
+    allowedParameters: ICommandParameter[];
+    constructor($infoService: IInfoService);
+    execute(args: string[]): Promise<void>;
+}

package/lib/commands/install.d.ts

@@ -0,0 +1,25 @@
+import { IProjectData, IProjectDataService } from "../definitions/project";
+import { IOptions, IPlatformCommandHelper, INodePackageManager } from "../declarations";
+import { IPlatformsDataService } from "../definitions/platform";
+import { IPluginsService } from "../definitions/plugins";
+import { ICommand, ICommandParameter } from "../common/definitions/commands";
+import { IFileSystem } from "../common/declarations";
+export declare class InstallCommand implements ICommand {
+    private $options;
+    private $mobileHelper;
+    private $platformsDataService;
+    private $platformCommandHelper;
+    private $projectData;
+    private $projectDataService;
+    private $pluginsService;
+    private $logger;
+    private $fs;
+    private $stringParameter;
+    private $packageManager;
+    enableHooks: boolean;
+    allowedParameters: ICommandParameter[];
+    constructor($options: IOptions, $mobileHelper: Mobile.IMobileHelper, $platformsDataService: IPlatformsDataService, $platformCommandHelper: IPlatformCommandHelper, $projectData: IProjectData, $projectDataService: IProjectDataService, $pluginsService: IPluginsService, $logger: ILogger, $fs: IFileSystem, $stringParameter: ICommandParameter, $packageManager: INodePackageManager);
+    execute(args: string[]): Promise<void>;
+    private installProjectDependencies;
+    private installModule;
+}

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

@@ -0,0 +1,11 @@
+import { IProjectData } from "../definitions/project";
+import { IPlatformCommandHelper } from "../declarations";
+import { ICommandParameter, ICommand } from "../common/definitions/commands";
+export declare class ListPlatformsCommand implements ICommand {
+    private $platformCommandHelper;
+    private $projectData;
+    private $logger;
+    allowedParameters: ICommandParameter[];
+    constructor($platformCommandHelper: IPlatformCommandHelper, $projectData: IProjectData, $logger: ILogger);
+    execute(args: string[]): Promise<void>;
+}

package/lib/commands/migrate.d.ts

@@ -0,0 +1,13 @@
+import { IProjectData } from "../definitions/project";
+import { IMigrateController } from "../definitions/migrate";
+import { ICommand, ICommandParameter } from "../common/definitions/commands";
+export declare class MigrateCommand implements ICommand {
+    private $devicePlatformsConstants;
+    private $migrateController;
+    private $staticConfig;
+    private $projectData;
+    private $logger;
+    allowedParameters: ICommandParameter[];
+    constructor($devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $migrateController: IMigrateController, $staticConfig: Config.IStaticConfig, $projectData: IProjectData, $logger: ILogger);
+    execute(args: string[]): Promise<void>;
+}

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

@@ -0,0 +1,49 @@
+import { IProjectData } from "../definitions/project";
+import { ICommandParameter, ICommand } from "../common/definitions/commands";
+import { IErrors } from "../common/declarations";
+export declare class NativeAddCommand implements ICommand {
+    protected $projectData: IProjectData;
+    protected $logger: ILogger;
+    protected $errors: IErrors;
+    allowedParameters: ICommandParameter[];
+    constructor($projectData: IProjectData, $logger: ILogger, $errors: IErrors);
+    execute(args: string[]): Promise<void>;
+    protected failWithUsage(): void;
+    canExecute(args: string[]): Promise<boolean>;
+    protected getIosSourcePathBase(): string;
+    protected getAndroidSourcePathBase(): string;
+}
+export declare class NativeAddSingleCommand extends NativeAddCommand {
+    constructor($projectData: IProjectData, $logger: ILogger, $errors: IErrors);
+    canExecute(args: string[]): Promise<boolean>;
+}
+export declare class NativeAddAndroidCommand extends NativeAddSingleCommand {
+    constructor($projectData: IProjectData, $logger: ILogger, $errors: IErrors);
+    private getPackageName;
+    private getClassSimpleName;
+    private generateJavaClassContent;
+    private generateKotlinClassContent;
+    doJavaKotlin(className: string, extension: string): void;
+    private checkAndUpdateGradleProperties;
+}
+export declare class NativeAddJavaCommand extends NativeAddAndroidCommand {
+    constructor($projectData: IProjectData, $logger: ILogger, $errors: IErrors);
+    execute(args: string[]): Promise<void>;
+}
+export declare class NativeAddKotlinCommand extends NativeAddAndroidCommand {
+    constructor($projectData: IProjectData, $logger: ILogger, $errors: IErrors);
+    execute(args: string[]): Promise<void>;
+}
+export declare class NativeAddObjectiveCCommand extends NativeAddSingleCommand {
+    constructor($projectData: IProjectData, $logger: ILogger, $errors: IErrors);
+    execute(args: string[]): Promise<void>;
+    private doObjectiveC;
+    private generateOrUpdateModuleMap;
+    private generateObjectiveCFiles;
+}
+export declare class NativeAddSwiftCommand extends NativeAddSingleCommand {
+    constructor($projectData: IProjectData, $logger: ILogger, $errors: IErrors);
+    execute(args: string[]): Promise<void>;
+    private doSwift;
+    private generateSwiftFile;
+}

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

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

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

@@ -0,0 +1,13 @@
+import { IProjectData } from "../../definitions/project";
+import { IPluginsService } from "../../definitions/plugins";
+import { ICommand, ICommandParameter } from "../../common/definitions/commands";
+import { IErrors } from "../../common/declarations";
+export declare class AddPluginCommand implements ICommand {
+    private $pluginsService;
+    private $projectData;
+    private $errors;
+    allowedParameters: ICommandParameter[];
+    constructor($pluginsService: IPluginsService, $projectData: IProjectData, $errors: IErrors);
+    execute(args: string[]): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+}

package/lib/commands/plugin/build-plugin.d.ts

@@ -0,0 +1,18 @@
+import { IOptions } from "../../declarations";
+import { IAndroidPluginBuildService } from "../../definitions/android-plugin-migrator";
+import { ICommand, ICommandParameter } from "../../common/definitions/commands";
+import { IErrors, IFileSystem } from "../../common/declarations";
+import { ITempService } from "../../definitions/temp-service";
+export declare class BuildPluginCommand implements ICommand {
+    private $androidPluginBuildService;
+    private $errors;
+    private $logger;
+    private $fs;
+    private $options;
+    private $tempService;
+    allowedParameters: ICommandParameter[];
+    pluginProjectPath: string;
+    constructor($androidPluginBuildService: IAndroidPluginBuildService, $errors: IErrors, $logger: ILogger, $fs: IFileSystem, $options: IOptions, $tempService: ITempService);
+    execute(args: string[]): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+}

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

@@ -0,0 +1,30 @@
+import { IOptions, INodePackageManager } from "../../declarations";
+import { ICommand, ICommandParameter } from "../../common/definitions/commands";
+import { IErrors, IFileSystem, IChildProcess } from "../../common/declarations";
+import { ITerminalSpinnerService } from "../../definitions/terminal-spinner-service";
+export declare class CreatePluginCommand implements ICommand {
+    private $options;
+    private $errors;
+    private $terminalSpinnerService;
+    private $logger;
+    private $pacoteService;
+    private $fs;
+    private $childProcess;
+    private $prompter;
+    private $packageManager;
+    allowedParameters: ICommandParameter[];
+    userMessage: string;
+    nameMessage: string;
+    includeTypeScriptDemoMessage: string;
+    includeAngularDemoMessage: string;
+    pathAlreadyExistsMessageTemplate: string;
+    constructor($options: IOptions, $errors: IErrors, $terminalSpinnerService: ITerminalSpinnerService, $logger: ILogger, $pacoteService: IPacoteService, $fs: IFileSystem, $childProcess: IChildProcess, $prompter: IPrompter, $packageManager: INodePackageManager);
+    execute(args: string[]): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+    private setupSeed;
+    private ensurePackageDir;
+    private downloadPackage;
+    private getGitHubUsername;
+    private getPluginNameSource;
+    private getShouldIncludeDemoResult;
+}

package/lib/commands/plugin/list-plugins.d.ts

@@ -0,0 +1,12 @@
+import { IProjectData } from "../../definitions/project";
+import { IPluginsService } from "../../definitions/plugins";
+import { ICommand, ICommandParameter } from "../../common/definitions/commands";
+export declare class ListPluginsCommand implements ICommand {
+    private $pluginsService;
+    private $projectData;
+    private $logger;
+    allowedParameters: ICommandParameter[];
+    constructor($pluginsService: IPluginsService, $projectData: IProjectData, $logger: ILogger);
+    execute(args: string[]): Promise<void>;
+    private createTableCells;
+}

package/lib/commands/plugin/remove-plugin.d.ts

@@ -0,0 +1,14 @@
+import { IProjectData } from "../../definitions/project";
+import { IPluginsService } from "../../definitions/plugins";
+import { ICommand, ICommandParameter } from "../../common/definitions/commands";
+import { IErrors } from "../../common/declarations";
+export declare class RemovePluginCommand implements ICommand {
+    private $pluginsService;
+    private $errors;
+    private $logger;
+    private $projectData;
+    allowedParameters: ICommandParameter[];
+    constructor($pluginsService: IPluginsService, $errors: IErrors, $logger: ILogger, $projectData: IProjectData);
+    execute(args: string[]): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+}

package/lib/commands/plugin/update-plugin.d.ts

@@ -0,0 +1,13 @@
+import { IProjectData } from "../../definitions/project";
+import { IPluginsService } from "../../definitions/plugins";
+import { ICommand, ICommandParameter } from "../../common/definitions/commands";
+import { IErrors } from "../../common/declarations";
+export declare class UpdatePluginCommand implements ICommand {
+    private $pluginsService;
+    private $projectData;
+    private $errors;
+    constructor($pluginsService: IPluginsService, $projectData: IProjectData, $errors: IErrors);
+    execute(args: string[]): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+    allowedParameters: ICommandParameter[];
+}

package/lib/commands/post-install.d.ts

@@ -0,0 +1,16 @@
+import { ICommand, ICommandParameter } from "../common/definitions/commands";
+import { IFileSystem, IHelpService, ISettingsService, IAnalyticsService, IHostInfo } from "../common/declarations";
+export declare class PostInstallCliCommand implements ICommand {
+    private $fs;
+    private $commandsService;
+    private $helpService;
+    private $settingsService;
+    private $analyticsService;
+    private $logger;
+    private $hostInfo;
+    constructor($fs: IFileSystem, $commandsService: ICommandsService, $helpService: IHelpService, $settingsService: ISettingsService, $analyticsService: IAnalyticsService, $logger: ILogger, $hostInfo: IHostInfo);
+    disableAnalytics: boolean;
+    allowedParameters: ICommandParameter[];
+    execute(args: string[]): Promise<void>;
+    postCommandAction(args: string[]): Promise<void>;
+}

package/lib/commands/prepare.d.ts

@@ -0,0 +1,40 @@
+import { ValidatePlatformCommandBase } from "./command-base";
+import { PrepareController } from "../controllers/prepare-controller";
+import { PrepareDataService } from "../services/prepare-data-service";
+import { IProjectData } from "../definitions/project";
+import { IOptions, IPlatformValidationService } from "../declarations";
+import { IPlatformsDataService } from "../definitions/platform";
+import { IMigrateController } from "../definitions/migrate";
+import { ICommand, ICommandParameter } from "../common/definitions/commands";
+import { OptionType } from "../common/enums";
+export declare class PrepareCommand extends ValidatePlatformCommandBase implements ICommand {
+    $options: IOptions;
+    $prepareController: PrepareController;
+    $platformValidationService: IPlatformValidationService;
+    $projectData: IProjectData;
+    $platformCommandParameter: ICommandParameter;
+    $platformsDataService: IPlatformsDataService;
+    $prepareDataService: PrepareDataService;
+    $migrateController: IMigrateController;
+    allowedParameters: ICommandParameter[];
+    dashedOptions: {
+        watch: {
+            type: OptionType;
+            default: boolean;
+            hasSensitiveValue: boolean;
+        };
+        hmr: {
+            type: OptionType;
+            default: boolean;
+            hasSensitiveValue: boolean;
+        };
+        skipNative: {
+            type: OptionType;
+            default: boolean;
+            hasSensitiveValue: boolean;
+        };
+    };
+    constructor($options: IOptions, $prepareController: PrepareController, $platformValidationService: IPlatformValidationService, $projectData: IProjectData, $platformCommandParameter: ICommandParameter, $platformsDataService: IPlatformsDataService, $prepareDataService: PrepareDataService, $migrateController: IMigrateController);
+    execute(args: string[]): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+}

package/lib/commands/prepare.js

@@ -28,11 +28,6 @@ class PrepareCommand extends command_base_1.ValidatePlatformCommandBase {
                 default: false,
                 hasSensitiveValue: false,
             },
-            whatever: {
-                type: enums_1.OptionType.Boolean,
-                default: false,
-                hasSensitiveValue: false,
-            },
         };
         this.$projectData.initializeProjectData();
     }

package/lib/commands/preview.d.ts

@@ -0,0 +1,18 @@
+import { ICommandParameter, ICommand } from "../common/definitions/commands";
+import { IChildProcess, IErrors } from "../common/declarations";
+import { IOptions, IPackageManager } from "../declarations";
+import { IProjectData } from "../definitions/project";
+export declare class PreviewCommand implements ICommand {
+    private $logger;
+    private $errors;
+    private $projectData;
+    private $packageManager;
+    private $childProcess;
+    private $options;
+    allowedParameters: ICommandParameter[];
+    skipOptionsValidation: boolean;
+    constructor($logger: ILogger, $errors: IErrors, $projectData: IProjectData, $packageManager: IPackageManager, $childProcess: IChildProcess, $options: IOptions);
+    private getPreviewCLIPath;
+    execute(args: string[]): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+}

package/lib/commands/preview.js

@@ -16,6 +16,7 @@ class PreviewCommand {
         this.$childProcess = $childProcess;
         this.$options = $options;
         this.allowedParameters = [];
+        this.skipOptionsValidation = true;
     }
     getPreviewCLIPath() {
         return (0, resolve_package_path_1.resolvePackagePath)(PREVIEW_CLI_PACKAGE, {

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

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

package/lib/commands/resources/resources-update.d.ts

@@ -0,0 +1,13 @@
+import { IProjectData } from "../../definitions/project";
+import { IAndroidResourcesMigrationService } from "../../declarations";
+import { ICommand, ICommandParameter } from "../../common/definitions/commands";
+import { IErrors } from "../../common/declarations";
+export declare class ResourcesUpdateCommand implements ICommand {
+    private $projectData;
+    private $errors;
+    private $androidResourcesMigrationService;
+    allowedParameters: ICommandParameter[];
+    constructor($projectData: IProjectData, $errors: IErrors, $androidResourcesMigrationService: IAndroidResourcesMigrationService);
+    execute(args: string[]): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+}

package/lib/commands/run.d.ts

@@ -0,0 +1,61 @@
+import { IErrors, IHostInfo } from "../common/declarations";
+import { ICommand, ICommandParameter } from "../common/definitions/commands";
+import { IKeyCommandHelper } from "../common/definitions/key-commands";
+import { IInjector } from "../common/definitions/yok";
+import { IOptions, IPlatformValidationService } from "../declarations";
+import { IMigrateController } from "../definitions/migrate";
+import { IProjectData, IProjectDataService } from "../definitions/project";
+export declare class RunCommandBase implements ICommand {
+    private $devicePlatformsConstants;
+    private $errors;
+    private $hostInfo;
+    private $liveSyncCommandHelper;
+    private $migrateController;
+    private $options;
+    private $projectData;
+    private $keyCommandHelper;
+    private liveSyncCommandHelperAdditionalOptions;
+    platform: string;
+    constructor($devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $errors: IErrors, $hostInfo: IHostInfo, $liveSyncCommandHelper: ILiveSyncCommandHelper, $migrateController: IMigrateController, $options: IOptions, $projectData: IProjectData, $keyCommandHelper: IKeyCommandHelper);
+    allowedParameters: ICommandParameter[];
+    execute(args: string[]): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+}
+export declare class RunIosCommand implements ICommand {
+    protected $devicePlatformsConstants: Mobile.IDevicePlatformsConstants;
+    protected $errors: IErrors;
+    protected $injector: IInjector;
+    protected $options: IOptions;
+    protected $platformValidationService: IPlatformValidationService;
+    protected $projectDataService: IProjectDataService;
+    protected get runCommand(): RunCommandBase;
+    allowedParameters: ICommandParameter[];
+    get platform(): string;
+    constructor($devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $errors: IErrors, $injector: IInjector, $options: IOptions, $platformValidationService: IPlatformValidationService, $projectDataService: IProjectDataService);
+    execute(args: string[]): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+}
+export declare class RunAndroidCommand implements ICommand {
+    private $devicePlatformsConstants;
+    private $errors;
+    private $injector;
+    private $options;
+    private $platformValidationService;
+    private $projectData;
+    private get runCommand();
+    allowedParameters: ICommandParameter[];
+    get platform(): string;
+    constructor($devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $errors: IErrors, $injector: IInjector, $options: IOptions, $platformValidationService: IPlatformValidationService, $projectData: IProjectData);
+    execute(args: string[]): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+}
+export declare class RunVisionOSCommand extends RunIosCommand {
+    protected $devicePlatformsConstants: Mobile.IDevicePlatformsConstants;
+    protected $errors: IErrors;
+    protected $injector: IInjector;
+    protected $options: IOptions;
+    protected $platformValidationService: IPlatformValidationService;
+    protected $projectDataService: IProjectDataService;
+    get platform(): string;
+    constructor($devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $errors: IErrors, $injector: IInjector, $options: IOptions, $platformValidationService: IPlatformValidationService, $projectDataService: IProjectDataService);
+}

package/lib/commands/setup.d.ts

@@ -0,0 +1,8 @@
+import { ICommand, ICommandParameter } from "../common/definitions/commands";
+import { IDoctorService } from "../common/declarations";
+export declare class SetupCommand implements ICommand {
+    private $doctorService;
+    allowedParameters: ICommandParameter[];
+    constructor($doctorService: IDoctorService);
+    execute(args: string[]): Promise<any>;
+}

package/lib/commands/start.d.ts

@@ -0,0 +1,9 @@
+import { ICommand, ICommandParameter } from "../common/definitions/commands";
+import { IStartService } from "../definitions/start-service";
+export declare class StartCommand implements ICommand {
+    private $startService;
+    constructor($startService: IStartService);
+    execute(args: string[]): Promise<void>;
+    allowedParameters: ICommandParameter[];
+    canExecute?(args: string[]): Promise<boolean>;
+}

package/lib/commands/typings.d.ts

@@ -0,0 +1,22 @@
+import { IChildProcess, IFileSystem, IHostInfo } from "../common/declarations";
+import { ICommand, ICommandParameter } from "../common/definitions/commands";
+import { IOptions, IStaticConfig } from "../declarations";
+import { IProjectData } from "../definitions/project";
+export declare class TypingsCommand implements ICommand {
+    private $logger;
+    private $options;
+    private $fs;
+    private $projectData;
+    private $mobileHelper;
+    private $childProcess;
+    private $hostInfo;
+    private $staticConfig;
+    private $prompter;
+    allowedParameters: ICommandParameter[];
+    constructor($logger: ILogger, $options: IOptions, $fs: IFileSystem, $projectData: IProjectData, $mobileHelper: Mobile.IMobileHelper, $childProcess: IChildProcess, $hostInfo: IHostInfo, $staticConfig: IStaticConfig, $prompter: IPrompter);
+    execute(args: string[]): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+    private resolveGradleDependencies;
+    private handleAndroidTypings;
+    private handleiOSTypings;
+}

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

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