ai-remote 0.4.8 → 0.4.10

package/dist/protocols/rdp/crypto.d.ts

@@ -1,63 +0,0 @@
-export declare function md5(message: Uint8Array): Uint8Array<ArrayBuffer>;
-export declare function sha1(message: Uint8Array): Uint8Array<ArrayBuffer>;
-/** RC4 keystream position. RDP re-keys every 4096 PDUs, so this is mutable. */
-export interface Rc4State {
-    s: Uint8Array;
-    i: number;
-    j: number;
-}
-/** The five values MS-RDPBCGR 5.3.5 derives from the two randoms. */
-export interface SessionKeys {
-    macKey: Uint8Array;
-    keyLength: number;
-    is40Bit: boolean;
-    initialDecryptKey: Uint8Array;
-    initialEncryptKey: Uint8Array;
-    decryptKey: Uint8Array;
-    encryptKey: Uint8Array;
-}
-export declare function rc4Init(key: Uint8Array): Rc4State;
-/** RC4 is symmetric, so this both encrypts and decrypts. State advances. */
-export declare function rc4Crypt(state: any, data: Uint8Array): Uint8Array<ArrayBuffer>;
-/**
- * Textbook RSA over little-endian buffers, which is what RDP's Security
- * Exchange PDU carries: the client random is raised to the server's public
- * exponent with no padding scheme (MS-RDPBCGR 5.3.4.1).
- */
-export declare function rsaEncrypt(dataLe: Uint8Array, modulusLe: Uint8Array, exponentLe: Uint8Array): Uint8Array<ArrayBuffer>;
-/**
- * RSAES-PKCS1-v1_5 encryption over big-endian buffers, which is what TLS uses
- * for an RSA key exchange. WebCrypto only offers OAEP, so the padding is built
- * here and the modular exponentiation reuses the same BigInt path as RDP.
- */
-export declare function rsaEncryptPkcs1(message: Uint8Array, modulusBe: Uint8Array, exponentBe: Uint8Array): Uint8Array<ArrayBuffer>;
-export declare const ENCRYPTION_METHOD: {
-    NONE: number;
-    BIT_40: number;
-    BIT_128: number;
-    BIT_56: number;
-    FIPS: number;
-};
-export declare function keyLengthForMethod(encryptionMethod: number): 8 | 16;
-/**
- * Derive the MAC key and both directional RC4 keys from the two random values
- * exchanged during connection.
- */
-export declare function deriveSessionKeys(clientRandom: Uint8Array, serverRandom: Uint8Array, encryptionMethod: number): {
-    macKey: Uint8Array<ArrayBuffer>;
-    keyLength: number;
-    is40Bit: boolean;
-    initialDecryptKey: Uint8Array<ArrayBuffer>;
-    initialEncryptKey: Uint8Array<ArrayBuffer>;
-    decryptKey: Uint8Array<ArrayBuffer>;
-    encryptKey: Uint8Array<ArrayBuffer>;
-};
-/**
- * MACSignature = First64Bits(MD5(macKey + Pad2 + SHA1(macKey + Pad1 + len + data)))
- */
-export declare function macSignature(macKey: any, data: Uint8Array): Uint8Array<ArrayBuffer>;
-/**
- * Every 4096 PDUs the RC4 key is refreshed from the initial key
- * (MS-RDPBCGR 5.3.7.1). The refreshed key is salted with itself.
- */
-export declare function updateSessionKey(initialKey: any, currentKey: any, keyLength: any, is40Bit: any): Uint8Array<ArrayBuffer>;

package/dist/protocols/rdp/display.d.ts

@@ -1,38 +0,0 @@
-export declare class RdpDisplay {
-    #private;
-    constructor(container: any);
-    resize(width: number, height: number): void;
-    /**
-     * Choose the part of the desktop that is on screen. Everything else about
-     * the session -- painting, input coordinates, the remote pointer -- keeps
-     * working in desktop coordinates, so only the framing changes here.
-     */
-    setViewport({ x, y, width, height }?: {
-        x?: number;
-        y?: number;
-    }): void;
-    applyScale(): void;
-    /**
-     * Zoom about a point, keeping whatever is under it in place. `focal` is in
-     * client coordinates -- the midpoint between two fingers, usually.
-     */
-    setZoom(next: any, focal?: any): void;
-    /** Move the visible window over the desktop. Returns what it actually used. */
-    panBy(dx: any, dy: any): {
-        x: number;
-        y: number;
-    };
-    /** True when the desktop is larger than the window on either axis. */
-    canPan(): boolean;
-    setScaleViewport(enabled: boolean): void;
-    /** Back to the opening view: whole desktop fitted on screen. */
-    resetZoom(): void;
-    drawRects(rects: any, palette: any): void;
-    applyPointer(pointer: any): void;
-    attachInput(client: any): void;
-    /** A key held while focus moves away would otherwise stay down on the host. */
-    releaseAllKeys(): void;
-    focus(): void;
-    blur(): void;
-    destroy(): void;
-}

package/dist/protocols/rdp/gcc.d.ts

@@ -1,23 +0,0 @@
-/** RDP 5.0 and later. Anything newer would oblige us to speak newer PDUs. */
-export declare const RDP_VERSION_5_PLUS = 524292;
-export declare const ENCRYPTION_LEVEL: {
-    NONE: number;
-    LOW: number;
-    CLIENT_COMPATIBLE: number;
-    HIGH: number;
-    FIPS: number;
-};
-export declare function clientData(options: any): Uint8Array<ArrayBufferLike>;
-/**
- * Walk the host's answer. Only the security and network blocks carry anything
- * the client must act on; the core block is kept for logging.
- */
-export declare function parseServerData(blocks: any): {
-    version: any;
-    encryptionMethod: number;
-    encryptionLevel: number;
-    serverRandom: any;
-    publicKey: any;
-    ioChannelId: number;
-    channelIds: any[];
-};

package/dist/protocols/rdp/keymap.d.ts

@@ -1,9 +0,0 @@
-/** Returns { scancode, extended } or null when the key has no RDP equivalent. */
-export declare function lookupScancode(code: string): {
-    scancode: any;
-    extended: boolean;
-};
-export declare const CTRL_ALT_DEL: {
-    code: string;
-    pressed: boolean;
-}[];

package/dist/protocols/rdp/mcs.d.ts

@@ -1,40 +0,0 @@
-export declare const MCS_BASE_CHANNEL_ID = 1001;
-export declare const MCS_GLOBAL_CHANNEL_ID = 1003;
-export declare function connectInitial(clientData: Uint8Array): Uint8Array<ArrayBufferLike>;
-export declare function parseConnectResponse(frame: Uint8Array): Uint8Array<ArrayBufferLike>;
-export declare function erectDomainRequest(): Uint8Array<ArrayBufferLike>;
-export declare function attachUserRequest(): Uint8Array<ArrayBufferLike>;
-export declare function parseAttachUserConfirm(frame: Uint8Array): {
-    userId: number;
-};
-export declare function channelJoinRequest(userId: number, channelId: number): Uint8Array<ArrayBufferLike>;
-export declare function parseChannelJoinConfirm(frame: Uint8Array): {
-    channelId: number;
-};
-export declare function sendDataRequest(userId: number, channelId: number, payload: Uint8Array): Uint8Array<ArrayBufferLike>;
-/**
- * Classify an inbound X.224 data frame. Everything the server sends after the
- * connect sequence arrives as a send-data indication on some channel.
- */
-export declare function parseDomainPdu(frame: Uint8Array): {
-    type: string;
-    channelId: number;
-    payload: Uint8Array<ArrayBufferLike>;
-    reason?: undefined;
-    message?: undefined;
-    mcsPduType?: undefined;
-} | {
-    channelId?: undefined;
-    payload?: undefined;
-    type: string;
-    reason: number;
-    message: any;
-    mcsPduType?: undefined;
-} | {
-    channelId?: undefined;
-    payload?: undefined;
-    reason?: undefined;
-    message?: undefined;
-    type: string;
-    mcsPduType: number;
-};

package/dist/protocols/rdp/ntlm.d.ts

@@ -1,61 +0,0 @@
-export declare function md4(message: string): Uint8Array<ArrayBuffer>;
-/** HMAC-MD5. WebCrypto has no MD5, so it is built from the MD5 here. */
-export declare function hmacMd5(key: Uint8Array, message: string): Uint8Array<ArrayBuffer>;
-export declare const NTLM_FLAG: {
-    UNICODE: number;
-    REQUEST_TARGET: number;
-    SIGN: number;
-    SEAL: number;
-    NTLM: number;
-    ALWAYS_SIGN: number;
-    EXTENDED_SESSION_SECURITY: number;
-    TARGET_INFO: number;
-    VERSION: number;
-    KEY_128: number;
-    KEY_EXCH: number;
-    KEY_56: number;
-};
-export declare function negotiateMessage(): Uint8Array<ArrayBufferLike>;
-export declare function parseChallengeMessage(bytes: Uint8Array): {
-    flags: number;
-    serverChallenge: Uint8Array<ArrayBuffer>;
-    targetName: Uint8Array<ArrayBuffer>;
-    targetInfo: Uint8Array<ArrayBuffer>;
-};
-/**
- * Build the AUTHENTICATE message plus every key CredSSP needs afterwards.
- *
- * The MIC is always sent: a current Windows host expects one, and sending it
- * obliges the client to flag it in the AV pair list, which in turn feeds the
- * NTProofStr -- so the modified list has to be the one that goes on the wire.
- */
-export declare function authenticateMessage({ username, domain, password, challenge, negotiateBytes, challengeBytes }: {
-    challenge: any;
-    challengeBytes: any;
-    domain: any;
-    negotiateBytes: any;
-    password: any;
-    username: any;
-}): {
-    message: Uint8Array<ArrayBufferLike>;
-    exportedSessionKey: Uint8Array<ArrayBuffer>;
-    keys: {
-        clientSigningKey: Uint8Array<ArrayBuffer>;
-        serverSigningKey: Uint8Array<ArrayBuffer>;
-        clientSealing: import("./crypto").Rc4State;
-        serverSealing: import("./crypto").Rc4State;
-    };
-};
-/**
- * NTLM message confidentiality (MS-NLMP 3.4.3). The signature covers the
- * plaintext, and both the payload and the checksum draw from the same RC4
- * stream -- payload first.
- */
-export declare class NtlmSealer {
-    private readonly keys;
-    private sendSequence;
-    private receiveSequence;
-    constructor(keys: any);
-    seal(plaintext: Uint8Array): Uint8Array<ArrayBufferLike>;
-    unseal(bytes: Uint8Array): Uint8Array<ArrayBuffer>;
-}

package/dist/protocols/rdp/pdu.d.ts

@@ -1,155 +0,0 @@
-import { Reader } from './buffer';
-export declare const PDU_TYPE: {
-    DEMAND_ACTIVE: number;
-    CONFIRM_ACTIVE: number;
-    DEACTIVATE_ALL: number;
-    DATA: number;
-    SERVER_REDIRECT: number;
-};
-export declare const PDU_TYPE2: {
-    UPDATE: number;
-    CONTROL: number;
-    POINTER: number;
-    INPUT: number;
-    SYNCHRONIZE: number;
-    REFRESH_RECT: number;
-    PLAY_SOUND: number;
-    SUPPRESS_OUTPUT: number;
-    SHUTDOWN_REQUEST: number;
-    SHUTDOWN_DENIED: number;
-    SAVE_SESSION_INFO: number;
-    FONT_LIST: number;
-    FONT_MAP: number;
-    SET_ERROR_INFO: number;
-    MONITOR_LAYOUT: number;
-};
-export declare const UPDATE_TYPE: {
-    ORDERS: number;
-    BITMAP: number;
-    PALETTE: number;
-    SYNCHRONIZE: number;
-};
-export declare const CONTROL_ACTION: {
-    REQUEST_CONTROL: number;
-    GRANTED_CONTROL: number;
-    DETACH: number;
-    COOPERATE: number;
-};
-export declare const INPUT_EVENT: {
-    SYNC: number;
-    SCANCODE: number;
-    UNICODE: number;
-    MOUSE: number;
-    MOUSEX: number;
-};
-export declare const KEYBOARD_FLAG: {
-    EXTENDED: number;
-    DOWN: number;
-    RELEASE: number;
-};
-export declare const POINTER_FLAG: {
-    WHEEL: number;
-    HWHEEL: number;
-    WHEEL_NEGATIVE: number;
-    MOVE: number;
-    DOWN: number;
-    BUTTON1: number;
-    BUTTON2: number;
-    BUTTON3: number;
-};
-/** Translate browser-style wheel direction to the signed RDP rotation flags. */
-export declare function pointerWheelFlags(delta: number, horizontal?: boolean): number;
-export declare const TOGGLE_FLAG: {
-    SCROLL_LOCK: number;
-    NUM_LOCK: number;
-    CAPS_LOCK: number;
-    KANA_LOCK: number;
-};
-export declare function errorInfoMessage(errorInfo: any): any;
-/** TS_SHARECONTROLHEADER + payload. */
-export declare function shareControlPdu(pduType: any, userId: number, payload: Uint8Array): Uint8Array<ArrayBufferLike>;
-/** TS_SHAREDATAHEADER inside a share control PDU of type DATA. */
-export declare function shareDataPdu(shareId: number, userId: number, pduType2: any, payload: Uint8Array): Uint8Array<ArrayBufferLike>;
-/**
- * Client Info PDU (MS-RDPBCGR 2.2.1.11). The credential lengths sit in front of
- * the strings, so the strings are written to a scratch buffer first.
- */
-export declare function clientInfoPdu({ domain, username, password, performanceFlags, autoLogon, remoteApp }: {
-    autoLogon: any;
-    domain: any;
-    password: any;
-    performanceFlags: any;
-    remoteApp?: boolean;
-    username: any;
-}): Uint8Array<ArrayBufferLike>;
-export declare function synchronizePdu(targetUser: any): Uint8Array<ArrayBufferLike>;
-export declare function controlPdu(action: any): Uint8Array<ArrayBufferLike>;
-export declare function fontListPdu(): Uint8Array<ArrayBufferLike>;
-export declare function confirmActivePdu(shareId: number, capabilities: any, capabilityCount: any): Uint8Array<ArrayBufferLike>;
-/** TS_INPUT_PDU_DATA: a batch of input events sharing one header. */
-export declare function inputEventsPdu(events: any): Uint8Array<ArrayBufferLike>;
-export declare function scancodeEvent(scancode: any, pressed: boolean, extended: any): Uint8Array<ArrayBufferLike>;
-export declare function unicodeEvent(codeUnit: any, pressed: boolean): Uint8Array<ArrayBufferLike>;
-export declare function mouseEvent(flags: number, x: number, y: number): Uint8Array<ArrayBufferLike>;
-export declare function extendedMouseEvent(flags: number, x: number, y: number): Uint8Array<ArrayBufferLike>;
-export declare function syncEvent(toggleFlags: number): Uint8Array<ArrayBufferLike>;
-export declare function refreshRectPdu(rects: any): Uint8Array<ArrayBufferLike>;
-export declare function suppressOutputPdu(allowDisplayUpdates: any, rect: any): Uint8Array<ArrayBufferLike>;
-export declare function parseShareControlHeader(bytes: Uint8Array): {
-    totalLength: number;
-    pduType: number;
-    pduSource: number;
-    payload: Uint8Array<ArrayBufferLike>;
-};
-export declare function parseShareDataHeader(bytes: Uint8Array): {
-    shareId: number;
-    pduType2: number;
-    compressedType: number;
-    compressedLength: number;
-    payload: Uint8Array<ArrayBufferLike>;
-};
-export declare function parseDemandActive(bytes: Uint8Array): {
-    shareId: number;
-    capabilities: Uint8Array<ArrayBufferLike>;
-};
-export declare function parseBitmapUpdate(reader: Reader): any[];
-export declare function parsePaletteUpdate(reader: Reader): Uint8Array<ArrayBuffer>;
-export declare function parsePointerUpdate(reader: Reader): {
-    kind: string;
-    cacheIndex: number;
-    hotSpotX: number;
-    hotSpotY: number;
-    width: number;
-    height: number;
-    xorBpp: any;
-    xorMask: Uint8Array<ArrayBuffer>;
-    andMask: Uint8Array<ArrayBuffer>;
-} | {
-    kind: string;
-    x: number;
-    y: number;
-    hidden?: undefined;
-    cacheIndex?: undefined;
-    messageType?: undefined;
-} | {
-    x?: undefined;
-    y?: undefined;
-    kind: string;
-    hidden: boolean;
-    cacheIndex?: undefined;
-    messageType?: undefined;
-} | {
-    x?: undefined;
-    y?: undefined;
-    hidden?: undefined;
-    kind: string;
-    cacheIndex: number;
-    messageType?: undefined;
-} | {
-    x?: undefined;
-    y?: undefined;
-    hidden?: undefined;
-    cacheIndex?: undefined;
-    kind: string;
-    messageType: number;
-};

package/dist/protocols/rdp/rail.d.ts

@@ -1,119 +0,0 @@
-import { Reader } from './buffer';
-export declare const RAIL_ORDER: {
-    EXEC: number;
-    ACTIVATE: number;
-    SYSPARAM: number;
-    SYSCOMMAND: number;
-    HANDSHAKE: number;
-    WINDOW_MOVE: number;
-    CLIENT_STATUS: number;
-    EXEC_RESULT: number;
-    HANDSHAKE_EX: number;
-};
-export declare const RAIL_EXEC_RESULT: {
-    0: string;
-    1: string;
-    2: string;
-    3: string;
-    5: string;
-    6: string;
-    7: string;
-};
-/** WM_SYSCOMMAND values a RAIL client may ask the host to apply to a window. */
-export declare const SYS_COMMAND: {
-    MINIMIZE: number;
-    MAXIMIZE: number;
-    CLOSE: number;
-    RESTORE: number;
-};
-/** SW_* show states reported by a window order's ShowState field. */
-export declare const SHOW_STATE: {
-    HIDDEN: number;
-    MINIMIZED: number;
-    MAXIMIZED: number;
-    NORMAL: number;
-};
-export declare const WINDOW_ORDER: {
-    TYPE_WINDOW: number;
-    STATE_NEW: number;
-    STATE_DELETED: number;
-    ICON: number;
-    CACHED_ICON: number;
-};
-export declare function railHandshake(buildNumber?: number): Uint8Array<ArrayBufferLike>;
-export declare function railClientStatus(flags?: number): Uint8Array<ArrayBufferLike>;
-/**
- * SPI_SETWORKAREA. This is how a RAIL client tells the host how much room it
- * has, and the host maximizes remote windows into it. Sending it again during
- * the session is what keeps a maximized window matched to the browser window.
- */
-export declare function railWorkArea(width: number, height: number): Uint8Array<ArrayBufferLike>;
-export declare function railSystemParameters(width: number, height: number): Uint8Array<ArrayBufferLike>[];
-/** TS_RAIL_ORDER_ACTIVATE: give (or take) input focus for one remote window. */
-export declare function railActivate(windowId: number, enabled?: boolean): Uint8Array<ArrayBufferLike>;
-/** TS_RAIL_ORDER_SYSCOMMAND: minimize, maximize, restore or close a window. */
-export declare function railSysCommand(windowId: number, command: string): Uint8Array<ArrayBufferLike>;
-/**
- * TS_RAIL_ORDER_WINDOWMOVE. A client that draws remote windows itself sends
- * this when the user finishes moving or resizing one; the host then applies
- * the rectangle to the real window. It is the only way to give a remote window
- * an exact size, which is what fitting one to the browser viewport needs.
- */
-export declare function railWindowMove(windowId: number, { left, top, right, bottom }: {
-    bottom: any;
-    left: any;
-    right: any;
-    top: any;
-}): Uint8Array<ArrayBufferLike>;
-/** Build TS_RAIL_ORDER_EXEC. Strings are UTF-16LE and are not terminated. */
-export declare function railExecute({ program, workingDir, arguments: args }: {
-    arguments?: string;
-    program: any;
-    workingDir?: string;
-}): Uint8Array<ArrayBufferLike>;
-/**
- * True for a window the session exists to show: not a child, not a tool
- * window, and not one of the never-activated popups a Chromium or Electron
- * application creates for menus, tooltips and drag images.
- */
-export declare function isPrimaryWindow(candidate: any): boolean;
-/**
- * Parse the window lifecycle subset of TS_UPDATE_ORDERS_PDU_DATA.
- *
- * RemoteApp window orders are Alternate Secondary orders and, unlike ordinary
- * drawing orders, carry their total size in every header. That lets the parser
- * read the fields it understands and then seek to the next order, rather than
- * having to understand every icon, notification and desktop order to stay in
- * sync with the stream.
- */
-export declare function parseRemoteAppWindowOrders(reader: Reader): any[];
-/** Parse one or more complete RAIL PDUs delivered in a channel message. */
-export declare function parseRailPdus(bytes: Uint8Array): any[];
-/**
- * Minimal RAIL endpoint for the browser client. It deliberately suppresses
- * icon orders because the browser currently presents the RemoteApp session in
- * one canvas rather than creating a local OS window per remote window.
- */
-export declare class RailChannel {
-    private readonly application;
-    private width;
-    private height;
-    private readonly send;
-    private readonly onReady;
-    private readonly onResult;
-    private started;
-    constructor({ application, width, height, send, onReady, onResult }: {
-        application: any;
-        height: any;
-        onReady: any;
-        onResult: any;
-        send: any;
-        width: any;
-    });
-    receive(bytes: Uint8Array): void;
-    /** Republish the client's work area, which is what maximize resizes into. */
-    setWorkArea(width: number, height: number): boolean;
-    activate(windowId: number): boolean;
-    sysCommand(windowId: number, command: string): boolean;
-    moveWindow(windowId: number, rectangle: any): boolean;
-}

package/dist/protocols/rdp/rle.d.ts

@@ -1,13 +0,0 @@
-export declare function rleDecompress(src: Uint8Array, width: number, height: number, bytesPerPixel: number): Uint32Array<ArrayBuffer>;
-/**
- * Reverse the row order of a decoded rectangle. RDP stores bitmaps bottom-up
- * and a canvas expects top-down, so without this every rectangle is painted
- * upside down.
- */
-export declare function flipRows(pixels: Uint8Array, width: number): Uint32Array<ArrayBuffer> | Uint8Array<ArrayBufferLike>;
-/** Read uncompressed bitmap data, which RDP stores bottom-up. */
-export declare function readUncompressed(src: Uint8Array, width: number, height: number, bytesPerPixel: number): Uint32Array<ArrayBuffer>;
-/** Expand raw pixel values into RGBA for putImageData. */
-export declare function pixelsToRgba(pixels: Uint8Array, bitsPerPixel: number, palette: Uint32Array): Uint8ClampedArray<ArrayBuffer>;
-/** Decode one TS_BITMAP_DATA rectangle to RGBA. */
-export declare function decodeBitmapRect(rect: BitmapRect, palette: Uint32Array): Uint8ClampedArray<ArrayBuffer>;

package/dist/protocols/rdp/sec.d.ts

@@ -1,59 +0,0 @@
-import { concatBytes } from './buffer';
-export declare const SEC_FLAG: {
-    EXCHANGE_PKT: number;
-    TRANSPORT_REQ: number;
-    ENCRYPT: number;
-    RESET_SEQNO: number;
-    IGNORE_SEQNO: number;
-    INFO_PKT: number;
-    LICENSE_PKT: number;
-    LICENSE_ENCRYPT_CS: number;
-    REDIRECTION_PKT: number;
-    SECURE_CHECKSUM: number;
-    AUTODETECT_REQ: number;
-    AUTODETECT_RSP: number;
-    HEARTBEAT: number;
-};
-export declare class SecurityLayer {
-    #private;
-    private encryptionMethod;
-    private encryptionLevel;
-    private keys;
-    private encryptState;
-    private decryptState;
-    private encryptedPdus;
-    private decryptedPdus;
-    constructor();
-    /** True when data PDUs carry a basic security header at all. */
-    get headerPresent(): boolean;
-    get encryptionEnabled(): boolean;
-    configure(encryptionMethod: number, encryptionLevel: number, clientRandom: Uint8Array, serverRandom: Uint8Array): void;
-    /**
-     * Prefix a payload with the basic security header, signing and encrypting it
-     * when the negotiated level asks for that.
-     *
-     * `flags` carries the PDU-kind bits (SEC_INFO_PKT and friends). A payload with
-     * no flags and no encryption needs no header at all.
-     */
-    wrap(payload: Uint8Array, flags?: number): Uint8Array<ArrayBufferLike>;
-    /**
-     * Strip (and if needed decrypt) the basic security header from a host PDU.
-     * `headerMandatory` forces the header to be read even when the host reported
-     * no encryption, which licensing PDUs require.
-     */
-    unwrap(bytes: Uint8Array, headerMandatory?: boolean): {
-        flags: number;
-        payload: Uint8Array<ArrayBufferLike>;
-    };
-    /**
-     * Fast-path output carries the same signature and RC4 stream as a slow-path
-     * PDU, but without the basic security header in front of it.
-     */
-    decryptFastPath(payload: Uint8Array): Uint8Array<ArrayBufferLike>;
-    /**
-     * Security Exchange PDU (MS-RDPBCGR 2.2.1.10): the client random encrypted
-     * with the host public key, followed by eight bytes of padding.
-     */
-    static securityExchange(encryptedClientRandom: any): Uint8Array<ArrayBufferLike>;
-}
-export { concatBytes };

package/dist/protocols/rdp/session.d.ts

@@ -1,62 +0,0 @@
-import type { ProtocolDriver } from '../types';
-export declare class RdpSession extends EventTarget {
-    #private;
-    readonly protocol: 'rdp';
-    constructor(container: any, url: string, options?: {});
-    /**
-     * Ask the host to size the remote application's window to the room this
-     * session has on the page. Full-desktop sessions have nothing to do here:
-     * their size is fixed when the connection is negotiated.
-     */
-    fitToViewport(): any;
-    get connected(): boolean;
-    get canvas(): HTMLCanvasElement | null;
-    /** The workspace instruments this socket for byte counters and keepalives. */
-    get socket(): WebSocket | null;
-    get _sock(): {
-        _websocket: any;
-    };
-    get scaleViewport(): any;
-    set scaleViewport(enabled: any);
-    get viewOnly(): any;
-    set viewOnly(enabled: any);
-    /**
-     * The on-screen keyboard and the special-keys dialog call this with an X11
-     * keysym and a DOM code. RDP wants a scancode, so the code decides; the
-     * keysym is only a fallback for characters with no key of their own.
-     */
-    sendKey(keysym: any, code: number, pressed: boolean): void;
-    sendCtrlAltDel(): void;
-    /** Desktop pixels. Returns false when the session cannot accept input. */
-    movePointer(x: number, y: number): boolean;
-    clickPointer(x: number, y: number, button?: number): boolean;
-    pointerButton(x: number, y: number, button?: number, pressed?: boolean): boolean;
-    scrollPointer(x: number, y: number, delta: {
-        x: number;
-        y: number;
-    }): boolean;
-    /** Type a run of characters, which RDP carries as Unicode rather than keys. */
-    typeText(text: string): boolean;
-    /** What the canvas is showing, for a screen capture or a coordinate check. */
-    get screenGeometry(): {
-        width: any;
-        height: any;
-        viewport: any;
-    };
-    /**
-     * Hand text to the host's clipboard, falling back to typing it when the host
-     * declined the clipboard channel -- xrdp builds often do.
-     */
-    clipboardPasteFrom(text: string): void;
-    /**
-     * Deliver text into the session, which is what the clipboard drawer's button
-     * has always visibly done. `clipboardPasteFrom` only loads the clipboard, the
-     * way noVNC's method of that name does.
-     */
-    pasteText(text: string): any;
-    releaseKeyboard(): void;
-    /** True once the host has agreed to share its clipboard. */
-    get clipboardShared(): any;
-    disconnect(): void;
-}
-export declare const rdpDriver: ProtocolDriver;

package/dist/protocols/rdp/tls.d.ts

@@ -1,18 +0,0 @@
-export declare class Tls12Client {
-    #private;
-    /**
-     * @param {(bytes: Uint8Array) => void} send        write raw bytes to the transport
-     * @param {(bytes: Uint8Array) => void} onData      decrypted application data
-     * @param {(error: Error) => void} onError          fatal protocol failure
-     */
-    constructor({ send, onData, onError }: {
-        onData: any;
-        onError: any;
-        send: any;
-    });
-    start(): Promise<any>;
-    /** Feed transport bytes. Calls are serialized, so order is preserved. */
-    receive(bytes: Uint8Array): any;
-    /** Send application data once the handshake has completed. */
-    write(plaintext: Uint8Array): any;
-}