frida 16.7.14 → 16.7.15

package/dist/device.d.ts

@@ -1,156 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { Application } from "./application";
-import { Bus } from "./bus";
-import { Cancellable } from "./cancellable";
-import { Child } from "./child";
-import { Crash } from "./crash";
-import { Icon } from "./icon";
-import { IOStream } from "./iostream";
-import { Process } from "./process";
-import { Service } from "./service";
-import { Session } from "./session";
-import { Signal } from "./signals";
-import { Spawn } from "./spawn";
-import { SystemParameters } from "./system_parameters";
-import { inspect } from "util";
-export declare class Device {
-    private impl;
-    spawnAdded: Signal<SpawnAddedHandler>;
-    spawnRemoved: Signal<SpawnRemovedHandler>;
-    childAdded: Signal<ChildAddedHandler>;
-    childRemoved: Signal<ChildRemovedHandler>;
-    processCrashed: Signal<ProcessCrashedHandler>;
-    output: Signal<OutputHandler>;
-    uninjected: Signal<UninjectedHandler>;
-    lost: Signal<DeviceLostHandler>;
-    bus: Bus;
-    constructor(impl: any);
-    get id(): string;
-    get name(): string;
-    get icon(): Icon | null;
-    get type(): DeviceType;
-    get isLost(): boolean;
-    querySystemParameters(cancellable?: Cancellable): Promise<SystemParameters>;
-    getFrontmostApplication(options?: FrontmostQueryOptions, cancellable?: Cancellable): Promise<Application | null>;
-    enumerateApplications(options?: ApplicationQueryOptions, cancellable?: Cancellable): Promise<Application[]>;
-    enumerateProcesses(options?: ProcessQueryOptions, cancellable?: Cancellable): Promise<Process[]>;
-    getProcess(name: string, options?: ProcessMatchOptions, cancellable?: Cancellable): Promise<Process>;
-    enableSpawnGating(cancellable?: Cancellable): Promise<void>;
-    disableSpawnGating(cancellable?: Cancellable): Promise<void>;
-    enumeratePendingSpawn(cancellable?: Cancellable): Promise<Spawn[]>;
-    enumeratePendingChildren(cancellable?: Cancellable): Promise<Child[]>;
-    spawn(program: string | string[], options?: SpawnOptions, cancellable?: Cancellable): Promise<ProcessID>;
-    input(target: TargetProcess, data: Buffer, cancellable?: Cancellable): Promise<void>;
-    resume(target: TargetProcess, cancellable?: Cancellable): Promise<void>;
-    kill(target: TargetProcess, cancellable?: Cancellable): Promise<void>;
-    attach(target: TargetProcess, options?: SessionOptions, cancellable?: Cancellable): Promise<Session>;
-    injectLibraryFile(target: TargetProcess, path: string, entrypoint: string, data: string, cancellable?: Cancellable): Promise<InjecteeID>;
-    injectLibraryBlob(target: TargetProcess, blob: Buffer, entrypoint: string, data: string, cancellable?: Cancellable): Promise<InjecteeID>;
-    openChannel(address: string, cancellable?: Cancellable): Promise<IOStream>;
-    openService(address: string, cancellable?: Cancellable): Promise<Service>;
-    unpair(cancellable?: Cancellable): Promise<void>;
-    private getPid;
-    [inspect.custom](depth: any, options: any): string;
-}
-export type ProcessID = number;
-export type ProcessName = string;
-export type InjecteeID = number;
-export type FileDescriptor = number;
-export type SpawnAddedHandler = (spawn: Spawn) => void;
-export type SpawnRemovedHandler = (spawn: Spawn) => void;
-export type ChildAddedHandler = (child: Child) => void;
-export type ChildRemovedHandler = (child: Child) => void;
-export type ProcessCrashedHandler = (crash: Crash) => void;
-export type OutputHandler = (pid: ProcessID, fd: FileDescriptor, data: Buffer) => void;
-export type UninjectedHandler = (id: InjecteeID) => void;
-export type DeviceLostHandler = () => void;
-export declare enum DeviceType {
-    Local = "local",
-    Remote = "remote",
-    Usb = "usb"
-}
-export interface FrontmostQueryOptions {
-    /**
-     * How much data to collect about the frontmost application. The default is `Scope.Minimal`,
-     * which means no parameters will be collected. Specify `Scope.Metadata` to collect all
-     * parameters except icons, which can be included by specifying `Scope.Full`.
-     */
-    scope?: Scope;
-}
-export interface ApplicationQueryOptions {
-    /**
-     * Limit enumeration to one or more application IDs only. Typically used to fetch additional
-     * details about a subset, e.g. based on user interaction.
-     */
-    identifiers?: string[];
-    /**
-     * How much data to collect about each application. The default is `Scope.Minimal`, which
-     * means no parameters will be collected. Specify `Scope.Metadata` to collect all parameters
-     * except icons, which can be included by specifying `Scope.Full`.
-     */
-    scope?: Scope;
-}
-export interface ProcessQueryOptions {
-    /**
-     * Limit enumeration to one or more process IDs only. Typically used to fetch additional
-     * details about a subset, e.g. based on user interaction.
-     */
-    pids?: number[];
-    /**
-     * How much data to collect about each process. The default is `Scope.Minimal`, which
-     * means no parameters will be collected. Specify `Scope.Metadata` to collect all
-     * parameters except icons, which can be included by specifying `Scope.Full`.
-     */
-    scope?: Scope;
-}
-export interface ProcessMatchOptions {
-    /**
-     * How much data to collect about the matching process. The default is `Scope.Minimal`,
-     * which means no parameters will be collected. Specify `Scope.Metadata` to collect all
-     * parameters except icons, which can be included by specifying `Scope.Full`.
-     */
-    scope?: Scope;
-}
-/**
- * How much data to collect about a given application or process.
- */
-export declare enum Scope {
-    /**
-     * Don't collect any parameters. This is the default.
-     */
-    Minimal = "minimal",
-    /**
-     * Collect all parameters except icons.
-     */
-    Metadata = "metadata",
-    /**
-     * Collect all parameters, including icons.
-     */
-    Full = "full"
-}
-export interface SpawnOptions {
-    argv?: string[];
-    envp?: {
-        [name: string]: string;
-    };
-    env?: {
-        [name: string]: string;
-    };
-    cwd?: string;
-    stdio?: Stdio;
-    [name: string]: any;
-}
-export declare enum Stdio {
-    Inherit = "inherit",
-    Pipe = "pipe"
-}
-export type TargetProcess = ProcessID | ProcessName;
-export interface SessionOptions {
-    realm?: Realm;
-    persistTimeout?: number;
-}
-export declare enum Realm {
-    Native = "native",
-    Emulated = "emulated"
-}

package/dist/device.js

@@ -1,188 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Realm = exports.Stdio = exports.Scope = exports.DeviceType = exports.Device = void 0;
-const bus_1 = require("./bus");
-const iostream_1 = require("./iostream");
-const service_1 = require("./service");
-const session_1 = require("./session");
-const signals_1 = require("./signals");
-const minimatch_1 = require("minimatch");
-const util_1 = require("util");
-class Device {
-    constructor(impl) {
-        this.impl = impl;
-        this.bus = new bus_1.Bus(impl.bus);
-        const { signals } = impl;
-        this.spawnAdded = new signals_1.Signal(signals, "spawn-added");
-        this.spawnRemoved = new signals_1.Signal(signals, "spawn-removed");
-        this.childAdded = new signals_1.Signal(signals, "child-added");
-        this.childRemoved = new signals_1.Signal(signals, "child-removed");
-        this.processCrashed = new signals_1.Signal(signals, "process-crashed");
-        this.output = new signals_1.Signal(signals, "output");
-        this.uninjected = new signals_1.Signal(signals, "uninjected");
-        this.lost = new signals_1.Signal(signals, "lost");
-    }
-    get id() {
-        return this.impl.id;
-    }
-    get name() {
-        return this.impl.name;
-    }
-    get icon() {
-        return this.impl.icon;
-    }
-    get type() {
-        return this.impl.type;
-    }
-    get isLost() {
-        return this.impl.isLost;
-    }
-    querySystemParameters(cancellable) {
-        return this.impl.querySystemParameters(cancellable);
-    }
-    getFrontmostApplication(options = {}, cancellable) {
-        const { scope = null, } = options;
-        return this.impl.getFrontmostApplication(scope, cancellable);
-    }
-    enumerateApplications(options = {}, cancellable) {
-        const { identifiers = [], scope = null, } = options;
-        return this.impl.enumerateApplications(identifiers, scope, cancellable);
-    }
-    enumerateProcesses(options = {}, cancellable) {
-        const { pids = [], scope = null, } = options;
-        return this.impl.enumerateProcesses(pids, scope, cancellable);
-    }
-    async getProcess(name, options = {}, cancellable) {
-        const { scope = Scope.Minimal, } = options;
-        const processes = await this.enumerateProcesses({ scope }, cancellable);
-        const mm = new minimatch_1.Minimatch(name.toLowerCase());
-        const matching = processes.filter(process => mm.match(process.name.toLowerCase()));
-        if (matching.length === 1) {
-            return matching[0];
-        }
-        else if (matching.length > 1) {
-            throw new Error("Ambiguous name; it matches: " + matching.map(process => `${process.name} (pid: ${process.pid})`).join(", "));
-        }
-        else {
-            throw new Error("Process not found");
-        }
-    }
-    enableSpawnGating(cancellable) {
-        return this.impl.enableSpawnGating(cancellable);
-    }
-    disableSpawnGating(cancellable) {
-        return this.impl.disableSpawnGating(cancellable);
-    }
-    enumeratePendingSpawn(cancellable) {
-        return this.impl.enumeratePendingSpawn(cancellable);
-    }
-    enumeratePendingChildren(cancellable) {
-        return this.impl.enumeratePendingChildren(cancellable);
-    }
-    spawn(program, options = {}, cancellable) {
-        const pendingOptions = Object.assign({}, options);
-        let argv = consumeOption("argv");
-        if (typeof program !== "string") {
-            argv = program;
-            program = argv[0];
-            if (argv.length === 1) {
-                argv = null;
-            }
-        }
-        const envp = consumeOption("envp");
-        const env = consumeOption("env");
-        const cwd = consumeOption("cwd");
-        const stdio = consumeOption("stdio");
-        const aux = pendingOptions;
-        return this.impl.spawn(program, argv, envp, env, cwd, stdio, aux, cancellable);
-        function consumeOption(name) {
-            const value = pendingOptions[name];
-            delete pendingOptions[name];
-            return value !== null && value !== void 0 ? value : null;
-        }
-    }
-    async input(target, data, cancellable) {
-        const pid = await this.getPid(target, cancellable);
-        return this.impl.input(pid, data, cancellable);
-    }
-    async resume(target, cancellable) {
-        const pid = await this.getPid(target, cancellable);
-        return this.impl.resume(pid, cancellable);
-    }
-    async kill(target, cancellable) {
-        const pid = await this.getPid(target, cancellable);
-        return this.impl.kill(pid, cancellable);
-    }
-    async attach(target, options = {}, cancellable) {
-        const { realm = null, persistTimeout = null, } = options;
-        const pid = await this.getPid(target, cancellable);
-        return new session_1.Session(await this.impl.attach(pid, realm, persistTimeout, cancellable));
-    }
-    async injectLibraryFile(target, path, entrypoint, data, cancellable) {
-        const pid = await this.getPid(target, cancellable);
-        return this.impl.injectLibraryFile(pid, path, entrypoint, data, cancellable);
-    }
-    async injectLibraryBlob(target, blob, entrypoint, data, cancellable) {
-        const pid = await this.getPid(target, cancellable);
-        return this.impl.injectLibraryBlob(pid, blob, entrypoint, data, cancellable);
-    }
-    async openChannel(address, cancellable) {
-        return new iostream_1.IOStream(await this.impl.openChannel(address, cancellable));
-    }
-    async openService(address, cancellable) {
-        return new service_1.Service(await this.impl.openService(address, cancellable));
-    }
-    async unpair(cancellable) {
-        await this.impl.unpair(cancellable);
-    }
-    async getPid(target, cancellable) {
-        if (typeof target === "number") {
-            return target;
-        }
-        const process = await this.getProcess(target, {}, cancellable);
-        return process.pid;
-    }
-    [util_1.inspect.custom](depth, options) {
-        return "Device " + (0, util_1.inspect)({
-            id: this.id,
-            name: this.name,
-            icon: this.icon,
-            type: this.type
-        }, options);
-    }
-}
-exports.Device = Device;
-var DeviceType;
-(function (DeviceType) {
-    DeviceType["Local"] = "local";
-    DeviceType["Remote"] = "remote";
-    DeviceType["Usb"] = "usb";
-})(DeviceType || (exports.DeviceType = DeviceType = {}));
-/**
- * How much data to collect about a given application or process.
- */
-var Scope;
-(function (Scope) {
-    /**
-     * Don't collect any parameters. This is the default.
-     */
-    Scope["Minimal"] = "minimal";
-    /**
-     * Collect all parameters except icons.
-     */
-    Scope["Metadata"] = "metadata";
-    /**
-     * Collect all parameters, including icons.
-     */
-    Scope["Full"] = "full";
-})(Scope || (exports.Scope = Scope = {}));
-var Stdio;
-(function (Stdio) {
-    Stdio["Inherit"] = "inherit";
-    Stdio["Pipe"] = "pipe";
-})(Stdio || (exports.Stdio = Stdio = {}));
-var Realm;
-(function (Realm) {
-    Realm["Native"] = "native";
-    Realm["Emulated"] = "emulated";
-})(Realm || (exports.Realm = Realm = {}));

package/dist/device_manager.d.ts

@@ -1,25 +0,0 @@
-/// <reference types="node" />
-import { Cancellable } from "./cancellable";
-import { Device } from "./device";
-import { Signal } from "./signals";
-import { inspect } from "util";
-export declare class DeviceManager {
-    private impl;
-    added: Signal<DeviceAddedHandler>;
-    removed: Signal<DeviceRemovedHandler>;
-    changed: Signal<DevicesChangedHandler>;
-    constructor();
-    enumerateDevices(cancellable?: Cancellable): Promise<Device[]>;
-    addRemoteDevice(address: string, options?: RemoteDeviceOptions, cancellable?: Cancellable): Promise<Device>;
-    removeRemoteDevice(address: string, cancellable?: Cancellable): Promise<void>;
-    [inspect.custom](): string;
-}
-export interface RemoteDeviceOptions {
-    certificate?: string;
-    origin?: string;
-    token?: string;
-    keepaliveInterval?: number;
-}
-export type DeviceAddedHandler = (device: Device) => void;
-export type DeviceRemovedHandler = (device: Device) => void;
-export type DevicesChangedHandler = () => void;

package/dist/device_manager.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeviceManager = void 0;
-const device_1 = require("./device");
-const native_1 = require("./native");
-const signals_1 = require("./signals");
-const util_1 = require("util");
-class DeviceManager {
-    constructor() {
-        this.impl = new native_1.binding.DeviceManager();
-        const signals = new DeviceManagerSignals(this.impl.signals);
-        this.added = new signals_1.Signal(signals, "added");
-        this.removed = new signals_1.Signal(signals, "removed");
-        this.changed = new signals_1.Signal(signals, "changed");
-    }
-    async enumerateDevices(cancellable) {
-        const devices = await this.impl.enumerateDevices(cancellable);
-        return devices.map(impl => new device_1.Device(impl));
-    }
-    async addRemoteDevice(address, options = {}, cancellable) {
-        const { certificate = null, origin = null, token = null, keepaliveInterval = null, } = options;
-        return new device_1.Device(await this.impl.addRemoteDevice(address, certificate, origin, token, keepaliveInterval, cancellable));
-    }
-    removeRemoteDevice(address, cancellable) {
-        return this.impl.removeRemoteDevice(address, cancellable);
-    }
-    [util_1.inspect.custom]() {
-        return "DeviceManager {}";
-    }
-}
-exports.DeviceManager = DeviceManager;
-class DeviceManagerSignals extends signals_1.SignalAdapter {
-    constructor(signals) {
-        super(signals);
-    }
-    getProxy(name, userHandler) {
-        if (name === "added" || name === "removed") {
-            return impl => userHandler(new device_1.Device(impl));
-        }
-        return null;
-    }
-}

package/dist/endpoint_parameters.d.ts

@@ -1,26 +0,0 @@
-/// <reference types="node" />
-import { AuthenticatedSessionInfo } from "./authentication";
-import { inspect } from "util";
-export declare class EndpointParameters {
-    private impl;
-    constructor({ address, port, certificate, origin, authentication, assetRoot, }?: EndpointParametersSubset);
-    [inspect.custom](): string;
-}
-export interface EndpointParametersSubset {
-    address?: string;
-    port?: number;
-    certificate?: string;
-    origin?: string;
-    authentication?: AuthenticationScheme;
-    assetRoot?: string;
-}
-export type AuthenticationScheme = TokenAuthenticationScheme | CallbackAuthenticationScheme;
-export interface TokenAuthenticationScheme {
-    scheme: "token";
-    token: string;
-}
-export interface CallbackAuthenticationScheme {
-    scheme: "callback";
-    callback: AuthenticationCallback;
-}
-export type AuthenticationCallback = (token: string) => Promise<AuthenticatedSessionInfo>;

package/dist/endpoint_parameters.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EndpointParameters = void 0;
-const native_1 = require("./native");
-const util_1 = require("util");
-class EndpointParameters {
-    constructor({ address = null, port = null, certificate = null, origin = null, authentication = null, assetRoot = null, } = {}) {
-        let authToken = null;
-        let authCallback = null;
-        if (authentication !== null) {
-            if (authentication.scheme === "token") {
-                authToken = authentication.token;
-            }
-            else {
-                authCallback = authentication.callback;
-            }
-        }
-        this.impl = new native_1.binding.EndpointParameters(address, port, certificate, origin, authToken, authCallback, assetRoot);
-    }
-    [util_1.inspect.custom]() {
-        return "EndpointParameters {}";
-    }
-}
-exports.EndpointParameters = EndpointParameters;

package/dist/icon.d.ts

@@ -1,14 +0,0 @@
-/// <reference types="node" />
-export type Icon = RGBAIcon | PNGIcon;
-export interface RGBAIcon {
-    format: "rgba";
-    width: number;
-    height: number;
-    image: Buffer;
-}
-export interface PNGIcon {
-    format: "png";
-    width?: number;
-    height?: number;
-    image: Buffer;
-}

package/dist/icon.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -1,161 +0,0 @@
-/// <reference types="node" />
-import * as applicationModule from "./application";
-import * as authenticationModule from "./authentication";
-import * as busModule from "./bus";
-import * as cancellableModule from "./cancellable";
-import * as childModule from "./child";
-import * as crashModule from "./crash";
-import * as deviceManagerModule from "./device_manager";
-import * as deviceModule from "./device";
-import * as endpointParametersModule from "./endpoint_parameters";
-import * as iconModule from "./icon";
-import * as iostreamModule from "./iostream";
-import * as portalMembershipModule from "./portal_membership";
-import * as portalServiceModule from "./portal_service";
-import * as processModule from "./process";
-import * as relayModule from "./relay";
-import * as scriptModule from "./script";
-import * as serviceModule from "./service";
-import * as sessionModule from "./session";
-import * as socketAddressModule from "./socket_address";
-import * as spawnModule from "./spawn";
-import * as systemParametersModule from "./system_parameters";
-export type DeviceManager = deviceManagerModule.DeviceManager;
-export declare const DeviceManager: typeof deviceManagerModule.DeviceManager;
-export type RemoteDeviceOptions = deviceManagerModule.RemoteDeviceOptions;
-export type DeviceAddedHandler = deviceManagerModule.DeviceAddedHandler;
-export type DeviceRemovedHandler = deviceManagerModule.DeviceRemovedHandler;
-export type DevicesChangedHandler = deviceManagerModule.DevicesChangedHandler;
-export type Device = deviceModule.Device;
-export declare const Device: typeof deviceModule.Device;
-export type ProcessID = deviceModule.ProcessID;
-export type ProcessName = deviceModule.ProcessName;
-export type InjecteeID = deviceModule.InjecteeID;
-export type FileDescriptor = deviceModule.FileDescriptor;
-export type SpawnAddedHandler = deviceModule.SpawnAddedHandler;
-export type SpawnRemovedHandler = deviceModule.SpawnRemovedHandler;
-export type ChildAddedHandler = deviceModule.ChildAddedHandler;
-export type ChildRemovedHandler = deviceModule.ChildRemovedHandler;
-export type OutputHandler = deviceModule.OutputHandler;
-export type UninjectedHandler = deviceModule.UninjectedHandler;
-export type DeviceLostHandler = deviceModule.DeviceLostHandler;
-export type DeviceType = deviceModule.DeviceType;
-export declare const DeviceType: typeof deviceModule.DeviceType;
-export type FrontmostQueryOptions = deviceModule.FrontmostQueryOptions;
-export type ApplicationQueryOptions = deviceModule.ApplicationQueryOptions;
-export type ProcessQueryOptions = deviceModule.ProcessQueryOptions;
-export type ProcessMatchOptions = deviceModule.ProcessMatchOptions;
-export type Scope = deviceModule.Scope;
-export declare const Scope: typeof deviceModule.Scope;
-export type SpawnOptions = deviceModule.SpawnOptions;
-export type Stdio = deviceModule.Stdio;
-export declare const Stdio: typeof deviceModule.Stdio;
-export type TargetProcess = deviceModule.TargetProcess;
-export type SessionOptions = deviceModule.SessionOptions;
-export type Realm = deviceModule.Realm;
-export declare const Realm: typeof deviceModule.Realm;
-export type SystemParameters = systemParametersModule.SystemParameters;
-export type SystemInterface = systemParametersModule.SystemInterface;
-export type NetworkInterface = systemParametersModule.NetworkInterface;
-export type CellularInterface = systemParametersModule.CellularInterface;
-export type Session = sessionModule.Session;
-export declare const Session: typeof sessionModule.Session;
-export type SessionDetachedHandler = sessionModule.SessionDetachedHandler;
-export type SessionDetachReason = sessionModule.SessionDetachReason;
-export declare const SessionDetachReason: typeof sessionModule.SessionDetachReason;
-export type PeerOptions = sessionModule.PeerOptions;
-export type PortalOptions = sessionModule.PortalOptions;
-export type Script = scriptModule.Script;
-export declare const Script: typeof scriptModule.Script;
-export type ScriptOptions = scriptModule.ScriptOptions;
-export type SnapshotOptions = scriptModule.SnapshotOptions;
-export type ScriptRuntime = scriptModule.ScriptRuntime;
-export declare const ScriptRuntime: typeof scriptModule.ScriptRuntime;
-export type ScriptDestroyedHandler = scriptModule.ScriptDestroyedHandler;
-export type ScriptMessageHandler = scriptModule.ScriptMessageHandler;
-export type ScriptLogHandler = scriptModule.ScriptLogHandler;
-export type Message = scriptModule.Message;
-export type MessageType = scriptModule.MessageType;
-export declare const MessageType: typeof scriptModule.MessageType;
-export type SendMessage = scriptModule.SendMessage;
-export type ErrorMessage = scriptModule.ErrorMessage;
-export type ScriptExports = scriptModule.ScriptExports;
-export type LogLevel = scriptModule.LogLevel;
-export declare const LogLevel: typeof scriptModule.LogLevel;
-export type EnableDebuggerOptions = scriptModule.EnableDebuggerOptions;
-export type Relay = relayModule.Relay;
-export declare const Relay: typeof relayModule.Relay;
-export type RelayProperties = relayModule.RelayProperties;
-export type RelayKind = relayModule.RelayKind;
-export declare const RelayKind: typeof relayModule.RelayKind;
-export type PortalMembership = portalMembershipModule.PortalMembership;
-export declare const PortalMembership: typeof portalMembershipModule.PortalMembership;
-export type PortalService = portalServiceModule.PortalService;
-export declare const PortalService: typeof portalServiceModule.PortalService;
-export type PortalServiceOptions = portalServiceModule.PortalServiceOptions;
-export type PortalConnectionId = portalServiceModule.PortalConnectionId;
-export type PortalConnectionTag = portalServiceModule.PortalConnectionTag;
-export type PortalNodeConnectedHandler = portalServiceModule.PortalNodeConnectedHandler;
-export type PortalNodeJoinedHandler = portalServiceModule.PortalNodeJoinedHandler;
-export type PortalNodeLeftHandler = portalServiceModule.PortalNodeLeftHandler;
-export type PortalNodeDisconnectedHandler = portalServiceModule.PortalNodeDisconnectedHandler;
-export type PortalControllerConnectedHandler = portalServiceModule.PortalControllerConnectedHandler;
-export type PortalControllerDisconnectedHandler = portalServiceModule.PortalControllerDisconnectedHandler;
-export type PortalAuthenticatedHandler = portalServiceModule.PortalAuthenticatedHandler;
-export type PortalSubscribeHandler = portalServiceModule.PortalSubscribeHandler;
-export type PortalMessageHandler = portalServiceModule.PortalMessageHandler;
-export type EndpointParameters = endpointParametersModule.EndpointParameters;
-export declare const EndpointParameters: typeof endpointParametersModule.EndpointParameters;
-export type EndpointParametersSubset = endpointParametersModule.EndpointParametersSubset;
-export type AuthenticationScheme = endpointParametersModule.AuthenticationScheme;
-export type TokenAuthenticationScheme = endpointParametersModule.TokenAuthenticationScheme;
-export type CallbackAuthenticationScheme = endpointParametersModule.CallbackAuthenticationScheme;
-export type AuthenticationCallback = endpointParametersModule.AuthenticationCallback;
-export type AuthenticatedSessionInfo = authenticationModule.AuthenticatedSessionInfo;
-export type IOStream = iostreamModule.IOStream;
-export declare const IOStream: typeof iostreamModule.IOStream;
-export type Cancellable = cancellableModule.Cancellable;
-export declare const Cancellable: typeof cancellableModule.Cancellable;
-export type Application = applicationModule.Application;
-export type ApplicationParameters = applicationModule.ApplicationParameters;
-export type Process = processModule.Process;
-export type ProcessParameters = processModule.ProcessParameters;
-export type Spawn = spawnModule.Spawn;
-export type Child = childModule.Child;
-export type ChildOrigin = childModule.ChildOrigin;
-export declare const ChildOrigin: typeof childModule.ChildOrigin;
-export type Crash = crashModule.Crash;
-export type CrashParameters = crashModule.CrashParameters;
-export type Icon = iconModule.Icon;
-export type RGBAIcon = iconModule.RGBAIcon;
-export type PNGIcon = iconModule.PNGIcon;
-export type Bus = busModule.Bus;
-export declare const Bus: typeof busModule.Bus;
-export type BusDetachedHandler = busModule.BusDetachedHandler;
-export type BusMessageHandler = busModule.BusMessageHandler;
-export type Service = serviceModule.Service;
-export declare const Service: typeof serviceModule.Service;
-export type ServiceCloseHandler = serviceModule.ServiceCloseHandler;
-export type ServiceMessageHandler = serviceModule.ServiceMessageHandler;
-export type SocketAddress = socketAddressModule.SocketAddress;
-export type IPV4SocketAddress = socketAddressModule.IPV4SocketAddress;
-export type IPV6SocketAddress = socketAddressModule.IPV6SocketAddress;
-export type AnonymousUnixSocketAddress = socketAddressModule.AnonymousUnixSocketAddress;
-export type PathUnixSocketAddress = socketAddressModule.PathUnixSocketAddress;
-export type AbstractUnixSocketAddress = socketAddressModule.AbstractUnixSocketAddress;
-export declare function querySystemParameters(cancellable?: Cancellable): Promise<SystemParameters>;
-export declare function spawn(program: string | string[], options?: SpawnOptions, cancellable?: Cancellable): Promise<number>;
-export declare function resume(target: number | string, cancellable?: Cancellable): Promise<void>;
-export declare function kill(target: number | string, cancellable?: Cancellable): Promise<void>;
-export declare function attach(target: TargetProcess, options?: SessionOptions, cancellable?: Cancellable): Promise<Session>;
-export declare function injectLibraryFile(target: number | string, path: string, entrypoint: string, data: string, cancellable?: Cancellable): Promise<number>;
-export declare function injectLibraryBlob(target: number | string, blob: Buffer, entrypoint: string, data: string, cancellable?: Cancellable): Promise<number>;
-export declare function enumerateDevices(cancellable?: Cancellable): Promise<Device[]>;
-export declare function getDeviceManager(): DeviceManager;
-export declare function getLocalDevice(cancellable?: Cancellable): Promise<Device>;
-export declare function getRemoteDevice(cancellable?: Cancellable): Promise<Device>;
-export declare function getUsbDevice(options?: GetDeviceOptions, cancellable?: Cancellable): Promise<Device>;
-export declare function getDevice(id: string, options?: GetDeviceOptions, cancellable?: Cancellable): Promise<Device>;
-export interface GetDeviceOptions {
-    timeout?: number | null;
-}