frida 16.7.14 → 16.7.15

package/lib/index.ts

@@ -1,316 +0,0 @@
-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 const DeviceManager = 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 const Device = 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 const DeviceType = 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 const Scope = deviceModule.Scope;
-export type SpawnOptions = deviceModule.SpawnOptions;
-export type Stdio = deviceModule.Stdio;
-export const Stdio = deviceModule.Stdio;
-export type TargetProcess = deviceModule.TargetProcess;
-export type SessionOptions = deviceModule.SessionOptions;
-export type Realm = deviceModule.Realm;
-export const Realm = 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 const Session = sessionModule.Session;
-export type SessionDetachedHandler = sessionModule.SessionDetachedHandler;
-export type SessionDetachReason = sessionModule.SessionDetachReason;
-export const SessionDetachReason = sessionModule.SessionDetachReason;
-export type PeerOptions = sessionModule.PeerOptions;
-export type PortalOptions = sessionModule.PortalOptions;
-
-export type Script = scriptModule.Script;
-export const Script = scriptModule.Script;
-export type ScriptOptions = scriptModule.ScriptOptions;
-export type SnapshotOptions = scriptModule.SnapshotOptions;
-export type ScriptRuntime = scriptModule.ScriptRuntime;
-export const ScriptRuntime = 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 const MessageType = scriptModule.MessageType;
-export type SendMessage = scriptModule.SendMessage;
-export type ErrorMessage = scriptModule.ErrorMessage;
-export type ScriptExports = scriptModule.ScriptExports;
-export type LogLevel = scriptModule.LogLevel;
-export const LogLevel = scriptModule.LogLevel;
-export type EnableDebuggerOptions = scriptModule.EnableDebuggerOptions;
-
-export type Relay = relayModule.Relay;
-export const Relay = relayModule.Relay;
-export type RelayProperties = relayModule.RelayProperties;
-export type RelayKind = relayModule.RelayKind;
-export const RelayKind = relayModule.RelayKind;
-
-export type PortalMembership = portalMembershipModule.PortalMembership;
-export const PortalMembership = portalMembershipModule.PortalMembership;
-
-export type PortalService = portalServiceModule.PortalService;
-export const PortalService = 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 const EndpointParameters = 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 const IOStream = iostreamModule.IOStream;
-export type Cancellable = cancellableModule.Cancellable;
-export const Cancellable = 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 const ChildOrigin = 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 const Bus = busModule.Bus;
-export type BusDetachedHandler = busModule.BusDetachedHandler;
-export type BusMessageHandler = busModule.BusMessageHandler;
-export type Service = serviceModule.Service;
-export const Service = 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;
-
-let sharedDeviceManager: DeviceManager = null;
-
-export async function querySystemParameters(cancellable?: Cancellable): Promise<SystemParameters> {
-    const device = await getLocalDevice(cancellable);
-    return await device.querySystemParameters(cancellable);
-}
-
-export async function spawn(program: string | string[], options: SpawnOptions = {}, cancellable?: Cancellable): Promise<number> {
-    const device = await getLocalDevice(cancellable);
-    return await device.spawn(program, options, cancellable);
-}
-
-export async function resume(target: number | string, cancellable?: Cancellable): Promise<void> {
-    const device = await getLocalDevice(cancellable);
-    await device.resume(target, cancellable);
-}
-
-export async function kill(target: number | string, cancellable?: Cancellable): Promise<void> {
-    const device = await getLocalDevice(cancellable);
-    await device.kill(target, cancellable);
-}
-
-export async function attach(target: TargetProcess, options: SessionOptions = {}, cancellable?: Cancellable): Promise<Session> {
-    const device = await getLocalDevice(cancellable);
-    return await device.attach(target, options, cancellable);
-}
-
-export async function injectLibraryFile(target: number | string, path: string, entrypoint: string, data: string,
-        cancellable?: Cancellable): Promise<number> {
-    const device = await getLocalDevice(cancellable);
-    return await device.injectLibraryFile(target, path, entrypoint, data, cancellable);
-}
-
-export async function injectLibraryBlob(target: number | string, blob: Buffer, entrypoint: string, data: string,
-        cancellable?: Cancellable): Promise<number> {
-    const device = await getLocalDevice(cancellable);
-    return await device.injectLibraryBlob(target, blob, entrypoint, data, cancellable);
-}
-
-export async function enumerateDevices(cancellable?: Cancellable): Promise<Device[]> {
-    const deviceManager = getDeviceManager();
-    return await deviceManager.enumerateDevices(cancellable);
-};
-
-export function getDeviceManager(): DeviceManager {
-    if (sharedDeviceManager === null) {
-        sharedDeviceManager = new deviceManagerModule.DeviceManager();
-    }
-    return sharedDeviceManager;
-}
-
-export function getLocalDevice(cancellable?: Cancellable): Promise<Device> {
-    return getMatchingDevice(device => device.type === DeviceType.Local, {}, cancellable);
-}
-
-export function getRemoteDevice(cancellable?: Cancellable): Promise<Device> {
-    return getMatchingDevice(device => device.type === DeviceType.Remote, {}, cancellable);
-}
-
-export function getUsbDevice(options?: GetDeviceOptions, cancellable?: Cancellable): Promise<Device> {
-    return getMatchingDevice(device => device.type === DeviceType.Usb, options, cancellable);
-}
-
-export function getDevice(id: string, options?: GetDeviceOptions, cancellable?: Cancellable): Promise<Device> {
-    return getMatchingDevice(device => device.id === id, options, cancellable);
-}
-
-export interface GetDeviceOptions {
-    timeout?: number | null;
-}
-
-async function getMatchingDevice(predicate: DevicePredicate, options: GetDeviceOptions = {}, cancellable?: Cancellable): Promise<Device> {
-    const device = await findMatchingDevice(predicate, cancellable);
-    if (device !== null) {
-        return device;
-    }
-
-    const { timeout = 0 } = options;
-    if (timeout === 0) {
-        throw new Error("Device not found");
-    }
-
-    const getDeviceEventually = new Promise((resolve: (device: Device) => void, reject: (error: Error) => void) => {
-        const deviceManager = getDeviceManager();
-
-        deviceManager.added.connect(onDeviceAdded);
-
-        const timer = (timeout !== null) ? setTimeout(onTimeout, timeout) : null;
-
-        if (cancellable !== undefined) {
-            cancellable.cancelled.connect(onCancel);
-            if (cancellable.isCancelled) {
-                onCancel();
-                return;
-            }
-        }
-
-        findMatchingDevice(predicate, cancellable)
-            .then(device => {
-                if (device !== null) {
-                    onSuccess(device);
-                }
-            })
-            .catch(onError);
-
-        function onDeviceAdded(device: Device): void {
-            if (predicate(device)) {
-                onSuccess(device);
-            }
-        }
-
-        function onSuccess(device: Device): void {
-            stopMonitoring();
-            resolve(device);
-        }
-
-        function onError(error: Error): void {
-            stopMonitoring();
-            reject(error);
-        }
-
-        function onTimeout(): void {
-            onError(new Error("Timed out while waiting for device to appear"));
-        }
-
-        function onCancel(): void {
-            onError(new Error("Operation was cancelled"));
-        }
-
-        function stopMonitoring(): void {
-            if (cancellable !== undefined) {
-                cancellable.cancelled.disconnect(onCancel);
-            }
-
-            if (timer !== null) {
-                clearTimeout(timer);
-            }
-
-            deviceManager.added.disconnect(onDeviceAdded);
-        }
-    });
-
-    return await getDeviceEventually;
-}
-
-async function findMatchingDevice(predicate: DevicePredicate, cancellable?: Cancellable): Promise<Device | null> {
-    const deviceManager = getDeviceManager();
-
-    const devices = await deviceManager.enumerateDevices(cancellable);
-
-    const matching = devices.filter(predicate);
-    if (matching.length === 0) {
-        return null;
-    }
-
-    return matching[0];
-}
-
-type DevicePredicate = (device: Device) => boolean;

package/lib/iostream.ts

@@ -1,78 +0,0 @@
-import { Cancellable } from "./cancellable";
-
-import { Duplex } from "stream";
-
-export class IOStream extends Duplex {
-    private pending = new Set<Promise<void>>();
-
-    private cancellable = new Cancellable();
-
-    constructor(private impl: any) {
-        super({});
-    }
-
-    async _destroy(error: Error | null, callback: (error: Error | null) => void): Promise<void> {
-        this.cancellable.cancel();
-
-        for (const operation of this.pending) {
-            try {
-                await operation;
-            } catch (e) {
-            }
-        }
-
-        try {
-            await this.impl.close();
-        } catch (e) {
-        }
-
-        callback(error);
-    }
-
-    _read(size: number): void {
-        const operation = this.impl.read(size, this.cancellable)
-            .then((data: Buffer): void => {
-                const isEof = data.length === 0;
-                if (isEof) {
-                    this.push(null);
-                    return;
-                }
-
-                this.push(data);
-            })
-            .catch((error: Error): void => {
-                if (this.impl.isClosed) {
-                    this.push(null);
-                }
-                this.emit("error", error);
-            });
-        this.track(operation);
-    }
-
-    _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void {
-        let data: Buffer;
-        if (Buffer.isBuffer(chunk)) {
-            data = chunk;
-        } else {
-            data = Buffer.from(chunk, encoding);
-        }
-
-        const operation = this.impl.write(data, this.cancellable)
-            .then((): void => {
-                callback(null);
-            })
-            .catch((error: Error): void => {
-                callback(error);
-            });
-        this.track(operation);
-    }
-
-    private track(operation: Promise<void>): void {
-        this.pending.add(operation);
-        operation
-            .catch(_ => {})
-            .finally(() => {
-                this.pending.delete(operation);
-            });
-    }
-}

package/lib/meson.build

@@ -1,53 +0,0 @@
-sources = [
-  'index.ts',
-
-  'application.ts',
-  'authentication.ts',
-  'bus.ts',
-  'cancellable.ts',
-  'child.ts',
-  'crash.ts',
-  'device.ts',
-  'device_manager.ts',
-  'endpoint_parameters.ts',
-  'icon.ts',
-  'iostream.ts',
-  'native.ts',
-  'portal_membership.ts',
-  'portal_service.ts',
-  'process.ts',
-  'relay.ts',
-  'script.ts',
-  'service.ts',
-  'session.ts',
-  'signals.ts',
-  'socket_address.ts',
-  'spawn.ts',
-  'system_parameters.ts',
-]
-
-outputs = []
-foreach s : sources
-  stem = s.split('.')[0]
-  outputs += [
-    stem + '.js',
-    stem + '.d.ts',
-  ]
-endforeach
-
-custom_target('js',
-  input: sources,
-  output: outputs,
-  command: [
-    python,
-    files('build.py'),
-    '@OUTDIR@',
-    '@PRIVATE_DIR@',
-    npm,
-    package_json,
-    tsconfig_json,
-    '@INPUT@',
-  ],
-  install: true,
-  install_dir: pkg_install_dir / 'dist',
-)

package/lib/native.ts

@@ -1,9 +0,0 @@
-import * as bindings from "bindings";
-
-export const binding = bindings({
-    bindings: "frida_binding",
-    try: [
-        ["module_root", "build", "bindings"],
-        [process.cwd(), "bindings"],
-    ]
-});

package/lib/portal_membership.ts

@@ -1,10 +0,0 @@
-import { Cancellable } from "./cancellable";
-
-export class PortalMembership {
-    constructor(private impl: any) {
-    }
-
-    terminate(cancellable?: Cancellable): Promise<void> {
-        return this.impl.terminate(cancellable);
-    }
-}

package/lib/portal_service.ts

@@ -1,105 +0,0 @@
-import { Application } from "./application";
-import { AuthenticatedSessionInfo } from "./authentication";
-import { Cancellable } from "./cancellable";
-import { Device } from "./device";
-import { EndpointParameters } from "./endpoint_parameters";
-import { binding } from "./native";
-import { Signal } from "./signals";
-import { SocketAddress } from "./socket_address";
-
-import { inspect } from "util";
-
-export class PortalService {
-    nodeConnected: Signal<PortalNodeConnectedHandler>;
-    nodeJoined: Signal<PortalNodeJoinedHandler>;
-    nodeLeft: Signal<PortalNodeLeftHandler>;
-    nodeDisconnected: Signal<PortalNodeDisconnectedHandler>;
-
-    controllerConnected: Signal<PortalControllerConnectedHandler>;
-    controllerDisconnected: Signal<PortalControllerDisconnectedHandler>;
-
-    authenticated: Signal<PortalAuthenticatedHandler>;
-    subscribe: Signal<PortalSubscribeHandler>;
-    message: Signal<PortalMessageHandler>;
-
-    device: Device;
-
-    private impl: any;
-
-    constructor({ clusterParams = null, controlParams = null }: PortalServiceOptions = {}) {
-        const impl = new binding.PortalService(clusterParams, controlParams);
-        this.impl = impl;
-
-        this.device = new Device(impl.device);
-
-        const { signals } = impl;
-
-        this.nodeConnected = new Signal<PortalNodeConnectedHandler>(signals, "node-connected");
-        this.nodeJoined = new Signal<PortalNodeJoinedHandler>(signals, "node-joined");
-        this.nodeLeft = new Signal<PortalNodeLeftHandler>(signals, "node-left");
-        this.nodeDisconnected = new Signal<PortalNodeDisconnectedHandler>(signals, "node-disconnected");
-
-        this.controllerConnected = new Signal<PortalControllerConnectedHandler>(signals, "controller-connected");
-        this.controllerDisconnected = new Signal<PortalControllerDisconnectedHandler>(signals, "controller-disconnected");
-
-        this.authenticated = new Signal<PortalAuthenticatedHandler>(signals, "authenticated");
-        this.subscribe = new Signal<PortalSubscribeHandler>(signals, "subscribe");
-        this.message = new Signal<PortalMessageHandler>(signals, "message");
-    }
-
-    start(cancellable?: Cancellable): Promise<void> {
-        return this.impl.start(cancellable);
-    }
-
-    stop(cancellable?: Cancellable): Promise<void> {
-        return this.impl.stop(cancellable);
-    }
-
-    post(connectionId: PortalConnectionId, message: any, data: Buffer | null = null): void {
-        this.impl.post(connectionId, message, data);
-    }
-
-    narrowcast(tag: PortalConnectionTag, message: any, data: Buffer | null = null): void {
-        this.impl.narrowcast(tag, message, data);
-    }
-
-    broadcast(message: any, data: Buffer | null = null): void {
-        this.impl.broadcast(message, data);
-    }
-
-    enumerateTags(connectionId: PortalConnectionId): Promise<PortalConnectionTag[]> {
-        return this.impl.enumerateTags(connectionId);
-    }
-
-    tag(connectionId: PortalConnectionId, tag: PortalConnectionTag): void {
-        this.impl.tag(connectionId, tag);
-    }
-
-    untag(connectionId: PortalConnectionId, tag: PortalConnectionTag): void {
-        this.impl.untag(connectionId, tag);
-    }
-
-    [inspect.custom]() {
-        return "PortalService {}";
-    }
-}
-
-export interface PortalServiceOptions {
-    clusterParams?: EndpointParameters;
-    controlParams?: EndpointParameters;
-}
-
-export type PortalConnectionId = number;
-export type PortalConnectionTag = string;
-
-export type PortalNodeConnectedHandler = (connectionId: PortalConnectionId, remoteAddress: SocketAddress) => void;
-export type PortalNodeJoinedHandler = (connectionId: PortalConnectionId, application: Application) => void;
-export type PortalNodeLeftHandler = (connectionId: PortalConnectionId, application: Application) => void;
-export type PortalNodeDisconnectedHandler = (connectionId: PortalConnectionId, remoteAddress: SocketAddress) => void;
-
-export type PortalControllerConnectedHandler = (connectionId: PortalConnectionId, remoteAddress: SocketAddress) => void;
-export type PortalControllerDisconnectedHandler = (connectionId: PortalConnectionId, remoteAddress: SocketAddress) => void;
-
-export type PortalAuthenticatedHandler = (connectionId: PortalConnectionId, sessionInfo: AuthenticatedSessionInfo) => void;
-export type PortalSubscribeHandler = (connectionId: PortalConnectionId) => void;
-export type PortalMessageHandler = (connectionId: PortalConnectionId, message: any, data: Buffer | null) => void;

package/lib/process.ts

@@ -1,57 +0,0 @@
-import { Icon } from "./icon";
-import { SystemParameters } from "./system_parameters";
-
-export interface Process {
-    pid: number;
-    name: string;
-    parameters: ProcessParameters;
-}
-
-/**
- * Process parameters typically obtained through `enumerateProcesses({ scope })`, where
- * `scope` is either `Scope.Metadata` or `Scope.Full`. The default of `Scope.Minimal`
- * means no parameters will be included.
- */
-export interface ProcessParameters {
-    /**
-     * Filesystem path of program.
-     */
-    path?: string;
-
-    /**
-     * Name of user that the process is running as.
-     */
-    user?: string;
-
-    /**
-     * Parent process ID.
-     */
-    ppid?: number;
-
-    /**
-     * When the process was started.
-     */
-    started?: Date;
-
-    /**
-     * Application IDs that have code running inside this process.
-     */
-    applications?: string[];
-
-    /**
-     * Whether the process is currently frontmost.
-     */
-    frontmost?: boolean;
-
-    /**
-     * One or more icons. Only included when `scope` is set to `Scope.Full`.
-     */
-    icons?: Icon[];
-
-    /**
-     * System parameters, available for processes accessed through a portal.
-     */
-     system?: SystemParameters;
-
-    [name: string]: any;
-}

package/lib/relay.ts

@@ -1,44 +0,0 @@
-import { binding } from "./native";
-
-import { inspect } from "util";
-
-export class Relay {
-    private impl: RelayProperties;
-
-    constructor({ address, username, password, kind }: RelayProperties) {
-        this.impl = new binding.Relay(address, username, password, kind);
-    }
-
-    get address(): string {
-        return this.impl.address;
-    }
-
-    get username(): string {
-        return this.impl.username;
-    }
-
-    get password(): string {
-        return this.impl.password;
-    }
-
-    get kind(): RelayKind {
-        return this.impl.kind;
-    }
-
-    [inspect.custom](depth, options) {
-        return inspect(this.impl, { ...options, depth });
-    }
-}
-
-export interface RelayProperties {
-    address: string;
-    username: string;
-    password: string;
-    kind: RelayKind;
-}
-
-export enum RelayKind {
-    TurnUDP = "turn-udp",
-    TurnTCP = "turn-tcp",
-    TurnTLS = "turn-tls"
-}