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

package/lib/key-commands/index.d.ts

@@ -0,0 +1,166 @@
+import { IChildProcess, IXcodeSelectService } from "../common/declarations";
+import { IKeyCommand, IKeyCommandHelper, IKeyCommandPlatform, IValidKeyName, SupportedProcessType } from "../common/definitions/key-commands";
+import { IProjectData } from "../definitions/project";
+import { IStartService } from "../definitions/start-service";
+import { IOSProjectService } from "../services/ios-project-service";
+import { IOptions } from "../declarations";
+export declare class A implements IKeyCommand {
+    private $startService;
+    key: IValidKeyName;
+    platform: IKeyCommandPlatform;
+    description: string;
+    group: string;
+    constructor($startService: IStartService);
+    execute(): Promise<void>;
+    canExecute(processType: SupportedProcessType): processType is "start";
+}
+export declare class ShiftA implements IKeyCommand {
+    private $logger;
+    private $liveSyncCommandHelper;
+    private $childProcess;
+    private $projectData;
+    key: IValidKeyName;
+    platform: IKeyCommandPlatform;
+    description: string;
+    group: string;
+    willBlockKeyCommandExecution: boolean;
+    protected isInteractive: boolean;
+    constructor($logger: ILogger, $liveSyncCommandHelper: ILiveSyncCommandHelper, $childProcess: IChildProcess, $projectData: IProjectData);
+    getAndroidStudioPath(): string | null;
+    execute(): Promise<void>;
+}
+export declare class OpenAndroidCommand extends ShiftA {
+    private $options;
+    constructor($logger: ILogger, $liveSyncCommandHelper: ILiveSyncCommandHelper, $childProcess: IChildProcess, $projectData: IProjectData, $options: IOptions);
+    execute(): Promise<void>;
+}
+export declare class I implements IKeyCommand {
+    private $startService;
+    key: IValidKeyName;
+    platform: IKeyCommandPlatform;
+    description: string;
+    group: string;
+    constructor($startService: IStartService);
+    execute(): Promise<void>;
+    canExecute(processType: SupportedProcessType): processType is "start";
+}
+export declare class ShiftI implements IKeyCommand {
+    private $iOSProjectService;
+    private $logger;
+    private $childProcess;
+    private $projectData;
+    private $xcodeSelectService;
+    private $xcodebuildArgsService;
+    key: IValidKeyName;
+    platform: IKeyCommandPlatform;
+    description: string;
+    group: string;
+    willBlockKeyCommandExecution: boolean;
+    protected isInteractive: boolean;
+    constructor($iOSProjectService: IOSProjectService, $logger: ILogger, $childProcess: IChildProcess, $projectData: IProjectData, $xcodeSelectService: IXcodeSelectService, $xcodebuildArgsService: IXcodebuildArgsService);
+    execute(): Promise<void>;
+}
+export declare class OpenIOSCommand extends ShiftI {
+    private $options;
+    constructor($iOSProjectService: IOSProjectService, $logger: ILogger, $childProcess: IChildProcess, $projectData: IProjectData, $xcodeSelectService: IXcodeSelectService, $xcodebuildArgsService: IXcodebuildArgsService, $options: IOptions);
+    execute(): Promise<void>;
+}
+export declare class V implements IKeyCommand {
+    private $startService;
+    key: IValidKeyName;
+    platform: IKeyCommandPlatform;
+    description: string;
+    group: string;
+    constructor($startService: IStartService);
+    execute(): Promise<void>;
+    canExecute(processType: SupportedProcessType): processType is "start";
+}
+export declare class ShiftV implements IKeyCommand {
+    private $iOSProjectService;
+    private $logger;
+    private $childProcess;
+    private $projectData;
+    private $xcodeSelectService;
+    private $xcodebuildArgsService;
+    protected $options: IOptions;
+    key: IValidKeyName;
+    platform: IKeyCommandPlatform;
+    description: string;
+    group: string;
+    willBlockKeyCommandExecution: boolean;
+    protected isInteractive: boolean;
+    constructor($iOSProjectService: IOSProjectService, $logger: ILogger, $childProcess: IChildProcess, $projectData: IProjectData, $xcodeSelectService: IXcodeSelectService, $xcodebuildArgsService: IXcodebuildArgsService, $options: IOptions);
+    execute(): Promise<void>;
+}
+export declare class OpenVisionOSCommand extends ShiftV {
+    protected $options: IOptions;
+    constructor($iOSProjectService: IOSProjectService, $logger: ILogger, $childProcess: IChildProcess, $projectData: IProjectData, $xcodeSelectService: IXcodeSelectService, $xcodebuildArgsService: IXcodebuildArgsService, $options: IOptions);
+    execute(): Promise<void>;
+}
+export declare class R implements IKeyCommand {
+    private $liveSyncCommandHelper;
+    key: IValidKeyName;
+    platform: IKeyCommandPlatform;
+    description: string;
+    group: string;
+    willBlockKeyCommandExecution: boolean;
+    constructor($liveSyncCommandHelper: ILiveSyncCommandHelper);
+    execute(platform: string): Promise<void>;
+}
+export declare class ShiftR implements IKeyCommand {
+    private $liveSyncCommandHelper;
+    key: IValidKeyName;
+    platform: IKeyCommandPlatform;
+    description: string;
+    group: string;
+    willBlockKeyCommandExecution: boolean;
+    constructor($liveSyncCommandHelper: ILiveSyncCommandHelper);
+    execute(platform: string): Promise<void>;
+}
+export declare class CtrlC implements IKeyCommand {
+    key: IValidKeyName;
+    platform: IKeyCommandPlatform;
+    description: string;
+    group: string;
+    willBlockKeyCommandExecution: boolean;
+    execute(): Promise<void>;
+}
+export declare class W implements IKeyCommand {
+    private $prepareController;
+    key: IValidKeyName;
+    platform: IKeyCommandPlatform;
+    description: string;
+    group: string;
+    willBlockKeyCommandExecution: boolean;
+    constructor($prepareController: IPrepareController);
+    execute(): Promise<void>;
+}
+export declare class C implements IKeyCommand {
+    private $childProcess;
+    private $liveSyncCommandHelper;
+    key: IValidKeyName;
+    platform: IKeyCommandPlatform;
+    description: string;
+    group: string;
+    willBlockKeyCommandExecution: boolean;
+    constructor($childProcess: IChildProcess, $liveSyncCommandHelper: ILiveSyncCommandHelper);
+    execute(): Promise<void>;
+}
+export declare class N implements IKeyCommand {
+    key: IValidKeyName;
+    platform: IKeyCommandPlatform;
+    description: string;
+    group: string;
+    willBlockKeyCommandExecution: boolean;
+    execute(platform: string): Promise<void>;
+}
+export declare class QuestionMark implements IKeyCommand {
+    private $keyCommandHelper;
+    key: IValidKeyName;
+    platform: IKeyCommandPlatform;
+    description: string;
+    group: string;
+    willBlockKeyCommandExecution: boolean;
+    constructor($keyCommandHelper: IKeyCommandHelper);
+    execute(platform_: string): Promise<void>;
+}

package/lib/nativescript-cli-lib-bootstrap.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/nativescript-cli-lib.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/nativescript-cli.d.ts

@@ -0,0 +1 @@
+export declare const originalProcessOn: any;

package/lib/node/pbxproj-dom-xcode.d.ts

@@ -0,0 +1,4 @@
+import * as pbxprojDomXcodeModule from "pbxproj-dom/xcode";
+declare global {
+    type IPbxprojDomXcode = typeof pbxprojDomXcodeModule;
+}

package/lib/node/xcode.d.ts

@@ -0,0 +1,2 @@
+import * as xcode from "nativescript-dev-xcode";
+export { xcode };

package/lib/node-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 NodePackageManager 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, path?: string): Promise<string>;
+    search(filter: string[], config: any): Promise<string>;
+    view(packageName: string, config: Object): Promise<any>;
+    searchNpms(keyword: string): Promise<INpmsResult>;
+    getRegistryPackageData(packageName: string): Promise<any>;
+    getCachePath(): Promise<string>;
+}

package/lib/options.d.ts

@@ -0,0 +1,33 @@
+import * as yargs from "yargs";
+import { IDictionary, IDashedOption, IErrors, ISettingsService } from "./common/declarations";
+export declare class Options {
+    private $errors;
+    private $settingsService;
+    private $logger;
+    private static DASHED_OPTION_REGEX;
+    private static NONDASHED_OPTION_REGEX;
+    private optionsWhiteList;
+    private globalOptions;
+    private initialArgv;
+    argv: yargs.Arguments;
+    options: IDictionary<IDashedOption>;
+    setupOptions(commandSpecificDashedOptions?: IDictionary<IDashedOption>): void;
+    constructor($errors: IErrors, $settingsService: ISettingsService, $logger: ILogger);
+    get shorthands(): string[];
+    private get commonOptions();
+    private get optionNames();
+    private getOptionValue;
+    validateOptions(commandSpecificDashedOptions?: IDictionary<IDashedOption>): void;
+    private getCanonicalOptionName;
+    private getReportedOptionName;
+    private reportInvalidOption;
+    private getCorrectOptionName;
+    private getOptionType;
+    private tryGetOptionByAliasName;
+    private hasAlias;
+    private isOptionSupported;
+    private getNonDashedOptionName;
+    private getDashedOptionName;
+    private setArgv;
+    private adjustDashedOptions;
+}

package/lib/options.js

@@ -28,18 +28,11 @@ class Options {
             this.argv.hmr = false;
         }
     }
-    constructor($errors, $settingsService) {
+    constructor($errors, $settingsService, $logger) {
         this.$errors = $errors;
         this.$settingsService = $settingsService;
-        this.optionsWhiteList = [
-            "ui",
-            "recursive",
-            "reporter",
-            "require",
-            "timeout",
-            "_",
-            "$0",
-        ];
+        this.$logger = $logger;
+        this.optionsWhiteList = ["_", "$0"];
         this.globalOptions = {
             log: { type: enums_1.OptionType.String, hasSensitiveValue: false },
             verbose: { type: enums_1.OptionType.Boolean, hasSensitiveValue: false },
@@ -57,8 +50,9 @@ class Options {
     get shorthands() {
         const result = [];
         _.each(_.keys(this.options), (optionName) => {
-            if (this.options[optionName].alias) {
-                result.push(this.options[optionName].alias);
+            const alias = this.options[optionName].alias;
+            if (alias) {
+                result.push(...(_.isArray(alias) ? alias : [alias]));
             }
         });
         return result;
@@ -105,6 +99,7 @@ class Options {
             vue: { type: enums_1.OptionType.Boolean, hasSensitiveValue: false },
             vuejs: { type: enums_1.OptionType.Boolean, hasSensitiveValue: false },
             svelte: { type: enums_1.OptionType.Boolean, hasSensitiveValue: false },
+            solid: { type: enums_1.OptionType.Boolean, hasSensitiveValue: false },
             vision: { type: enums_1.OptionType.Boolean, hasSensitiveValue: false },
             "vision-ng": { type: enums_1.OptionType.Boolean, hasSensitiveValue: false },
             "vision-react": { type: enums_1.OptionType.Boolean, hasSensitiveValue: false },
@@ -149,7 +144,6 @@ class Options {
             },
             json: { type: enums_1.OptionType.Boolean, hasSensitiveValue: false },
             avd: { type: enums_1.OptionType.String, hasSensitiveValue: true },
-            config: { type: enums_1.OptionType.Array, hasSensitiveValue: false },
             insecure: {
                 type: enums_1.OptionType.Boolean,
                 alias: "k",
@@ -234,49 +228,82 @@ class Options {
     }
     validateOptions(commandSpecificDashedOptions) {
         this.setupOptions(commandSpecificDashedOptions);
-        const parsed = {};
-        for (const key of Object.keys(this.argv)) {
-            const optionName = `${this.argv[key]}`;
-            parsed[optionName] = this.getOptionValue(optionName);
-        }
-        _.each(parsed, (value, originalOptionName) => {
-            if (value === undefined) {
-                return;
+        const validated = [];
+        for (const originalOptionName of Object.keys(this.argv)) {
+            const optionValue = this.getOptionValue(originalOptionName);
+            if (optionValue === undefined) {
+                continue;
             }
             const optionName = this.getCorrectOptionName(originalOptionName);
-            if (!_.includes(this.optionsWhiteList, optionName)) {
-                if (!this.isOptionSupported(optionName)) {
-                    this.$errors.failWithHelp(`The option '${originalOptionName}' is not supported.`);
-                }
-                const optionType = this.getOptionType(optionName), optionValue = parsed[optionName];
-                if (_.isArray(optionValue) && optionType !== enums_1.OptionType.Array) {
-                    this.$errors.failWithHelp("The '%s' option requires a single value.", originalOptionName);
-                }
-                else if (optionType === enums_1.OptionType.String &&
-                    helpers.isNullOrWhitespace(optionValue)) {
-                    this.$errors.failWithHelp("The option '%s' requires non-empty value.", originalOptionName);
-                }
-                else if (optionType === enums_1.OptionType.Array &&
-                    optionValue.length === 0) {
-                    this.$errors.failWithHelp(`The option '${originalOptionName}' requires one or more values, separated by a space.`);
-                }
+            if (_.includes(this.optionsWhiteList, optionName)) {
+                continue;
             }
-        });
+            const dedupeKey = this.getCanonicalOptionName(optionName);
+            if (_.includes(validated, dedupeKey)) {
+                continue;
+            }
+            validated.push(dedupeKey);
+            if (!this.isOptionSupported(optionName)) {
+                this.reportInvalidOption(`The option '${this.getReportedOptionName(originalOptionName)}' is not supported.`);
+                continue;
+            }
+            const optionType = this.getOptionType(optionName);
+            if (_.isArray(optionValue) && optionType !== enums_1.OptionType.Array) {
+                this.reportInvalidOption(`The '${originalOptionName}' option requires a single value.`);
+            }
+            else if (optionType === enums_1.OptionType.String &&
+                helpers.isNullOrWhitespace(optionValue)) {
+                this.reportInvalidOption(`The option '${originalOptionName}' requires non-empty value.`);
+            }
+            else if (optionType === enums_1.OptionType.Array && optionValue.length === 0) {
+                this.reportInvalidOption(`The option '${originalOptionName}' requires one or more values, separated by a space.`);
+            }
+        }
     }
-    getCorrectOptionName(optionName) {
-        const secondaryOptionName = this.getNonDashedOptionName(optionName);
-        return _.includes(this.optionNames, secondaryOptionName)
-            ? secondaryOptionName
+    getCanonicalOptionName(optionName) {
+        const correctName = this.getCorrectOptionName(optionName);
+        if (this.options[correctName]) {
+            return this.getNonDashedOptionName(correctName);
+        }
+        const aliasedName = _.findKey(this.options, (opt) => this.hasAlias(opt, correctName));
+        return this.getNonDashedOptionName(aliasedName || correctName);
+    }
+    getReportedOptionName(optionName) {
+        return process.argv.indexOf(`--no-${optionName}`) !== -1
+            ? `no-${optionName}`
             : optionName;
     }
+    reportInvalidOption(message) {
+        if (process.env.NS_STRICT_OPTIONS === "error") {
+            this.$errors.failWithHelp(message);
+            return;
+        }
+        this.$logger.warn(`${message} This will become an error in a future release. Set NS_STRICT_OPTIONS=error to preview that behavior.`);
+    }
+    getCorrectOptionName(optionName) {
+        const nonDashedName = this.getNonDashedOptionName(optionName);
+        if (_.includes(this.optionNames, nonDashedName)) {
+            return nonDashedName;
+        }
+        const dashedName = this.getDashedOptionName(optionName);
+        if (_.includes(this.optionNames, dashedName)) {
+            return dashedName;
+        }
+        return optionName;
+    }
     getOptionType(optionName) {
         const option = this.options[optionName] || this.tryGetOptionByAliasName(optionName);
         return option ? option.type : "";
     }
     tryGetOptionByAliasName(aliasName) {
-        const option = _.find(this.options, (opt) => opt.alias === aliasName);
+        const option = _.find(this.options, (opt) => this.hasAlias(opt, aliasName));
         return option;
     }
+    hasAlias(option, aliasName) {
+        return _.isArray(option.alias)
+            ? _.includes(option.alias, aliasName)
+            : option.alias === aliasName;
+    }
     isOptionSupported(option) {
         if (!this.options[option]) {
             const opt = this.tryGetOptionByAliasName(option);

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

@@ -0,0 +1,30 @@
+import { INpmInstallOptions, IPackageInstallationManager, IPackageManager, IStaticConfig } from "./declarations";
+import { IProjectDataService } from "./definitions/project";
+import { IChildProcess, IDictionary, IFileSystem, ISettingsService } from "./common/declarations";
+export declare class PackageInstallationManager implements IPackageInstallationManager {
+    private $packageManager;
+    private $childProcess;
+    private $logger;
+    private $settingsService;
+    private $fs;
+    private $staticConfig;
+    private $projectDataService;
+    constructor($packageManager: IPackageManager, $childProcess: IChildProcess, $logger: ILogger, $settingsService: ISettingsService, $fs: IFileSystem, $staticConfig: IStaticConfig, $projectDataService: IProjectDataService);
+    getLatestVersion(packageName: string): Promise<string>;
+    getNextVersion(packageName: string): Promise<string>;
+    getLatestCompatibleVersion(packageName: string, referenceVersion?: string): Promise<string>;
+    getMaxSatisfyingVersion(packageName: string, versionRange: string): Promise<string>;
+    getMaxSatisfyingVersionSafe(packageName: string, versionIdentifier: string): Promise<string>;
+    getInstalledDependencyVersion(packageName: string, projectDir?: string): Promise<string>;
+    getLatestCompatibleVersionSafe(packageName: string, referenceVersion?: string): Promise<string>;
+    install(packageToInstall: string, projectDir: string, opts?: INpmInstallOptions): Promise<any>;
+    uninstall(packageToUninstall: string, projectDir: string, opts?: IDictionary<string | boolean>): Promise<any>;
+    getInspectorFromCache(inspectorNpmPackageName: string, projectDir: string): Promise<string>;
+    clearInspectorCache(): void;
+    private getInspectorCachePath;
+    private prepareCacheDir;
+    private inspectorAlreadyInstalled;
+    private installCore;
+    private npmInstall;
+    private getVersion;
+}

package/lib/package-manager.d.ts

@@ -0,0 +1,32 @@
+import { IPackageManager, INodePackageManager, IOptions, INodePackageManagerInstallOptions, INpmInstallResultInfo, INpmsResult, INpmPackageNameParts } from "./declarations";
+import { IErrors, IUserSettingsService, IDictionary } from "./common/declarations";
+import { IProjectConfigService } from "./definitions/project";
+export declare class PackageManager implements IPackageManager {
+    private $errors;
+    private $npm;
+    private $options;
+    private $yarn;
+    private $yarn2;
+    private $pnpm;
+    private $bun;
+    private $logger;
+    private $userSettingsService;
+    private $projectConfigService;
+    private packageManager;
+    private _packageManagerName;
+    constructor($errors: IErrors, $npm: INodePackageManager, $options: IOptions, $yarn: INodePackageManager, $yarn2: INodePackageManager, $pnpm: INodePackageManager, $bun: INodePackageManager, $logger: ILogger, $userSettingsService: IUserSettingsService, $projectConfigService: IProjectConfigService);
+    protected init(): Promise<void>;
+    getPackageManagerName(): Promise<string>;
+    install(packageName: string, pathToSave: string, config: INodePackageManagerInstallOptions): Promise<INpmInstallResultInfo>;
+    uninstall(packageName: string, config?: IDictionary<string | boolean>, path?: string): Promise<string>;
+    view(packageName: string, config: Object): Promise<any>;
+    search(filter: string[], config: IDictionary<string | boolean>): Promise<string>;
+    searchNpms(keyword: string): Promise<INpmsResult>;
+    isRegistered(packageName: string): Promise<boolean>;
+    getPackageFullName(packageNameParts: INpmPackageNameParts): Promise<string>;
+    getPackageNameParts(fullPackageName: string): Promise<INpmPackageNameParts>;
+    getRegistryPackageData(packageName: string): Promise<any>;
+    getCachePath(): Promise<string>;
+    getTagVersion(packageName: string, tag: string): Promise<string>;
+    private _determinePackageManager;
+}

package/lib/platform-command-param.d.ts

@@ -0,0 +1,10 @@
+import { IProjectData } from "./definitions/project";
+import { IPlatformValidationService } from "./declarations";
+import { ICommandParameter } from "./common/definitions/commands";
+export declare class PlatformCommandParameter implements ICommandParameter {
+    private $platformValidationService;
+    private $projectData;
+    constructor($platformValidationService: IPlatformValidationService, $projectData: IProjectData);
+    mandatory: boolean;
+    validate(value: string): Promise<boolean>;
+}

package/lib/pnpm-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, IDictionary } from "./common/declarations";
+export declare class PnpmPackageManager extends BasePackageManager {
+    private $errors;
+    private $httpClient;
+    private $logger;
+    constructor($childProcess: IChildProcess, $errors: IErrors, $fs: IFileSystem, $hostInfo: IHostInfo, $httpClient: Server.IHttpClient, $logger: ILogger, $pacoteService: IPacoteService);
+    install(packageName: string, pathToSave: string, config: INodePackageManagerInstallOptions): Promise<INpmInstallResultInfo>;
+    uninstall(packageName: string, config?: IDictionary<string | boolean>, cwd?: string): Promise<string>;
+    view(packageName: string, config: Object): Promise<any>;
+    search(filter: string[], config: IDictionary<string | boolean>): Promise<string>;
+    searchNpms(keyword: string): Promise<INpmsResult>;
+    getRegistryPackageData(packageName: string): Promise<any>;
+    getCachePath(): Promise<string>;
+}

package/lib/project-data.d.ts

@@ -0,0 +1,58 @@
+import { BundlerType, INsConfig, IProjectConfigService, IProjectData } from "./definitions/project";
+import { IAndroidResourcesMigrationService, IOptions, IStaticConfig } from "./declarations";
+import { IErrors, IFileSystem, IProjectHelper, IStringDictionary } from "./common/declarations";
+import { IInjector } from "./common/definitions/yok";
+export declare class ProjectData implements IProjectData {
+    private $fs;
+    private $errors;
+    private $projectHelper;
+    private $staticConfig;
+    private $options;
+    private $logger;
+    private $injector;
+    private $androidResourcesMigrationService;
+    private $devicePlatformsConstants;
+    private static PROJECT_TYPES;
+    projectDir: string;
+    platformsDir: string;
+    projectFilePath: string;
+    projectIdentifiers: Mobile.IProjectIdentifier;
+    get projectId(): string;
+    set projectId(identifier: string);
+    projectName: string;
+    packageJsonData: any;
+    nsConfig: INsConfig;
+    appDirectoryPath: string;
+    appResourcesDirectoryPath: string;
+    dependencies: any;
+    devDependencies: IStringDictionary;
+    ignoredDependencies: string[];
+    projectType: string;
+    androidManifestPath: string;
+    infoPlistPath: string;
+    appGradlePath: string;
+    gradleFilesDirectoryPath: string;
+    buildXcconfigPath: string;
+    podfilePath: string;
+    isShared: boolean;
+    webpackConfigPath: string;
+    bundlerConfigPath: string;
+    bundler: BundlerType;
+    initialized: boolean;
+    constructor($fs: IFileSystem, $errors: IErrors, $projectHelper: IProjectHelper, $staticConfig: IStaticConfig, $options: IOptions, $logger: ILogger, $injector: IInjector, $androidResourcesMigrationService: IAndroidResourcesMigrationService, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants);
+    get projectConfig(): IProjectConfigService;
+    initializeProjectData(projectDir?: string): void;
+    initializeProjectDataFromContent(packageJsonContent: string, projectDir?: string): void;
+    private getPathToAndroidManifest;
+    private errorInvalidProject;
+    private getProjectFilePath;
+    getAppResourcesDirectoryPath(projectDir?: string): string;
+    getAppResourcesRelativeDirectoryPath(): string;
+    getAppDirectoryPath(projectDir?: string): string;
+    getAppDirectoryRelativePath(): string;
+    getNsConfigRelativePath(): string;
+    private resolveToProjectDir;
+    private initializeProjectIdentifiers;
+    private getProjectType;
+    private warnProjectId;
+}

package/lib/providers/project-files-provider.d.ts

@@ -0,0 +1,12 @@
+import { ProjectFilesProviderBase } from "../common/services/project-files-provider-base";
+import { IPlatformsDataService } from "../definitions/platform";
+import { IOptions } from "../declarations";
+import { IProjectData } from "../definitions/project";
+import { IProjectFilesConfig } from "../common/declarations";
+export declare class ProjectFilesProvider extends ProjectFilesProviderBase {
+    private $platformsDataService;
+    constructor($platformsDataService: IPlatformsDataService, $mobileHelper: Mobile.IMobileHelper, $options: IOptions);
+    private static INTERNAL_NONPROJECT_FILES;
+    mapFilePath(filePath: string, platform: string, projectData: IProjectData, projectFilesConfig: IProjectFilesConfig): string;
+    isFileExcluded(filePath: string): boolean;
+}

package/lib/resolvers/livesync-service-resolver.d.ts

@@ -0,0 +1,9 @@
+import { IInjector } from "../common/definitions/yok";
+import { IErrors } from "../common/declarations";
+export declare class LiveSyncServiceResolver implements ILiveSyncServiceResolver {
+    private $errors;
+    private $injector;
+    private $mobileHelper;
+    constructor($errors: IErrors, $injector: IInjector, $mobileHelper: Mobile.IMobileHelper);
+    resolveLiveSyncService(platform: string): IPlatformLiveSyncService;
+}

package/lib/services/analytics/analytics-broker-process.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/services/analytics/analytics-broker.d.ts

@@ -0,0 +1,11 @@
+import { IAnalyticsBroker, ITrackingInformation } from "./analytics";
+import { IAnalyticsSettingsService } from "../../common/declarations";
+import { IInjector } from "../../common/definitions/yok";
+export declare class AnalyticsBroker implements IAnalyticsBroker {
+    private $analyticsSettingsService;
+    private $injector;
+    private analyticsLoggingService;
+    private getGoogleAnalyticsProvider;
+    constructor($analyticsSettingsService: IAnalyticsSettingsService, $injector: IInjector, analyticsLoggingService: IFileLogService);
+    sendDataForTracking(trackInfo: ITrackingInformation): Promise<void>;
+}

package/lib/services/analytics/analytics-service.d.ts

@@ -0,0 +1,46 @@
+import { IOptions } from "../../declarations";
+import { IProjectDataService } from "../../definitions/project";
+import { IAnalyticsService, IDisposable, IUserSettingsService, IAnalyticsSettingsService, IChildProcess, IProjectHelper } from "../../common/declarations";
+import { IGoogleAnalyticsData, IEventActionData } from "../../common/definitions/google-analytics";
+export declare class AnalyticsService implements IAnalyticsService, IDisposable {
+    private $logger;
+    private $options;
+    private $staticConfig;
+    private $prompter;
+    private $userSettingsService;
+    private $analyticsSettingsService;
+    private $childProcess;
+    private $projectDataService;
+    private $mobileHelper;
+    private $projectHelper;
+    private static ANALYTICS_BROKER_START_TIMEOUT;
+    private brokerProcess;
+    private shouldDisposeInstance;
+    private analyticsStatuses;
+    constructor($logger: ILogger, $options: IOptions, $staticConfig: Config.IStaticConfig, $prompter: IPrompter, $userSettingsService: IUserSettingsService, $analyticsSettingsService: IAnalyticsSettingsService, $childProcess: IChildProcess, $projectDataService: IProjectDataService, $mobileHelper: Mobile.IMobileHelper, $projectHelper: IProjectHelper);
+    setShouldDispose(shouldDispose: boolean): void;
+    checkConsent(): Promise<void>;
+    setStatus(settingName: string, enabled: boolean): Promise<void>;
+    isEnabled(settingName: string): Promise<boolean>;
+    getStatusMessage(settingName: string, jsonFormat: boolean, readableSettingName: string): Promise<string>;
+    trackAcceptFeatureUsage(settings: {
+        acceptTrackFeatureUsage: boolean;
+    }): Promise<void>;
+    trackInGoogleAnalytics(gaSettings: IGoogleAnalyticsData): Promise<void>;
+    trackEventActionInGoogleAnalytics(data: IEventActionData): Promise<void>;
+    finishTracking(): Promise<void>;
+    private forcefullyTrackInGoogleAnalytics;
+    private setProjectRelatedCustomDimensions;
+    dispose(): void;
+    private addDataToLabel;
+    private getAnalyticsBroker;
+    private getBrokerProcessArgs;
+    private sendInfoForTracking;
+    private sendMessageToBroker;
+    private initAnalyticsStatuses;
+    private getStatus;
+    private isNotConfirmed;
+    private getHumanReadableStatusMessage;
+    private getJsonStatusMessage;
+    trackException(exception: any, message: string): Promise<void>;
+}