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

package/lib/commands/update.d.ts

@@ -0,0 +1,21 @@
+import { IProjectData } from "../definitions/project";
+import { IMigrateController } from "../definitions/migrate";
+import { IOptions } from "../declarations";
+import { ICommand, ICommandParameter } from "../common/definitions/commands";
+import { IErrors } from "../common/declarations";
+export declare class UpdateCommand implements ICommand {
+    private $devicePlatformsConstants;
+    private $updateController;
+    private $migrateController;
+    private $options;
+    private $errors;
+    private $logger;
+    private $projectData;
+    private $markingModeService;
+    allowedParameters: ICommandParameter[];
+    static readonly SHOULD_MIGRATE_PROJECT_MESSAGE = "This project is not compatible with the current NativeScript version and cannot be updated. Use \"ns migrate\" to make your project compatible.";
+    static readonly PROJECT_UP_TO_DATE_MESSAGE = "This project is up to date.";
+    constructor($devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $updateController: IUpdateController, $migrateController: IMigrateController, $options: IOptions, $errors: IErrors, $logger: ILogger, $projectData: IProjectData, $markingModeService: IMarkingModeService);
+    execute(args: string[]): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+}

package/lib/commands/widget.d.ts

@@ -0,0 +1,24 @@
+import { IProjectConfigService, IProjectData } from "../definitions/project";
+import { ICommandParameter, ICommand } from "../common/definitions/commands";
+import { IErrors } from "../common/declarations";
+export declare class WidgetCommand implements ICommand {
+    protected $projectData: IProjectData;
+    protected $projectConfigService: IProjectConfigService;
+    protected $logger: ILogger;
+    protected $errors: IErrors;
+    allowedParameters: ICommandParameter[];
+    constructor($projectData: IProjectData, $projectConfigService: IProjectConfigService, $logger: ILogger, $errors: IErrors);
+    execute(args: string[]): Promise<void>;
+    protected failWithUsage(): void;
+    canExecute(args: string[]): Promise<boolean>;
+    protected getIosSourcePathBase(): string;
+}
+export declare class WidgetIOSCommand extends WidgetCommand {
+    constructor($projectData: IProjectData, $projectConfigService: IProjectConfigService, $logger: ILogger, $errors: IErrors);
+    canExecute(args: string[]): Promise<boolean>;
+    execute(args: string[]): Promise<void>;
+    private startPrompt;
+    private generateSharedWidgetPackage;
+    private generateWidget;
+    private generateAppleUtility;
+}

package/lib/commands/widget.js

@@ -795,5 +795,4 @@ declare class AppleWidgetUtils extends NSObject {
     }
 }
 exports.WidgetIOSCommand = WidgetIOSCommand;
-yok_1.injector.registerCommand(["widget"], WidgetCommand);
 yok_1.injector.registerCommand(["widget|ios"], WidgetIOSCommand);

package/lib/common/child-process.d.ts

@@ -0,0 +1,17 @@
+import * as child_process from "child_process";
+import { EventEmitter } from "events";
+import { IChildProcess, IErrors, IExecOptions, ISpawnFromEventOptions, ISpawnResult } from "./declarations";
+export declare class ChildProcess extends EventEmitter implements IChildProcess {
+    private $logger;
+    private $errors;
+    constructor($logger: ILogger, $errors: IErrors);
+    exec(command: string, options?: any, execOptions?: IExecOptions): Promise<any>;
+    execFile(command: string, args: string[]): Promise<any>;
+    spawn(command: string, args?: string[], options?: any): child_process.ChildProcess;
+    fork(modulePath: string, args?: string[], options?: any): child_process.ChildProcess;
+    spawnFromEvent(command: string, args: string[], event: string, options?: any, spawnFromEventOptions?: ISpawnFromEventOptions): Promise<ISpawnResult>;
+    trySpawnFromCloseEvent(command: string, args: string[], options?: any, spawnFromEventOptions?: ISpawnFromEventOptions): Promise<ISpawnResult>;
+    tryExecuteApplication(command: string, args: string[], event: string, errorMessage: string, condition: (_childProcess: any) => boolean): Promise<any>;
+    private tryExecuteApplicationCore;
+    private getArgumentsAsQuotedString;
+}

package/lib/common/codeGeneration/code-entity.d.ts

@@ -0,0 +1,22 @@
+import { CodeGeneration } from "./code-generation";
+export declare enum CodeEntityType {
+    Line = 0,
+    Block = 1
+}
+export declare class Line implements CodeGeneration.ILine {
+    content: string;
+    constructor(content: string);
+    get codeEntityType(): CodeEntityType;
+    static create(content: string): CodeGeneration.ILine;
+}
+export declare class Block implements CodeGeneration.IBlock {
+    opener: string;
+    codeEntities: CodeGeneration.ICodeEntity[];
+    endingCharacter: string;
+    constructor(opener?: string);
+    get codeEntityType(): CodeEntityType;
+    addBlock(block: CodeGeneration.IBlock): void;
+    addLine(line: CodeGeneration.ILine): void;
+    addBlocks(blocks: CodeGeneration.IBlock[]): void;
+    writeLine(content: string): void;
+}

package/lib/common/codeGeneration/code-printer.d.ts

@@ -0,0 +1,10 @@
+import { CodeGeneration } from "./code-generation";
+export declare class CodePrinter {
+    private static INDENT_CHAR;
+    private static NEW_LINE_CHAR;
+    private static START_BLOCK_CHAR;
+    private static END_BLOCK_CHAR;
+    composeBlock(block: CodeGeneration.IBlock, indentSize?: number): string;
+    private getIndentation;
+    private composeLine;
+}

package/lib/common/command-params.d.ts

@@ -0,0 +1,14 @@
+import { ICommandParameter, IStringParameterBuilder } from "./definitions/commands";
+import { IInjector } from "./definitions/yok";
+export declare class StringCommandParameter implements ICommandParameter {
+    private $injector;
+    mandatory: boolean;
+    errorMessage: string;
+    constructor($injector: IInjector);
+    validate(validationValue: string): Promise<boolean>;
+}
+export declare class StringParameterBuilder implements IStringParameterBuilder {
+    private $injector;
+    constructor($injector: IInjector);
+    createMandatoryParameter(errorMsg: string): ICommandParameter;
+}

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

@@ -0,0 +1,30 @@
+import { IOptions } from "../../declarations";
+import { ICommandParameter, ICommand } from "../definitions/commands";
+import { IErrors, IAnalyticsService } from "../declarations";
+export declare class AnalyticsCommandParameter implements ICommandParameter {
+    private $errors;
+    constructor($errors: IErrors);
+    mandatory: boolean;
+    validate(validationValue: string): Promise<boolean>;
+}
+declare class AnalyticsCommand implements ICommand {
+    protected $analyticsService: IAnalyticsService;
+    private $logger;
+    private $errors;
+    private $options;
+    private settingName;
+    private humanReadableSettingName;
+    constructor($analyticsService: IAnalyticsService, $logger: ILogger, $errors: IErrors, $options: IOptions, settingName: string, humanReadableSettingName: string);
+    allowedParameters: AnalyticsCommandParameter[];
+    disableAnalytics: boolean;
+    execute(args: string[]): Promise<void>;
+}
+export declare class UsageReportingCommand extends AnalyticsCommand {
+    protected $analyticsService: IAnalyticsService;
+    constructor($analyticsService: IAnalyticsService, $logger: ILogger, $errors: IErrors, $options: IOptions, $staticConfig: Config.IStaticConfig);
+}
+export declare class ErrorReportingCommand extends AnalyticsCommand {
+    protected $analyticsService: IAnalyticsService;
+    constructor($analyticsService: IAnalyticsService, $logger: ILogger, $errors: IErrors, $options: IOptions, $staticConfig: Config.IStaticConfig);
+}
+export {};

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

@@ -0,0 +1,35 @@
+import { ICommandParameter, ICommand } from "../definitions/commands";
+import { IAutoCompletionService } from "../declarations";
+export declare class AutoCompleteCommand implements ICommand {
+    private $autoCompletionService;
+    private $logger;
+    private $prompter;
+    constructor($autoCompletionService: IAutoCompletionService, $logger: ILogger, $prompter: IPrompter);
+    disableAnalytics: boolean;
+    allowedParameters: ICommandParameter[];
+    execute(args: string[]): Promise<void>;
+}
+export declare class DisableAutoCompleteCommand implements ICommand {
+    private $autoCompletionService;
+    private $logger;
+    constructor($autoCompletionService: IAutoCompletionService, $logger: ILogger);
+    disableAnalytics: boolean;
+    allowedParameters: ICommandParameter[];
+    execute(args: string[]): Promise<void>;
+}
+export declare class EnableAutoCompleteCommand implements ICommand {
+    private $autoCompletionService;
+    private $logger;
+    constructor($autoCompletionService: IAutoCompletionService, $logger: ILogger);
+    disableAnalytics: boolean;
+    allowedParameters: ICommandParameter[];
+    execute(args: string[]): Promise<void>;
+}
+export declare class AutoCompleteStatusCommand implements ICommand {
+    private $autoCompletionService;
+    private $logger;
+    constructor($autoCompletionService: IAutoCompletionService, $logger: ILogger);
+    disableAnalytics: boolean;
+    allowedParameters: ICommandParameter[];
+    execute(args: string[]): Promise<void>;
+}

package/lib/common/commands/device/device-log-stream.d.ts

@@ -0,0 +1,16 @@
+import { IOptions } from "../../../declarations";
+import { ICommandParameter, ICommand } from "../../definitions/commands";
+import { ICleanupService } from "../../../definitions/cleanup-service";
+import { IErrors } from "../../declarations";
+export declare class OpenDeviceLogStreamCommand implements ICommand {
+    private $devicesService;
+    private $errors;
+    private $commandsService;
+    private $options;
+    private $deviceLogProvider;
+    private $loggingLevels;
+    private static NOT_SPECIFIED_DEVICE_ERROR_MESSAGE;
+    constructor($devicesService: Mobile.IDevicesService, $errors: IErrors, $commandsService: ICommandsService, $options: IOptions, $deviceLogProvider: Mobile.IDeviceLogProvider, $loggingLevels: Mobile.ILoggingLevels, $iOSSimulatorLogProvider: Mobile.IiOSSimulatorLogProvider, $cleanupService: ICleanupService);
+    allowedParameters: ICommandParameter[];
+    execute(args: string[]): Promise<void>;
+}

package/lib/common/commands/device/get-file.d.ts

@@ -0,0 +1,14 @@
+import { IProjectData } from "../../../definitions/project";
+import { IOptions } from "../../../declarations";
+import { ICommandParameter, ICommand } from "../../definitions/commands";
+import { IErrors } from "../../declarations";
+export declare class GetFileCommand implements ICommand {
+    private $devicesService;
+    private $stringParameter;
+    private $projectData;
+    private $errors;
+    private $options;
+    constructor($devicesService: Mobile.IDevicesService, $stringParameter: ICommandParameter, $projectData: IProjectData, $errors: IErrors, $options: IOptions);
+    allowedParameters: ICommandParameter[];
+    execute(args: string[]): Promise<void>;
+}

package/lib/common/commands/device/list-applications.d.ts

@@ -0,0 +1,10 @@
+import { IOptions } from "../../../declarations";
+import { ICommandParameter, ICommand } from "../../definitions/commands";
+export declare class ListApplicationsCommand implements ICommand {
+    private $devicesService;
+    private $logger;
+    private $options;
+    constructor($devicesService: Mobile.IDevicesService, $logger: ILogger, $options: IOptions);
+    allowedParameters: ICommandParameter[];
+    execute(args: string[]): Promise<void>;
+}

package/lib/common/commands/device/list-devices.d.ts

@@ -0,0 +1,16 @@
+import { IOptions } from "../../../declarations";
+import { ICommand, ICommandParameter } from "../../definitions/commands";
+import { IErrors } from "../../declarations";
+export declare class ListDevicesCommand implements ICommand {
+    private $devicesService;
+    private $errors;
+    private $emulatorHelper;
+    private $logger;
+    private $stringParameter;
+    private $mobileHelper;
+    private $options;
+    constructor($devicesService: Mobile.IDevicesService, $errors: IErrors, $emulatorHelper: Mobile.IEmulatorHelper, $logger: ILogger, $stringParameter: ICommandParameter, $mobileHelper: Mobile.IMobileHelper, $options: IOptions);
+    allowedParameters: ICommandParameter[];
+    execute(args: string[]): Promise<void>;
+    private printEmulators;
+}

package/lib/common/commands/device/list-files.d.ts

@@ -0,0 +1,14 @@
+import { IProjectData } from "../../../definitions/project";
+import { IOptions } from "../../../declarations";
+import { ICommandParameter, ICommand } from "../../definitions/commands";
+import { IErrors } from "../../declarations";
+export declare class ListFilesCommand implements ICommand {
+    private $devicesService;
+    private $stringParameter;
+    private $options;
+    private $projectData;
+    private $errors;
+    constructor($devicesService: Mobile.IDevicesService, $stringParameter: ICommandParameter, $options: IOptions, $projectData: IProjectData, $errors: IErrors);
+    allowedParameters: ICommandParameter[];
+    execute(args: string[]): Promise<void>;
+}

package/lib/common/commands/device/put-file.d.ts

@@ -0,0 +1,14 @@
+import { IProjectData } from "../../../definitions/project";
+import { IOptions } from "../../../declarations";
+import { ICommand, ICommandParameter } from "../../definitions/commands";
+import { IErrors } from "../../declarations";
+export declare class PutFileCommand implements ICommand {
+    private $devicesService;
+    private $stringParameter;
+    private $options;
+    private $projectData;
+    private $errors;
+    constructor($devicesService: Mobile.IDevicesService, $stringParameter: ICommandParameter, $options: IOptions, $projectData: IProjectData, $errors: IErrors);
+    allowedParameters: ICommandParameter[];
+    execute(args: string[]): Promise<void>;
+}

package/lib/common/commands/device/run-application.d.ts

@@ -0,0 +1,13 @@
+import { IOptions } from "../../../declarations";
+import { ICommand, ICommandParameter } from "../../definitions/commands";
+import { IErrors } from "../../declarations";
+export declare class RunApplicationOnDeviceCommand implements ICommand {
+    private $devicesService;
+    private $errors;
+    private $stringParameter;
+    private $staticConfig;
+    private $options;
+    constructor($devicesService: Mobile.IDevicesService, $errors: IErrors, $stringParameter: ICommandParameter, $staticConfig: Config.IStaticConfig, $options: IOptions);
+    allowedParameters: ICommandParameter[];
+    execute(args: string[]): Promise<void>;
+}

package/lib/common/commands/device/stop-application.d.ts

@@ -0,0 +1,10 @@
+import { IOptions } from "../../../declarations";
+import { ICommandParameter, ICommand } from "../../definitions/commands";
+export declare class StopApplicationOnDeviceCommand implements ICommand {
+    private $devicesService;
+    private $stringParameter;
+    private $options;
+    constructor($devicesService: Mobile.IDevicesService, $stringParameter: ICommandParameter, $options: IOptions);
+    allowedParameters: ICommandParameter[];
+    execute(args: string[]): Promise<void>;
+}

package/lib/common/commands/device/uninstall-application.d.ts

@@ -0,0 +1,10 @@
+import { IOptions } from "../../../declarations";
+import { ICommandParameter, ICommand } from "../../definitions/commands";
+export declare class UninstallApplicationCommand implements ICommand {
+    private $devicesService;
+    private $stringParameter;
+    private $options;
+    constructor($devicesService: Mobile.IDevicesService, $stringParameter: ICommandParameter, $options: IOptions);
+    allowedParameters: ICommandParameter[];
+    execute(args: string[]): Promise<void>;
+}

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

@@ -0,0 +1,23 @@
+import { ICommand, ICommandParameter } from "../definitions/commands";
+import { IDoctorService, IProjectHelper } from "../declarations";
+export declare class DoctorCommand implements ICommand {
+    private $doctorService;
+    private $projectHelper;
+    constructor($doctorService: IDoctorService, $projectHelper: IProjectHelper);
+    allowedParameters: ICommandParameter[];
+    execute(args: string[]): Promise<void>;
+}
+export declare class DoctorIosCommand implements ICommand {
+    private $doctorService;
+    private $projectHelper;
+    constructor($doctorService: IDoctorService, $projectHelper: IProjectHelper);
+    allowedParameters: ICommandParameter[];
+    execute(args: string[]): Promise<void>;
+}
+export declare class DoctorAndroidCommand implements ICommand {
+    private $doctorService;
+    private $projectHelper;
+    constructor($doctorService: IDoctorService, $projectHelper: IProjectHelper);
+    allowedParameters: ICommandParameter[];
+    execute(args: string[]): Promise<void>;
+}

package/lib/common/commands/generate-messages.d.ts

@@ -0,0 +1,13 @@
+import { IOptions } from "../../declarations";
+import { ICommand, ICommandParameter } from "../definitions/commands";
+import { IFileSystem, IServiceContractGenerator } from "../declarations";
+export declare class GenerateMessages implements ICommand {
+    private $fs;
+    private $messageContractGenerator;
+    private $options;
+    private static MESSAGES_DEFINITIONS_FILE_NAME;
+    private static MESSAGES_IMPLEMENTATION_FILE_NAME;
+    constructor($fs: IFileSystem, $messageContractGenerator: IServiceContractGenerator, $options: IOptions);
+    allowedParameters: ICommandParameter[];
+    execute(args: string[]): Promise<void>;
+}

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

@@ -0,0 +1,14 @@
+import { IOptions } from "../../declarations";
+import { IInjector } from "../definitions/yok";
+import { ICommand, ICommandParameter } from "../definitions/commands";
+import { IHelpService } from "../declarations";
+export declare class HelpCommand implements ICommand {
+    private $injector;
+    private $helpService;
+    private $options;
+    constructor($injector: IInjector, $helpService: IHelpService, $options: IOptions);
+    enableHooks: boolean;
+    canExecute(args: string[]): Promise<boolean>;
+    allowedParameters: ICommandParameter[];
+    execute(args: string[]): Promise<void>;
+}

package/lib/common/commands/package-manager-get.d.ts

@@ -0,0 +1,10 @@
+import { IUserSettingsService, IErrors } from "../declarations";
+import { ICommand, ICommandParameter } from "../definitions/commands";
+export declare class PackageManagerGetCommand implements ICommand {
+    private $errors;
+    private $logger;
+    private $userSettingsService;
+    constructor($errors: IErrors, $logger: ILogger, $userSettingsService: IUserSettingsService);
+    allowedParameters: ICommandParameter[];
+    execute(args: string[]): Promise<void>;
+}

package/lib/common/commands/package-manager-set.d.ts

@@ -0,0 +1,11 @@
+import { ICommand, ICommandParameter } from "../definitions/commands";
+import { IUserSettingsService, IErrors } from "../declarations";
+export declare class PackageManagerCommand implements ICommand {
+    private $userSettingsService;
+    private $errors;
+    private $logger;
+    private $stringParameter;
+    constructor($userSettingsService: IUserSettingsService, $errors: IErrors, $logger: ILogger, $stringParameter: ICommandParameter);
+    allowedParameters: ICommandParameter[];
+    execute(args: string[]): Promise<void>;
+}

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

@@ -0,0 +1,9 @@
+import { ICommand, ICommandParameter } from "../definitions/commands";
+import { IErrors } from "../declarations";
+export declare class PostInstallCommand implements ICommand {
+    protected $errors: IErrors;
+    constructor($errors: IErrors);
+    disableAnalytics: boolean;
+    allowedParameters: ICommandParameter[];
+    execute(args: string[]): Promise<void>;
+}

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

@@ -0,0 +1,16 @@
+import { IPackageInstallationManager } from "../../declarations";
+import { ICommand, ICommandParameter } from "../definitions/commands";
+import { IAnalyticsService, IFileSystem, ISettingsService } from "../declarations";
+import { IExtensibilityService } from "../definitions/extensibility";
+export declare class PreUninstallCommand implements ICommand {
+    private $analyticsService;
+    private $extensibilityService;
+    private $fs;
+    private $packageInstallationManager;
+    private $settingsService;
+    allowedParameters: ICommandParameter[];
+    constructor($analyticsService: IAnalyticsService, $extensibilityService: IExtensibilityService, $fs: IFileSystem, $packageInstallationManager: IPackageInstallationManager, $settingsService: ISettingsService);
+    execute(args: string[]): Promise<void>;
+    private handleIntentionalUninstall;
+    private handleFeedbackForm;
+}

package/lib/common/commands/proxy/proxy-base.d.ts

@@ -0,0 +1,13 @@
+import { ICommandParameter, ICommand } from "../../definitions/commands";
+import { IAnalyticsService, IProxyService } from "../../declarations";
+export declare abstract class ProxyCommandBase implements ICommand {
+    protected $analyticsService: IAnalyticsService;
+    protected $logger: ILogger;
+    protected $proxyService: IProxyService;
+    private commandName;
+    disableAnalytics: boolean;
+    allowedParameters: ICommandParameter[];
+    constructor($analyticsService: IAnalyticsService, $logger: ILogger, $proxyService: IProxyService, commandName: string);
+    abstract execute(args: string[]): Promise<void>;
+    protected tryTrackUsage(): Promise<void>;
+}

package/lib/common/commands/proxy/proxy-clear.d.ts

@@ -0,0 +1,9 @@
+import { ProxyCommandBase } from "./proxy-base";
+import { IAnalyticsService, IProxyService } from "../../declarations";
+export declare class ProxyClearCommand extends ProxyCommandBase {
+    protected $analyticsService: IAnalyticsService;
+    protected $logger: ILogger;
+    protected $proxyService: IProxyService;
+    constructor($analyticsService: IAnalyticsService, $logger: ILogger, $proxyService: IProxyService);
+    execute(args: string[]): Promise<void>;
+}

package/lib/common/commands/proxy/proxy-get.d.ts

@@ -0,0 +1,9 @@
+import { ProxyCommandBase } from "./proxy-base";
+import { IAnalyticsService, IProxyService } from "../../declarations";
+export declare class ProxyGetCommand extends ProxyCommandBase {
+    protected $analyticsService: IAnalyticsService;
+    protected $logger: ILogger;
+    protected $proxyService: IProxyService;
+    constructor($analyticsService: IAnalyticsService, $logger: ILogger, $proxyService: IProxyService);
+    execute(args: string[]): Promise<void>;
+}

package/lib/common/commands/proxy/proxy-set.d.ts

@@ -0,0 +1,23 @@
+import * as commandParams from "../../command-params";
+import { ProxyCommandBase } from "./proxy-base";
+import { IOptions } from "../../../declarations";
+import { IErrors, IHostInfo, IAnalyticsService, IProxyService } from "../../declarations";
+import { IInjector } from "../../definitions/yok";
+export declare class ProxySetCommand extends ProxyCommandBase {
+    private $errors;
+    private $injector;
+    private $prompter;
+    private $hostInfo;
+    private $staticConfig;
+    protected $analyticsService: IAnalyticsService;
+    protected $logger: ILogger;
+    protected $options: IOptions;
+    protected $proxyService: IProxyService;
+    allowedParameters: commandParams.StringCommandParameter[];
+    constructor($errors: IErrors, $injector: IInjector, $prompter: IPrompter, $hostInfo: IHostInfo, $staticConfig: Config.IStaticConfig, $analyticsService: IAnalyticsService, $logger: ILogger, $options: IOptions, $proxyService: IProxyService);
+    execute(args: string[]): Promise<void>;
+    private isPasswordRequired;
+    private isValidPort;
+    private getPortFromUserInput;
+    private getInvalidPortMessage;
+}

package/lib/common/constants.d.ts

@@ -0,0 +1,117 @@
+import { IDictionary } from "./declarations";
+export declare class ProvisionType {
+    static Development: string;
+    static AdHoc: string;
+    static AppStore: string;
+    static Enterprise: string;
+}
+export declare class DeviceTypes {
+    static Emulator: string;
+    static Simulator: string;
+    static Device: string;
+}
+export declare const APP_RESOURCES_FOLDER_NAME = "App_Resources";
+export declare const ERROR_NO_DEVICES = "Cannot find connected devices. Reconnect any connected devices, verify that your system recognizes them, and run this command again.";
+export declare const ERROR_CANT_USE_SIMULATOR = "You can use iOS simulator only on OS X.";
+export declare const ERROR_NO_DEVICES_CANT_USE_IOS_SIMULATOR = "Cannot find connected devices and cannot start iOS simulator on this OS.";
+export declare const ERROR_CANNOT_RESOLVE_DEVICE = "Cannot resolve the specified connected device. The provided platform does not match the provided index or identifier. To list currently connected devices and verify that the specified pair of platform and index or identifier exists, run 'device'.";
+export declare const ERROR_NO_VALID_SUBCOMMAND_FORMAT = "The input is not valid sub-command for '%s' command.";
+export declare const UNREACHABLE_STATUS = "Unreachable";
+export declare const CONNECTED_STATUS = "Connected";
+export declare const RUNNING_EMULATOR_STATUS = "Running";
+export declare const NOT_RUNNING_EMULATOR_STATUS = "Not running";
+export declare const APPLE_VENDOR_NAME = "Apple";
+export declare class LiveSyncPaths {
+    static SYNC_DIR_NAME: string;
+    static REMOVEDSYNC_DIR_NAME: string;
+    static FULLSYNC_DIR_NAME: string;
+    static IOS_DEVICE_PROJECT_ROOT_PATH: string;
+    static IOS_DEVICE_SYNC_ZIP_PATH: string;
+    static ANDROID_TMP_DIR_NAME: string;
+}
+export declare class HmrConstants {
+    static HMR_ERROR_STATUS: number;
+    static HMR_SUCCESS_STATUS: number;
+}
+export declare class DeviceDiscoveryEventNames {
+    static DEVICE_FOUND: string;
+    static DEVICE_UPDATED: string;
+    static DEVICE_LOST: string;
+}
+export declare class EmulatorDiscoveryNames {
+    static EMULATOR_IMAGE_FOUND: string;
+    static EMULATOR_IMAGE_LOST: string;
+}
+export declare const DEVICE_LOG_EVENT_NAME = "deviceLogData";
+export declare const IOS_LOG_PREDICATE = "senderImagePath contains \"NativeScript\"";
+export declare const IOS_APP_CRASH_LOG_REG_EXP: RegExp;
+export declare const FAIL_LIVESYNC_LOG_REGEX: RegExp;
+export declare const TARGET_FRAMEWORK_IDENTIFIERS: {
+    Cordova: string;
+    NativeScript: string;
+};
+export declare class Configurations {
+    static Debug: string;
+    static Release: string;
+}
+export declare const NODE_MODULES_DIR_NAME = "node_modules";
+export declare const TNS_CORE_MODULES = "tns-core-modules";
+export declare class FileExtensions {
+    static TYPESCRIPT_DEFINITION_FILE: string;
+    static TYPESCRIPT_FILE: string;
+    static PNG_FILE: string;
+    static NINE_PATCH_PNG_FILE: string;
+}
+export declare const IOS_POST_NOTIFICATION_COMMAND_TYPE = "PostNotification";
+export declare const IOS_OBSERVE_NOTIFICATION_COMMAND_TYPE = "ObserveNotification";
+export declare const IOS_RELAY_NOTIFICATION_COMMAND_TYPE = "RelayNotification";
+export declare class Proxy {
+    static CACHE_FILE_NAME: string;
+    static USE_PROXY: string;
+    static PROXY_PORT: string;
+    static PROXY_HOSTNAME: string;
+}
+export declare class HttpStatusCodes {
+    static SEE_OTHER: number;
+    static NOT_MODIFIED: number;
+    static PAYMENT_REQUIRED: number;
+    static PROXY_AUTHENTICATION_REQUIRED: number;
+    static CONFLICTING_RESOURCE: number;
+}
+export declare const HttpProtocolToPort: IDictionary<number>;
+export declare const enum AnalyticsClients {
+    Cli = "CLI",
+    NonInteractive = "Non-interactive",
+    Unknown = "Unknown"
+}
+export declare const DEFAULT_CHUNK_SIZE = 100;
+export declare const enum CommandsDelimiters {
+    HierarchicalCommand = "|",
+    DefaultCommandSymbol = "*",
+    DefaultHierarchicalCommand = "|*",
+    HooksCommand = "-"
+}
+export declare const DEBUGGER_PORT_FOUND_EVENT_NAME = "DEBUGGER_PORT_FOUND";
+export declare const ATTACH_REQUEST_EVENT_NAME = "ATTACH_REQUEST";
+export declare class AndroidVirtualDevice {
+    static ANDROID_DIR_NAME: string;
+    static AVD_DIR_NAME: string;
+    static ENCODING_MASK: RegExp;
+    static INI_FILES_MASK: RegExp;
+    static AVD_FILES_MASK: RegExp;
+    static MIN_ANDROID_APILEVEL: number;
+    static MIN_ANDROID_VERSION: string;
+    static AVAILABLE_AVDS_MESSAGE: string;
+    static AVD_LIST_DELIMITER: string;
+    static CONFIG_INI_FILE_NAME: string;
+    static INI_FILE_EXTENSION: string;
+    static AVD_FILE_EXTENSION: string;
+    static RUNNING_AVD_EMULATOR_REGEX: RegExp;
+    static RUNNING_GENY_EMULATOR_REGEX: RegExp;
+    static GENYMOTION_VENDOR_NAME: string;
+    static AVD_VENDOR_NAME: string;
+    static TIMEOUT_SECONDS: number;
+    static GENYMOTION_DEFAULT_STDERR_STRING: string;
+    static UNABLE_TO_START_EMULATOR_MESSAGE: string;
+}
+export declare const SOCKET_CONNECTION_TIMEOUT_MS = 30000;

package/lib/common/contracts/command-registry.d.ts

@@ -0,0 +1,35 @@
+import type { ICommand } from "../definitions/commands";
+export interface DeferredCommandOptions {
+    owner: string;
+    source: string;
+    load: () => void;
+}
+export type DeferredCommandRejection = {
+    reason: "invalid-name";
+    detail: string;
+} | {
+    reason: "claimed";
+    owner: string;
+} | {
+    reason: "built-in";
+} | {
+    reason: "subcommand-parent";
+} | {
+    reason: "parent-is-command";
+    parent: string;
+};
+export interface DeferredCommandResult {
+    registered: boolean;
+    rejection?: DeferredCommandRejection;
+}
+export declare abstract class CommandRegistry {
+    abstract requireCommand(names: string | string[], file: string): void;
+    abstract registerCommand(names: string | string[], resolver: any): void;
+    abstract registerDeferredCommand(name: string, options: DeferredCommandOptions): DeferredCommandResult;
+    abstract resolveCommand(name: string): ICommand;
+    abstract getRegisteredCommandsNames(includeDev: boolean): string[];
+    abstract getChildrenCommandsNames(commandName: string): string[];
+    abstract buildHierarchicalCommand(parentCommandName: string, commandLineArguments: string[]): any;
+    abstract isValidHierarchicalCommand(commandName: string, commandArguments: string[]): Promise<boolean>;
+    abstract isDefaultCommand(commandName: string): boolean;
+}