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

package/lib/common/mobile/device-log-emitter.d.ts

@@ -0,0 +1,9 @@
+import { DeviceLogProviderBase } from "./device-log-provider-base";
+export declare class DeviceLogEmitter extends DeviceLogProviderBase {
+    protected $logFilter: Mobile.ILogFilter;
+    private $loggingLevels;
+    protected $logSourceMapService: Mobile.ILogSourceMapService;
+    constructor($logFilter: Mobile.ILogFilter, $logger: ILogger, $loggingLevels: Mobile.ILoggingLevels, $logSourceMapService: Mobile.ILogSourceMapService);
+    logData(line: string, platform: string, deviceIdentifier: string): void;
+    setLogLevel(logLevel: string, deviceIdentifier?: string): void;
+}

package/lib/common/mobile/device-log-provider-base.d.ts

@@ -0,0 +1,21 @@
+import { EventEmitter } from "events";
+import { IDictionary } from "../declarations";
+export declare abstract class DeviceLogProviderBase extends EventEmitter implements Mobile.IDeviceLogProvider {
+    protected $logFilter: Mobile.ILogFilter;
+    protected $logger: ILogger;
+    protected $logSourceMapService: Mobile.ILogSourceMapService;
+    protected devicesLogOptions: IDictionary<Mobile.IDeviceLogOptions>;
+    constructor($logFilter: Mobile.ILogFilter, $logger: ILogger, $logSourceMapService: Mobile.ILogSourceMapService);
+    setSourceFileLocation(pathToOriginalFile: string): Promise<void>;
+    abstract logData(lineText: string, platform: string, deviceIdentifier: string): void;
+    abstract setLogLevel(logLevel: string, deviceIdentifier?: string): void;
+    setApplicationPidForDevice(deviceIdentifier: string, pid: string): void;
+    setApplicationIdForDevice(deviceIdentifier: string, appId: string): void;
+    setProjectNameForDevice(deviceIdentifier: string, projectName: string): void;
+    setProjectDirForDevice(deviceIdentifier: string, projectDir: string): void;
+    protected setDefaultLogLevelForDevice(deviceIdentifier: string): void;
+    protected getApplicationPidForDevice(deviceIdentifier: string): string;
+    getApplicationIdForDevice(deviceIdentifier: string): string;
+    protected getDeviceLogOptionsForDevice(deviceIdentifier: string): Mobile.IDeviceLogOptions;
+    protected setDeviceLogOptionsProperty(deviceIdentifier: string, propNameFunction: Function, propertyValue: string | boolean): void;
+}

package/lib/common/mobile/device-log-provider.d.ts

@@ -0,0 +1,21 @@
+import { DeviceLogProviderBase } from "./device-log-provider-base";
+import { IOptions } from "../../declarations";
+import { ITimelineProfilerService } from "../../services/timeline-profiler-service";
+export declare class DeviceLogProvider extends DeviceLogProviderBase {
+    protected $logFilter: Mobile.ILogFilter;
+    protected $logger: ILogger;
+    protected $logSourceMapService: Mobile.ILogSourceMapService;
+    protected $timelineProfilerService: ITimelineProfilerService;
+    protected $options: IOptions;
+    constructor($logFilter: Mobile.ILogFilter, $logger: ILogger, $logSourceMapService: Mobile.ILogSourceMapService, $timelineProfilerService: ITimelineProfilerService, $options: IOptions);
+    logData(lineText: string, platform: string, deviceIdentifier: string): void;
+    setLogLevel(logLevel: string, deviceIdentifier?: string): void;
+    private consoleLogLevelRegex;
+    private consoleLevelColor;
+    private deviceColorMap;
+    private colorPool;
+    private colorPoolIndex;
+    private getDeviceColor;
+    private logDataCore;
+    private printLine;
+}

package/lib/common/mobile/device-platforms-constants.d.ts

@@ -0,0 +1,8 @@
+export declare class DevicePlatformsConstants implements Mobile.IDevicePlatformsConstants {
+    iOS: string;
+    Android: string;
+    visionOS: string;
+    isiOS(value: string): boolean;
+    isAndroid(value: string): boolean;
+    isvisionOS(value: string): boolean;
+}

package/lib/common/mobile/emulator-helper.d.ts

@@ -0,0 +1,32 @@
+export declare class EmulatorHelper implements Mobile.IEmulatorHelper {
+    mapAndroidApiLevelToVersion: {
+        "android-36": string;
+        "android-36.1": string;
+        "android-35": string;
+        "android-34": string;
+        "android-33": string;
+        "android-32": string;
+        "android-31": string;
+        "android-30": string;
+        "android-29": string;
+        "android-28": string;
+        "android-27": string;
+        "android-26": string;
+        "android-25": string;
+        "android-24": string;
+        "android-23": string;
+        "android-22": string;
+        "android-21": string;
+        "android-20": string;
+        "android-19": string;
+        "android-18": string;
+        "android-17": string;
+    };
+    getEmulatorsFromAvailableEmulatorsOutput(availableEmulatorsOutput: Mobile.IListEmulatorsOutput): Mobile.IDeviceInfo[];
+    getErrorsFromAvailableEmulatorsOutput(availableEmulatorsOutput: Mobile.IListEmulatorsOutput): string[];
+    getEmulatorByImageIdentifier(imageIdentifier: string, emulators: Mobile.IDeviceInfo[]): Mobile.IDeviceInfo;
+    getEmulatorByIdOrName(emulatorIdOrName: string, emulators: Mobile.IDeviceInfo[]): Mobile.IDeviceInfo;
+    isEmulatorRunning(emulator: Mobile.IDeviceInfo): boolean;
+    getEmulatorByStartEmulatorOptions(options: Mobile.IStartEmulatorOptions, emulators: Mobile.IDeviceInfo[]): Mobile.IDeviceInfo;
+    setRunningAndroidEmulatorProperties(emulatorId: string, emulator: Mobile.IDeviceInfo): void;
+}

package/lib/common/mobile/ios/device/ios-application-manager.d.ts

@@ -0,0 +1,27 @@
+import { ApplicationManagerBase } from "../../application-manager-base";
+import { IOptions } from "../../../../declarations";
+import { IHooksService, IErrors, IiOSNotificationService, IDictionary } from "../../../declarations";
+export declare class IOSApplicationManager extends ApplicationManagerBase {
+    protected $logger: ILogger;
+    protected $hooksService: IHooksService;
+    private device;
+    private $errors;
+    private $iOSNotificationService;
+    private $iosDeviceOperations;
+    private $options;
+    protected $deviceLogProvider: Mobile.IDeviceLogProvider;
+    private applicationsLiveSyncInfos;
+    constructor($logger: ILogger, $hooksService: IHooksService, device: Mobile.IiOSDevice, $errors: IErrors, $iOSNotificationService: IiOSNotificationService, $iosDeviceOperations: IIOSDeviceOperations, $options: IOptions, $deviceLogProvider: Mobile.IDeviceLogProvider);
+    getInstalledApplications(): Promise<string[]>;
+    installApplication(packageFilePath: string): Promise<void>;
+    getApplicationsInformation(): Promise<Mobile.IApplicationInfo[]>;
+    uninstallApplication(appIdentifier: string): Promise<void>;
+    startApplication(appData: Mobile.IStartApplicationData): Promise<void>;
+    stopApplication(appData: Mobile.IApplicationData): Promise<void>;
+    restartApplication(appData: Mobile.IStartApplicationData): Promise<void>;
+    private setDeviceLogData;
+    private runApplicationCore;
+    private startDeviceLog;
+    getDebuggableApps(): Promise<Mobile.IDeviceApplicationInformation[]>;
+    getDebuggableAppViews(appIdentifiers: string[]): Promise<IDictionary<Mobile.IDebugWebViewInfo[]>>;
+}

package/lib/common/mobile/ios/device/ios-device-file-system.d.ts

@@ -0,0 +1,19 @@
+import { IFileSystem, IStringDictionary } from "../../../declarations";
+export declare class IOSDeviceFileSystem implements Mobile.IDeviceFileSystem {
+    private device;
+    private $logger;
+    private $iosDeviceOperations;
+    private $fs;
+    private static AFC_DELETE_FILE_NOT_FOUND_ERROR;
+    constructor(device: Mobile.IDevice, $logger: ILogger, $iosDeviceOperations: IIOSDeviceOperations, $fs: IFileSystem);
+    listFiles(devicePath: string, appIdentifier: string): Promise<void>;
+    getDirectoryEntries(devicePath: string, appIdentifier: string): Promise<string[] | null>;
+    getFile(deviceFilePath: string, appIdentifier: string, outputFilePath?: string): Promise<void>;
+    getFileContent(deviceFilePath: string, appIdentifier: string): Promise<string>;
+    putFile(localFilePath: string, deviceFilePath: string, appIdentifier: string): Promise<void>;
+    deleteFile(deviceFilePath: string, appIdentifier: string): Promise<void>;
+    transferFiles(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[]): Promise<Mobile.ILocalToDevicePathData[]>;
+    transferDirectory(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[], projectFilesPath: string): Promise<Mobile.ILocalToDevicePathData[]>;
+    updateHashesOnDevice(hashes: IStringDictionary, appIdentifier: string): Promise<void>;
+    private uploadFilesCore;
+}

package/lib/common/mobile/ios/device/ios-device-operations.d.ts

@@ -0,0 +1,29 @@
+import { EventEmitter } from "events";
+import { IDisposable, IShouldDispose, IDictionary } from "../../../declarations";
+export declare class IOSDeviceOperations extends EventEmitter implements IIOSDeviceOperations, IDisposable, IShouldDispose {
+    private $logger;
+    isInitialized: boolean;
+    shouldDispose: boolean;
+    private deviceLib;
+    constructor($logger: ILogger);
+    install(ipaPath: string, deviceIdentifiers: string[], errorHandler: DeviceOperationErrorHandler): Promise<IOSDeviceResponse>;
+    uninstall(appIdentifier: string, deviceIdentifiers: string[], errorHandler: DeviceOperationErrorHandler): Promise<IOSDeviceResponse>;
+    startLookingForDevices(deviceFoundCallback: DeviceInfoCallback, deviceUpdatedCallback: DeviceInfoCallback, deviceLostCallback: DeviceInfoCallback, options?: Mobile.IDeviceLookingOptions): Promise<void>;
+    startDeviceLog(deviceIdentifier: string): void;
+    apps(deviceIdentifiers: string[], errorHandler?: DeviceOperationErrorHandler): Promise<IOSDeviceAppInfo>;
+    listDirectory(listArray: IOSDeviceLib.IReadOperationData[], errorHandler?: DeviceOperationErrorHandler): Promise<IOSDeviceMultipleResponse>;
+    readFiles(deviceFilePaths: IOSDeviceLib.IReadOperationData[], errorHandler?: DeviceOperationErrorHandler): Promise<IOSDeviceResponse>;
+    downloadFiles(deviceFilePaths: IOSDeviceLib.IFileOperationData[], errorHandler?: DeviceOperationErrorHandler): Promise<IOSDeviceResponse>;
+    uploadFiles(files: IOSDeviceLib.IUploadFilesData[], errorHandler?: DeviceOperationErrorHandler): Promise<IOSDeviceResponse>;
+    deleteFiles(deleteArray: IOSDeviceLib.IDeleteFileData[], errorHandler?: DeviceOperationErrorHandler): Promise<IOSDeviceResponse>;
+    start(startArray: IOSDeviceLib.IDdiApplicationData[], errorHandler?: DeviceOperationErrorHandler): Promise<IOSDeviceResponse>;
+    stop(stopArray: IOSDeviceLib.IDdiApplicationData[], errorHandler?: DeviceOperationErrorHandler): Promise<IOSDeviceResponse>;
+    dispose(signal?: string): void;
+    postNotification(postNotificationArray: IOSDeviceLib.IPostNotificationData[], errorHandler?: DeviceOperationErrorHandler): Promise<IOSDeviceResponse>;
+    awaitNotificationResponse(awaitNotificationResponseArray: IOSDeviceLib.IAwaitNotificatioNResponseData[], errorHandler?: DeviceOperationErrorHandler): Promise<IOSDeviceResponse>;
+    connectToPort(connectToPortArray: IOSDeviceLib.IConnectToPortData[], errorHandler?: DeviceOperationErrorHandler): Promise<IDictionary<IOSDeviceLib.IConnectToPortResponse[]>>;
+    setShouldDispose(shouldDispose: boolean): void;
+    private getMultipleResults;
+    private assertIsInitialized;
+    private attacheDeviceLogDataHandler;
+}

package/lib/common/mobile/ios/device/ios-device.d.ts

@@ -0,0 +1,32 @@
+import * as net from "net";
+import { IOSDeviceBase } from "../ios-device-base";
+import { IiOSSocketRequestExecutor } from "../../../../declarations";
+import { IErrors } from "../../../declarations";
+import { IInjector } from "../../../definitions/yok";
+export declare class IOSDevice extends IOSDeviceBase {
+    private deviceActionInfo;
+    protected $errors: IErrors;
+    private $injector;
+    protected $iOSDebuggerPortService: IIOSDebuggerPortService;
+    protected $deviceLogProvider: Mobile.IDeviceLogProvider;
+    protected $logger: ILogger;
+    protected $lockService: ILockService;
+    private $iOSSocketRequestExecutor;
+    private $devicePlatformsConstants;
+    private $iOSDeviceProductNameMapper;
+    private $iosDeviceOperations;
+    private $mobileHelper;
+    applicationManager: Mobile.IDeviceApplicationManager;
+    fileSystem: Mobile.IDeviceFileSystem;
+    deviceInfo: Mobile.IDeviceInfo;
+    private _deviceLogHandler;
+    constructor(deviceActionInfo: IOSDeviceLib.IDeviceActionInfo, $errors: IErrors, $injector: IInjector, $iOSDebuggerPortService: IIOSDebuggerPortService, $deviceLogProvider: Mobile.IDeviceLogProvider, $logger: ILogger, $lockService: ILockService, $iOSSocketRequestExecutor: IiOSSocketRequestExecutor, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $iOSDeviceProductNameMapper: Mobile.IiOSDeviceProductNameMapper, $iosDeviceOperations: IIOSDeviceOperations, $mobileHelper: Mobile.IMobileHelper);
+    get isEmulator(): boolean;
+    get isOnlyWiFiConnected(): boolean;
+    openDeviceLogStream(): Promise<void>;
+    protected getDebugSocketCore(appId: string): Promise<net.Socket>;
+    private actionOnDeviceLog;
+    detach(): void;
+    private getActiveArchitecture;
+    private getPlatform;
+}

package/lib/common/mobile/ios/ios-device-base.d.ts

@@ -0,0 +1,24 @@
+import * as net from "net";
+import { IErrors } from "../../declarations";
+export declare abstract class IOSDeviceBase implements Mobile.IiOSDevice {
+    private cachedSockets;
+    protected abstract $errors: IErrors;
+    protected abstract $deviceLogProvider: Mobile.IDeviceLogProvider;
+    protected abstract $iOSDebuggerPortService: IIOSDebuggerPortService;
+    protected abstract $lockService: ILockService;
+    protected abstract $logger: ILogger;
+    abstract deviceInfo: Mobile.IDeviceInfo;
+    abstract applicationManager: Mobile.IDeviceApplicationManager;
+    abstract fileSystem: Mobile.IDeviceFileSystem;
+    abstract isEmulator: boolean;
+    abstract isOnlyWiFiConnected: boolean;
+    abstract openDeviceLogStream(options?: Mobile.IiOSLogStreamOptions): Promise<void>;
+    getDebugSocket(appId: string, projectName: string, projectDir: string, ensureAppStarted?: boolean): Promise<net.Socket>;
+    protected abstract getDebugSocketCore(appId: string): Promise<net.Socket>;
+    protected attachToDebuggerFoundEvent(appId: string, projectName: string, projectDir: string): Promise<void>;
+    protected getDebuggerPort(appId: string): Promise<number>;
+    destroyAllSockets(): Promise<void>;
+    destroyDebugSocket(appId: string): Promise<void>;
+    private destroySocketSafe;
+    private startDeviceLogProcess;
+}

package/lib/common/mobile/ios/ios-log-filter.d.ts

@@ -0,0 +1,6 @@
+export declare class IOSLogFilter implements Mobile.IPlatformLogFilter {
+    private $loggingLevels;
+    protected infoFilterRegex: RegExp;
+    constructor($loggingLevels: Mobile.ILoggingLevels);
+    filterData(data: string, loggingOptions?: Mobile.IDeviceLogOptions): string;
+}

package/lib/common/mobile/ios/simulator/ios-emulator-services.d.ts

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

package/lib/common/mobile/ios/simulator/ios-sim-resolver.d.ts

@@ -0,0 +1,7 @@
+export declare class IOSSimResolver implements Mobile.IiOSSimResolver {
+    private static iOSSimName;
+    private static iOSStandaloneExecutableName;
+    private _iOSSim;
+    get iOSSim(): any;
+    get iOSSimPath(): string;
+}

package/lib/common/mobile/ios/simulator/ios-simulator-application-manager.d.ts

@@ -0,0 +1,27 @@
+import { ApplicationManagerBase } from "../../application-manager-base";
+import { IOptions } from "../../../../declarations";
+import { IDictionary, IChildProcess, IFileSystem, IHooksService } from "../../../declarations";
+import { ITempService } from "../../../../definitions/temp-service";
+export declare class IOSSimulatorApplicationManager extends ApplicationManagerBase {
+    private $childProcess;
+    private iosSim;
+    private device;
+    private $options;
+    private $fs;
+    protected $deviceLogProvider: Mobile.IDeviceLogProvider;
+    private $tempService;
+    private _lldbProcesses;
+    constructor($childProcess: IChildProcess, iosSim: any, device: Mobile.IiOSDevice, $options: IOptions, $fs: IFileSystem, $deviceLogProvider: Mobile.IDeviceLogProvider, $tempService: ITempService, $logger: ILogger, $hooksService: IHooksService);
+    getInstalledApplications(): Promise<string[]>;
+    installApplication(packageFilePath: string): Promise<void>;
+    uninstallApplication(appIdentifier: string): Promise<void>;
+    startApplication(appData: Mobile.IStartApplicationData): Promise<void>;
+    stopApplication(appData: Mobile.IApplicationData): Promise<void>;
+    getDebuggableApps(): Promise<Mobile.IDeviceApplicationInformation[]>;
+    getDebuggableAppViews(appIdentifiers: string[]): Promise<IDictionary<Mobile.IDebugWebViewInfo[]>>;
+    private attachNativeDebugger;
+    private detachNativeDebugger;
+    private killProcess;
+    private setDeviceLogData;
+    private startDeviceLog;
+}

package/lib/common/mobile/ios/simulator/ios-simulator-device.d.ts

@@ -0,0 +1,27 @@
+import * as net from "net";
+import { IOSDeviceBase } from "../ios-device-base";
+import { IiOSNotification } from "../../../../declarations";
+import { IErrors } from "../../../declarations";
+import { IInjector } from "../../../definitions/yok";
+export declare class IOSSimulator extends IOSDeviceBase implements Mobile.IiOSDevice {
+    private simulator;
+    private $devicePlatformsConstants;
+    protected $deviceLogProvider: Mobile.IDeviceLogProvider;
+    protected $errors: IErrors;
+    protected $lockService: ILockService;
+    private $injector;
+    protected $iOSDebuggerPortService: IIOSDebuggerPortService;
+    private $iOSSimResolver;
+    private $iOSEmulatorServices;
+    private $iOSNotification;
+    private $iOSSimulatorLogProvider;
+    protected $logger: ILogger;
+    applicationManager: Mobile.IDeviceApplicationManager;
+    fileSystem: Mobile.IDeviceFileSystem;
+    deviceInfo: Mobile.IDeviceInfo;
+    constructor(simulator: Mobile.IiSimDevice, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $deviceLogProvider: Mobile.IDeviceLogProvider, $errors: IErrors, $lockService: ILockService, $injector: IInjector, $iOSDebuggerPortService: IIOSDebuggerPortService, $iOSSimResolver: Mobile.IiOSSimResolver, $iOSEmulatorServices: Mobile.IiOSSimulatorService, $iOSNotification: IiOSNotification, $iOSSimulatorLogProvider: Mobile.IiOSSimulatorLogProvider, $logger: ILogger);
+    get isEmulator(): boolean;
+    get isOnlyWiFiConnected(): boolean;
+    openDeviceLogStream(options?: Mobile.IiOSLogStreamOptions): Promise<void>;
+    protected getDebugSocketCore(appId: string): Promise<net.Socket>;
+}

package/lib/common/mobile/ios/simulator/ios-simulator-file-system.d.ts

@@ -0,0 +1,16 @@
+import { IFileSystem, IStringDictionary } from "../../../declarations";
+export declare class IOSSimulatorFileSystem implements Mobile.IDeviceFileSystem {
+    private iosSim;
+    private $fs;
+    private $logger;
+    constructor(iosSim: any, $fs: IFileSystem, $logger: ILogger);
+    listFiles(devicePath: string): Promise<void>;
+    getFile(deviceFilePath: string, appIdentifier: string, outputFilePath?: string): Promise<void>;
+    getFileContent(deviceFilePath: string, appIdentifier: string): Promise<string>;
+    putFile(localFilePath: string, deviceFilePath: string, appIdentifier: string): Promise<void>;
+    deleteFile(deviceFilePath: string, appIdentifier: string): Promise<void>;
+    transferFiles(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[]): Promise<Mobile.ILocalToDevicePathData[]>;
+    transferDirectory(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[], projectFilesPath: string): Promise<Mobile.ILocalToDevicePathData[]>;
+    transferFile(localFilePath: string, deviceFilePath: string): Promise<void>;
+    updateHashesOnDevice(hashes: IStringDictionary, appIdentifier: string): Promise<void>;
+}

package/lib/common/mobile/ios/simulator/ios-simulator-log-provider.d.ts

@@ -0,0 +1,15 @@
+import { EventEmitter } from "events";
+import { IShouldDispose, IDisposable } from "../../../declarations";
+export declare class IOSSimulatorLogProvider extends EventEmitter implements Mobile.IiOSSimulatorLogProvider, IDisposable, IShouldDispose {
+    private $iOSSimResolver;
+    private $logger;
+    private $devicePlatformsConstants;
+    private $deviceLogProvider;
+    shouldDispose: boolean;
+    private simulatorsLoggingEnabled;
+    private simulatorsLogProcess;
+    constructor($iOSSimResolver: Mobile.IiOSSimResolver, $logger: ILogger, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $deviceLogProvider: Mobile.IDeviceLogProvider);
+    setShouldDispose(shouldDispose: boolean): void;
+    startLogProcess(deviceId: string, options?: Mobile.IiOSLogStreamOptions): Promise<void>;
+    dispose(signal?: any): void;
+}

package/lib/common/mobile/local-to-device-path-data-factory.d.ts

@@ -0,0 +1,3 @@
+export declare class LocalToDevicePathDataFactory implements Mobile.ILocalToDevicePathDataFactory {
+    create(filePath: string, localProjectRootPath: string, onDeviceFileName: string, deviceProjectRootPath: string): Mobile.ILocalToDevicePathData;
+}

package/lib/common/mobile/log-filter.d.ts

@@ -0,0 +1,13 @@
+import { IInjector } from "../definitions/yok";
+export declare class LogFilter implements Mobile.ILogFilter {
+    private $devicePlatformsConstants;
+    private $injector;
+    private $loggingLevels;
+    private _loggingLevel;
+    constructor($devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $injector: IInjector, $loggingLevels: Mobile.ILoggingLevels);
+    get loggingLevel(): string;
+    set loggingLevel(logLevel: string);
+    filterData(platform: string, data: string, loggingOptions?: Mobile.IDeviceLogOptions): string;
+    private getDeviceLogFilterInstance;
+    private verifyLogLevel;
+}

package/lib/common/mobile/logging-levels.d.ts

@@ -0,0 +1,4 @@
+export declare class LoggingLevels implements Mobile.ILoggingLevels {
+    info: string;
+    full: string;
+}

package/lib/common/mobile/mobile-core/android-device-discovery.d.ts

@@ -0,0 +1,16 @@
+import { DeviceDiscovery } from "./device-discovery";
+import { IInjector } from "../../definitions/yok";
+export declare class AndroidDeviceDiscovery extends DeviceDiscovery implements Mobile.IAndroidDeviceDiscovery {
+    private $injector;
+    private $adb;
+    private $mobileHelper;
+    private _devices;
+    private isStarted;
+    constructor($injector: IInjector, $adb: Mobile.IAndroidDebugBridge, $mobileHelper: Mobile.IMobileHelper);
+    private createAndAddDevice;
+    private deleteAndRemoveDevice;
+    startLookingForDevices(options?: Mobile.IDeviceLookingOptions): Promise<void>;
+    private checkForDevices;
+    private checkCurrentData;
+    ensureAdbServerStarted(): Promise<any>;
+}

package/lib/common/mobile/mobile-core/android-emulator-discovery.d.ts

@@ -0,0 +1,11 @@
+import { EventEmitter } from "events";
+export declare class AndroidEmulatorDiscovery extends EventEmitter implements Mobile.IDeviceDiscovery {
+    private $androidEmulatorServices;
+    private $mobileHelper;
+    private _emulators;
+    constructor($androidEmulatorServices: Mobile.IEmulatorPlatformService, $mobileHelper: Mobile.IMobileHelper);
+    startLookingForDevices(options?: Mobile.IDeviceLookingOptions): Promise<void>;
+    getDevices(): Mobile.IDeviceInfo[];
+    private raiseOnEmulatorImagesFound;
+    private raiseOnEmulatorImagesLost;
+}

package/lib/common/mobile/mobile-core/android-process-service.d.ts

@@ -0,0 +1,33 @@
+import { IDictionary, IErrors, INet } from "../../declarations";
+import { ICleanupService } from "../../../definitions/cleanup-service";
+import { IInjector } from "../../definitions/yok";
+import { IStaticConfig } from "../../../declarations";
+export declare class AndroidProcessService implements Mobile.IAndroidProcessService {
+    private $errors;
+    private $cleanupService;
+    private $injector;
+    private $net;
+    private $staticConfig;
+    private _devicesAdbs;
+    private _forwardedLocalPorts;
+    constructor($errors: IErrors, $cleanupService: ICleanupService, $injector: IInjector, $net: INet, $staticConfig: IStaticConfig);
+    forwardFreeTcpToAbstractPort(portForwardInputData: Mobile.IPortForwardData): Promise<number>;
+    mapAbstractToTcpPort(deviceIdentifier: string, appIdentifier: string, framework: string): Promise<string>;
+    getMappedAbstractToTcpPorts(deviceIdentifier: string, appIdentifiers: string[], framework: string): Promise<IDictionary<number>>;
+    getDebuggableApps(deviceIdentifier: string): Promise<Mobile.IDeviceApplicationInformation[]>;
+    getAppProcessId(deviceIdentifier: string, appIdentifier: string): Promise<string>;
+    private forwardPort;
+    private setupForPortForwarding;
+    private getApplicationInfoFromWebViewPortInformation;
+    private getNativeScriptApplicationInformation;
+    private getAbstractPortForApplication;
+    private getCordovaPortInformation;
+    private getNativeScriptPortInformation;
+    private getAbstractPortsInformation;
+    private getPortInformation;
+    private getProcessIds;
+    private getAlreadyMappedPort;
+    private getAdb;
+    private getApplicationIdentifierFromPid;
+    private getFirstMatchingGroupFromMultilineResult;
+}

package/lib/common/mobile/mobile-core/device-discovery.d.ts

@@ -0,0 +1,12 @@
+import { EventEmitter } from "events";
+export declare class DeviceDiscovery extends EventEmitter implements Mobile.IDeviceDiscovery {
+    private devices;
+    startLookingForDevices(): Promise<void>;
+    protected getDevice(deviceIdentifier: string): Mobile.IDevice;
+    protected addDevice(device: Mobile.IDevice): void;
+    protected updateDeviceInfo(device: Mobile.IDevice): void;
+    protected removeDevice(deviceIdentifier: string): void;
+    private raiseOnDeviceFound;
+    private raiseOnDeviceUpdated;
+    private raiseOnDeviceLost;
+}

package/lib/common/mobile/mobile-core/devices-service.d.ts

@@ -0,0 +1,99 @@
+import { EventEmitter } from "events";
+import { IOptions } from "../../../declarations";
+import { IAppInstalledInfo, IErrors, IHostInfo } from "../../declarations";
+import { IInjector } from "../../definitions/yok";
+export declare class DevicesService extends EventEmitter implements Mobile.IDevicesService {
+    private $logger;
+    private $errors;
+    private $iOSSimulatorDiscovery;
+    private $iOSDeviceDiscovery;
+    private $androidDeviceDiscovery;
+    private $staticConfig;
+    private $messages;
+    private $mobileHelper;
+    private $deviceLogProvider;
+    private $hostInfo;
+    private $injector;
+    private $options;
+    private $androidProcessService;
+    private $iOSEmulatorServices;
+    private $androidEmulatorServices;
+    private $androidEmulatorDiscovery;
+    private $emulatorHelper;
+    private $prompter;
+    private $devicePlatformsConstants;
+    private static DEVICE_LOOKING_INTERVAL;
+    private static EMULATOR_IMAGES_DETECTION_INTERVAL;
+    private _devices;
+    private _availableEmulators;
+    private _platform;
+    private _device;
+    private _isInitialized;
+    private _data;
+    private _otherDeviceDiscoveries;
+    private _allDeviceDiscoveries;
+    private deviceDetectionInterval;
+    private emulatorDetectionInterval;
+    constructor($logger: ILogger, $errors: IErrors, $iOSSimulatorDiscovery: Mobile.IiOSSimulatorDiscovery, $iOSDeviceDiscovery: Mobile.IDeviceDiscovery, $androidDeviceDiscovery: Mobile.IDeviceDiscovery, $staticConfig: Config.IStaticConfig, $messages: IMessages, $mobileHelper: Mobile.IMobileHelper, $deviceLogProvider: Mobile.IDeviceLogProvider, $hostInfo: IHostInfo, $injector: IInjector, $options: IOptions, $androidProcessService: Mobile.IAndroidProcessService, $iOSEmulatorServices: Mobile.IiOSSimulatorService, $androidEmulatorServices: Mobile.IEmulatorPlatformService, $androidEmulatorDiscovery: Mobile.IDeviceDiscovery, $emulatorHelper: Mobile.IEmulatorHelper, $prompter: IPrompter, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants);
+    pickSingleDevice(options: Mobile.IPickSingleDeviceOptions): Promise<Mobile.IDevice>;
+    getEmulatorImages(options?: Mobile.IListEmulatorsOptions): Promise<Mobile.IListEmulatorsOutput>;
+    startEmulator(options: Mobile.IStartEmulatorOptions): Promise<string[]>;
+    get platform(): string;
+    get deviceCount(): number;
+    getDevices(): Mobile.IDeviceInfo[];
+    getDevicesForPlatform(platform: string): Mobile.IDevice[];
+    isAndroidDevice(device: Mobile.IDevice): boolean;
+    isiOSDevice(device: Mobile.IDevice): boolean;
+    isiOSSimulator(device: Mobile.IDevice): boolean;
+    setLogLevel(logLevel: string, deviceIdentifier?: string): void;
+    isAppInstalledOnDevices(deviceIdentifiers: string[], appId: string, projectName: string, projectDir: string): Promise<IAppInstalledInfo>[];
+    getDeviceInstances(): Mobile.IDevice[];
+    getInstalledApplications(deviceIdentifier: string): Promise<string[]>;
+    addDeviceDiscovery(deviceDiscovery: Mobile.IDeviceDiscovery): void;
+    private attachToKnownDeviceDiscoveryEvents;
+    private attachToKnownEmulatorDiscoveryEvents;
+    private attachToDeviceDiscoveryEvents;
+    private onDeviceFound;
+    private onDeviceUpdated;
+    private onDeviceLost;
+    private onEmulatorImageFound;
+    private onEmulatorImageLost;
+    protected detectCurrentlyAttachedDevices(deviceInitOpts?: Mobile.IDeviceLookingOptions): Promise<void>;
+    protected detectCurrentlyAvailableEmulators(): Promise<void>;
+    startDeviceDetectionInterval(deviceInitOpts?: Mobile.IDeviceLookingOptions): void;
+    startEmulatorDetectionInterval(opts?: Mobile.IHasDetectionInterval): void;
+    stopDeviceDetectionInterval(): void;
+    stopEmulatorDetectionInterval(): void;
+    getDeviceByIdentifier(identifier: string): Mobile.IDevice;
+    private startLookingForDevices;
+    private getDeviceByIndex;
+    getDevice(deviceOption: string): Promise<Mobile.IDevice>;
+    private executeOnDevice;
+    private executeOnAllConnectedDevices;
+    deployOnDevices(deviceIdentifiers: string[], packagePath: string, appId: string | Mobile.IProjectIdentifier, projectName: string, projectDir: string): Promise<void>[];
+    execute<T>(action: (device: Mobile.IDevice) => Promise<T>, canExecute?: (dev: Mobile.IDevice) => boolean, options?: {
+        allowNoDevices?: boolean;
+    }): Promise<Mobile.IDeviceActionResult<T>[]>;
+    protected startEmulatorIfNecessary(deviceInitOpts?: Mobile.IDevicesServicesInitializationOptions): Promise<void>;
+    private _startEmulatorIfNecessary;
+    private _deviceInitializePromise;
+    initialize(data?: Mobile.IDevicesServicesInitializationOptions): Promise<void>;
+    getPlatformsFromDeviceDescriptors(deviceDescriptors: ILiveSyncDeviceDescriptor[]): string[];
+    private initializeCore;
+    get hasDevices(): boolean;
+    isOnlyiOSSimultorRunning(): boolean;
+    getDeviceByDeviceOption(): Mobile.IDevice;
+    mapAbstractToTcpPort(deviceIdentifier: string, appIdentifier: string, framework: string): Promise<string>;
+    getDebuggableApps(deviceIdentifiers: string[]): Promise<Mobile.IDeviceApplicationInformation[]>[];
+    getDebuggableViews(deviceIdentifier: string, appIdentifier: string): Promise<Mobile.IDebugWebViewInfo[]>;
+    private getDebuggableAppsCore;
+    private deployOnDevice;
+    private filterDevicesByPlatform;
+    private validateIndex;
+    private resolveEmulatorServices;
+    protected startEmulatorCore(deviceInitOpts?: Mobile.IDevicesServicesInitializationOptions): Promise<void>;
+    private executeCore;
+    private isApplicationInstalledOnDevice;
+    private getDeviceLookingOptions;
+    private getEmulatorError;
+}

package/lib/common/mobile/mobile-core/ios-device-discovery.d.ts

@@ -0,0 +1,12 @@
+import { DeviceDiscovery } from "./device-discovery";
+import { IInjector } from "../../definitions/yok";
+export declare class IOSDeviceDiscovery extends DeviceDiscovery {
+    private $injector;
+    private $logger;
+    private $mobileHelper;
+    private $iosDeviceOperations;
+    private $devicePlatformsConstants;
+    constructor($injector: IInjector, $logger: ILogger, $mobileHelper: Mobile.IMobileHelper, $iosDeviceOperations: IIOSDeviceOperations, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants);
+    startLookingForDevices(options?: Mobile.IDeviceLookingOptions): Promise<void>;
+    private createDevice;
+}

package/lib/common/mobile/mobile-core/ios-simulator-discovery.d.ts

@@ -0,0 +1,20 @@
+import { DeviceDiscovery } from "./device-discovery";
+import { IHostInfo } from "../../declarations";
+import { IInjector } from "../../definitions/yok";
+export declare class IOSSimulatorDiscovery extends DeviceDiscovery {
+    private $injector;
+    private $iOSSimResolver;
+    private $mobileHelper;
+    private $hostInfo;
+    private $iOSEmulatorServices;
+    private cachedSimulators;
+    private availableSimulators;
+    constructor($injector: IInjector, $iOSSimResolver: Mobile.IiOSSimResolver, $mobileHelper: Mobile.IMobileHelper, $hostInfo: IHostInfo, $iOSEmulatorServices: Mobile.IiOSSimulatorService);
+    startLookingForDevices(options?: Mobile.IDeviceLookingOptions): Promise<void>;
+    private checkForDevices;
+    checkForAvailableSimulators(): Promise<Mobile.IDeviceInfo[]>;
+    private createAndAddDevice;
+    private deleteAndRemoveDevice;
+    private raiseOnEmulatorImagesFound;
+    private raiseOnEmulatorImagesLost;
+}

package/lib/common/mobile/mobile-helper.d.ts

@@ -0,0 +1,22 @@
+import { IProjectData } from "../../definitions/project";
+import { IErrors, IFileSystem } from "../declarations";
+import { ITempService } from "../../definitions/temp-service";
+export declare class MobileHelper implements Mobile.IMobileHelper {
+    private $errors;
+    private $fs;
+    private $devicePlatformsConstants;
+    private $tempService;
+    private static DEVICE_PATH_SEPARATOR;
+    constructor($errors: IErrors, $fs: IFileSystem, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $tempService: ITempService);
+    get platformNames(): string[];
+    isAndroidPlatform(platform: string): boolean;
+    isiOSPlatform(platform: string): boolean;
+    isvisionOSPlatform(platform: string): boolean;
+    isApplePlatform(platform: string): boolean;
+    normalizePlatformName(platform: string): string;
+    validatePlatformName(platform: string): string;
+    buildDevicePath(...args: string[]): string;
+    correctDevicePath(filePath: string): string;
+    isiOSTablet(deviceName: string): boolean;
+    getDeviceFileContent(device: Mobile.IDevice, deviceFilePath: string, projectData: IProjectData): Promise<string>;
+}

package/lib/common/mobile/wp8/wp8-emulator-services.d.ts

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

package/lib/common/opener.d.ts

@@ -0,0 +1,4 @@
+import { IOpener } from "../declarations";
+export declare class Opener implements IOpener {
+    open(target: string, appname?: string): any;
+}

package/lib/common/os-info.d.ts

@@ -0,0 +1,7 @@
+import { IOsInfo } from "./declarations";
+export declare class OsInfo implements IOsInfo {
+    type(): string;
+    release(): string;
+    arch(): string;
+    platform(): string;
+}

package/lib/common/plist-parser.d.ts

@@ -0,0 +1,5 @@
+import { IPlistParser } from "./declarations";
+export declare class PlistParser implements IPlistParser {
+    parseFile(plistFilePath: string): Promise<any>;
+    parseFileSync(plistFilePath: string): any;
+}