@fkn/lib 0.3.1 → 0.3.2

package/index.d.ts

@@ -1 +1,788 @@
-export * from './api';
+import { AddressInfo } from 'net';
+import { BindOptions } from 'dgram';
+import type { BoxBase } from 'osra';
+import { BoxedClonable } from 'osra/build/revivables/fallbacks';
+import { BoxedTransferable } from 'osra/build/revivables/fallbacks';
+import { BoxedUnclonable } from 'osra/build/revivables/fallbacks';
+import type { Capable } from 'osra';
+import { Clonable } from 'osra/build/revivables/fallbacks';
+import { DuplexOptions } from 'stream';
+import { EventEmitter } from 'events';
+import { ListenOptions } from 'net';
+import { osraBuildRevivablesAbortSignal } from 'osra/build/revivables/abort-signal';
+import { osraBuildRevivablesArrayBuffer } from 'osra/build/revivables/array-buffer';
+import { osraBuildRevivablesBigint } from 'osra/build/revivables/bigint';
+import { osraBuildRevivablesBlob } from 'osra/build/revivables/blob';
+import { osraBuildRevivablesDate } from 'osra/build/revivables/date';
+import { osraBuildRevivablesError } from 'osra/build/revivables/error';
+import { osraBuildRevivablesEvent } from 'osra/build/revivables/event';
+import { osraBuildRevivablesEventTarget } from 'osra/build/revivables/event-target';
+import { osraBuildRevivablesFunction } from 'osra/build/revivables/function';
+import { osraBuildRevivablesHeaders } from 'osra/build/revivables/headers';
+import { osraBuildRevivablesIdentity } from 'osra/build/revivables/identity';
+import { osraBuildRevivablesMap } from 'osra/build/revivables/map';
+import { osraBuildRevivablesMessagePort } from 'osra/build/revivables/message-port';
+import { osraBuildRevivablesPromise } from 'osra/build/revivables/promise';
+import { osraBuildRevivablesReadableStream } from 'osra/build/revivables/readable-stream';
+import { osraBuildRevivablesRequest } from 'osra/build/revivables/request';
+import { osraBuildRevivablesResponse } from 'osra/build/revivables/response';
+import { osraBuildRevivablesSet } from 'osra/build/revivables/set';
+import { osraBuildRevivablesSymbol } from 'osra/build/revivables/symbol';
+import { osraBuildRevivablesTransfer } from 'osra/build/revivables/transfer';
+import { osraBuildRevivablesTypedArray } from 'osra/build/revivables/typed-array';
+import { RemoteInfo } from 'dgram';
+import { Resolvers } from '../api';
+import { RevivableContext } from 'osra';
+import { Server as Server_2 } from 'net';
+import { ServerOpts } from 'net';
+import { Socket as Socket_2 } from 'net';
+import { Socket as Socket_4 } from 'dgram';
+import { SocketConnectOpts } from 'net';
+import { SocketConstructorOpts } from 'net';
+import { SocketOptions } from 'dgram';
+import { SocketType } from 'dgram';
+import { Stream } from 'stream';
+import { TcpSocketOption } from '../../api/webvpn/tcp';
+import { Transferable as Transferable_2 } from 'osra/build/revivables/fallbacks';
+import { UdpSocketOption } from '../../api/webvpn/udp';
+import type { UnderlyingType } from 'osra';
+
+declare namespace addStyleTag {
+    export {
+        type_19 as type,
+        AddStyleTagOptions,
+        resolve_18 as resolve
+    }
+}
+
+declare type AddStyleTagOptions = OperationTimeoutOptions & {
+    content: string;
+    noSanitize?: boolean;
+};
+
+export declare const attachFrame: ({ iframe, domains }: AttachFrameOptions) => Promise<Frame>;
+
+export declare type AttachFrameOptions = {
+    iframe: HTMLIFrameElement;
+    domains?: string[];
+};
+
+declare type BarrierContext = {
+    parts: SelectorPart[];
+    selfIndex: number;
+    resolveLocal: (parts: SelectorPart[]) => Element[];
+};
+
+declare type BarrierResolver = (context: BarrierContext) => Promise<FrameId>;
+
+export declare const box: <T extends RemoteVideoElement, T2 extends RevivableContext>(value: T, context: T2) => BoxedVideoElement;
+
+export declare type BoxedVideoElement = BoxBase<typeof type> & {
+    initialState: VideoElementState;
+    controller: Capable;
+} & {
+    [UnderlyingType]: RemoteVideoElement;
+};
+
+declare namespace click {
+    export {
+        type_8 as type,
+        resolve_7 as resolve
+    }
+}
+
+declare const connect: (options: SocketConnectOpts, connectionListener?: () => void) => Socket;
+
+declare namespace count {
+    export {
+        type_13 as type,
+        resolve_12 as resolve
+    }
+}
+
+declare const createConnection: (options: SocketConnectOpts, connectionListener?: () => void) => Socket;
+
+declare const createServer: (options: ServerOpts, connectionListener?: (socket: Socket) => void) => Server;
+
+declare const createSocket: (options: SocketType | SocketOptions, callback?: (msg: Buffer, rinfo: RemoteInfo) => void) => Socket_3;
+
+export declare const createVideoElementHandle: (element: HTMLVideoElement) => RemoteVideoElement;
+
+declare const _default: {
+    Socket: typeof Socket;
+    Server: typeof Server;
+    connect: (options: SocketConnectOpts, connectionListener?: () => void) => Socket;
+    createConnection: (options: SocketConnectOpts, connectionListener?: () => void) => Socket;
+    createServer: (options: ServerOpts, connectionListener?: (socket: Socket) => void) => Server;
+    isIP: (input: string) => 0 | 4 | 6;
+    isIPv4: (input: string) => boolean;
+    isIPv6: (input: string) => boolean;
+};
+
+export declare namespace dgram {
+    export {
+        Socket_3 as Socket,
+        createSocket
+    }
+}
+
+declare interface EventEmitterOptions {
+    /**
+     * Enables automatic capturing of promise rejection.
+     */
+    captureRejections?: boolean | undefined;
+}
+
+declare interface EventEmitterOptions_2 {
+    /**
+     * Enables automatic capturing of promise rejection.
+     */
+    captureRejections?: boolean | undefined;
+}
+
+declare namespace exists {
+    export {
+        type_14 as type,
+        resolve_13 as resolve
+    }
+}
+
+declare type ExtractOperationArgs<M> = M extends {
+    resolve: (context: any, ...args: infer A) => any;
+} ? A : never;
+
+declare type ExtractResolverArgs<M> = M extends {
+    resolve: (context: any, ...args: infer A) => Element[];
+} ? A : never;
+
+declare type ExtractResolverReturn<M> = M extends {
+    resolve: (context: any, ...args: any[]) => infer R;
+} ? R : never;
+
+declare type ExtractType<M> = M extends {
+    type: infer T extends string;
+} ? T : never;
+
+declare type FetchParameters = Parameters<ProxyFetch>;
+
+declare namespace fill {
+    export {
+        type_9 as type,
+        resolve_8 as resolve
+    }
+}
+
+declare namespace first {
+    export {
+        type_6 as type,
+        resolve_5 as resolve,
+        render_5 as render
+    }
+}
+
+export declare type Frame = FrameLocator & {
+    goto(url: string, options?: GotoOptions): Promise<void>;
+    url(): string;
+};
+
+declare type FrameId = `${number}-${number}`;
+
+declare interface FrameLocator extends LocatorChain<FrameLocatorModule, FrameLocator> {
+}
+
+declare type FrameLocatorModule = typeof frameLocatorModule;
+
+declare const frameLocatorModule: {
+    readonly type: "frameLocator";
+    readonly selectorModules: readonly [{
+        readonly type: "locator";
+        readonly resolve: (context: LocatorContext, selector: string) => Element[];
+        readonly render: SelectorRenderer;
+        readonly nextLocatorType: "locator";
+    }, typeof frameLocatorSel, typeof owner];
+    readonly operationModules: readonly [typeof addStyleTag];
+};
+
+declare namespace frameLocatorSel {
+    export {
+        type_17 as type,
+        resolve_16 as resolve,
+        resolvePeer,
+        render_7 as render
+    }
+}
+
+declare namespace getAttribute {
+    export {
+        type_15 as type,
+        resolve_14 as resolve
+    }
+}
+
+declare namespace getByRole {
+    export {
+        type_3 as type,
+        resolve_2 as resolve,
+        render_2 as render
+    }
+}
+
+declare namespace getByTestId {
+    export {
+        type_5 as type,
+        resolve_4 as resolve,
+        render_4 as render
+    }
+}
+
+declare namespace getByText {
+    export {
+        type_4 as type,
+        resolve_3 as resolve,
+        render_3 as render
+    }
+}
+
+export declare type GotoOptions = {
+    waitUntil?: 'documentstart' | 'load';
+    domains?: string[];
+};
+
+export declare const handleRevivableModules: (defaults: readonly [osraBuildRevivablesTransfer, osraBuildRevivablesIdentity, osraBuildRevivablesArrayBuffer, osraBuildRevivablesDate, osraBuildRevivablesHeaders, osraBuildRevivablesError, osraBuildRevivablesTypedArray, osraBuildRevivablesBlob, osraBuildRevivablesPromise, osraBuildRevivablesFunction, osraBuildRevivablesMessagePort, osraBuildRevivablesReadableStream, osraBuildRevivablesAbortSignal, osraBuildRevivablesResponse, osraBuildRevivablesRequest, osraBuildRevivablesMap, osraBuildRevivablesSet, osraBuildRevivablesBigint, osraBuildRevivablesSymbol, osraBuildRevivablesEvent, osraBuildRevivablesEventTarget, {
+    readonly type: "clonable";
+    readonly capableOnly: true;
+    readonly isType: (value: unknown) => value is Clonable;
+    readonly box: (value: Clonable, _context: RevivableContext<any>) => Clonable;
+    readonly revive: (value: BoxedClonable, _context: RevivableContext<any>) => Clonable;
+}, {
+    readonly type: "transferable";
+    readonly capableOnly: true;
+    readonly isType: (value: unknown) => value is Transferable_2;
+    readonly box: (value: Transferable_2, _context: RevivableContext<any>) => Transferable_2;
+    readonly revive: (value: BoxedTransferable, _context: RevivableContext<any>) => Transferable_2;
+}, {
+    readonly type: "unclonable";
+    readonly isType: (value: unknown) => value is never;
+    readonly box: (_value: never, _context: RevivableContext<any>) => BoxedUnclonable;
+    readonly revive: (_value: BoxedUnclonable, _context: RevivableContext<any>) => Record<string, never>;
+}]) => readonly [typeof videoElement_2, osraBuildRevivablesTransfer, osraBuildRevivablesIdentity, osraBuildRevivablesArrayBuffer, osraBuildRevivablesDate, osraBuildRevivablesHeaders, osraBuildRevivablesError, osraBuildRevivablesTypedArray, osraBuildRevivablesBlob, osraBuildRevivablesPromise, osraBuildRevivablesFunction, osraBuildRevivablesMessagePort, osraBuildRevivablesReadableStream, osraBuildRevivablesAbortSignal, osraBuildRevivablesResponse, osraBuildRevivablesRequest, osraBuildRevivablesMap, osraBuildRevivablesSet, osraBuildRevivablesBigint, osraBuildRevivablesSymbol, osraBuildRevivablesEvent, osraBuildRevivablesEventTarget, {
+    readonly type: "clonable";
+    readonly capableOnly: true;
+    readonly isType: (value: unknown) => value is Clonable;
+    readonly box: (value: Clonable, _context: RevivableContext<any>) => Clonable;
+    readonly revive: (value: BoxedClonable, _context: RevivableContext<any>) => Clonable;
+}, {
+    readonly type: "transferable";
+    readonly capableOnly: true;
+    readonly isType: (value: unknown) => value is Transferable_2;
+    readonly box: (value: Transferable_2, _context: RevivableContext<any>) => Transferable_2;
+    readonly revive: (value: BoxedTransferable, _context: RevivableContext<any>) => Transferable_2;
+}, {
+    readonly type: "unclonable";
+    readonly isType: (value: unknown) => value is never;
+    readonly box: (_value: never, _context: RevivableContext<any>) => BoxedUnclonable;
+    readonly revive: (_value: BoxedUnclonable, _context: RevivableContext<any>) => Record<string, never>;
+}];
+
+declare namespace hover {
+    export {
+        type_10 as type,
+        resolve_9 as resolve
+    }
+}
+
+declare const isIP: (input: string) => 0 | 4 | 6;
+
+declare const isIPv4: (input: string) => boolean;
+
+declare const isIPv6: (input: string) => boolean;
+
+export declare const isType: (value: unknown) => value is RemoteVideoElement;
+
+declare namespace isVisible {
+    export {
+        type_12 as type,
+        resolve_11 as resolve
+    }
+}
+
+declare interface Locator extends LocatorChain<LocatorModule, Locator> {
+}
+
+declare type LocatorChain<L extends LocatorKindModule, Self> = {
+    [M in L['selectorModules'][number] as ExtractType<M>]: [
+    NextLocator<M>
+    ] extends [never] ? (...args: ExtractResolverArgs<M>) => Self : (...args: ExtractResolverArgs<M>) => NextLocator<M>;
+} & {
+    [M in L['operationModules'][number] as ExtractType<M>]: (...args: ExtractOperationArgs<M>) => Promise<Awaited<ExtractResolverReturn<M>>>;
+};
+
+declare type LocatorContext = {
+    elements: Element[];
+};
+
+declare type LocatorKindModule = {
+    readonly type: string;
+    readonly selectorModules: readonly SelectorModule[];
+    readonly operationModules: readonly OperationModule[];
+};
+
+declare type LocatorModule = typeof locatorModule;
+
+declare const locatorModule: {
+    readonly type: "locator";
+    readonly selectorModules: readonly [typeof locatorSel, {
+        readonly type: "frameLocator";
+        readonly resolve: (context: LocatorContext, selector: string) => HTMLIFrameElement[];
+        readonly resolvePeer: BarrierResolver;
+        readonly render: SelectorRenderer;
+        readonly nextLocatorType: "frameLocator";
+    }, typeof getByRole, typeof getByText, typeof getByTestId, typeof first, typeof nth];
+    readonly operationModules: readonly [typeof click, typeof fill, typeof hover, typeof textContent, typeof isVisible, typeof count, typeof exists, typeof getAttribute, typeof videoElement];
+};
+
+declare type LocatorModules = [LocatorModule, FrameLocatorModule];
+
+declare type LocatorModuleUnion = LocatorModules[number];
+
+declare namespace locatorSel {
+    export {
+        type_2 as type,
+        resolve,
+        render
+    }
+}
+
+export declare namespace net {
+    export {
+        Socket,
+        Server,
+        connect,
+        createConnection,
+        createServer,
+        isIP,
+        isIPv4,
+        isIPv6,
+        _default,
+        _default as default
+    }
+}
+
+declare type NextLocator<M> = M extends {
+    nextLocatorType: 'frameLocator';
+} ? FrameLocator : M extends {
+    nextLocatorType: 'locator';
+} ? Locator : never;
+
+declare namespace nth {
+    export {
+        type_7 as type,
+        resolve_6 as resolve,
+        render_6 as render
+    }
+}
+
+declare type OperationModule = {
+    type: string;
+    resolve: (context: LocatorContext, ...args: any[]) => unknown;
+};
+
+declare type OperationTimeoutOptions = {
+    timeout?: number;
+};
+
+declare namespace owner {
+    export {
+        type_18 as type,
+        resolve_17 as resolve,
+        resolvePeer_2 as resolvePeer,
+        render_8 as render
+    }
+}
+
+declare type ProxyFetch = Resolvers['proxyFetch'];
+
+export declare type RemoteVideoElement = EventTarget & {
+    currentTime: number;
+    volume: number;
+    muted: boolean;
+    playbackRate: number;
+    src: string;
+    loop: boolean;
+    autoplay: boolean;
+    preload: string;
+    poster: string;
+    disableRemotePlayback: boolean;
+    readonly duration: number;
+    readonly paused: boolean;
+    readonly ended: boolean;
+    readonly seeking: boolean;
+    readonly readyState: number;
+    readonly currentSrc: string;
+    readonly error: MediaError | null;
+    readonly buffered: TimeRanges;
+    readonly seekable: TimeRanges;
+    play(): Promise<void>;
+    pause(): void;
+    load(): void;
+    requestPictureInPicture(): Promise<void>;
+    exitPictureInPicture(): Promise<void>;
+    readonly HAVE_FUTURE_DATA: 3;
+    readonly HAVE_ENOUGH_DATA: 4;
+};
+
+declare const render: SelectorRenderer;
+
+declare const render_2: SelectorRenderer;
+
+declare const render_3: SelectorRenderer;
+
+declare const render_4: SelectorRenderer;
+
+declare const render_5: SelectorRenderer;
+
+declare const render_6: SelectorRenderer;
+
+declare const render_7: SelectorRenderer;
+
+declare const render_8: SelectorRenderer;
+
+declare const resolve: (context: LocatorContext, selector: string) => Element[];
+
+declare const resolve_10: (context: LocatorContext, _options?: OperationTimeoutOptions) => string;
+
+declare const resolve_11: (context: LocatorContext, _options?: OperationTimeoutOptions) => boolean;
+
+declare const resolve_12: (context: LocatorContext, _options?: OperationTimeoutOptions) => number;
+
+declare const resolve_13: (context: LocatorContext, _options?: OperationTimeoutOptions) => boolean;
+
+declare const resolve_14: (context: LocatorContext, name: string, _options?: OperationTimeoutOptions) => string | null;
+
+declare const resolve_15: (context: LocatorContext, _options?: OperationTimeoutOptions) => RemoteVideoElement;
+
+declare const resolve_16: (context: LocatorContext, selector: string) => HTMLIFrameElement[];
+
+declare const resolve_17: (_: LocatorContext) => never;
+
+declare const resolve_18: (_context: LocatorContext, options: AddStyleTagOptions) => Promise<void>;
+
+declare const resolve_2: (context: LocatorContext, role: string) => Element[];
+
+declare const resolve_3: (context: LocatorContext, text: string) => Element[];
+
+declare const resolve_4: (context: LocatorContext, testId: string) => Element[];
+
+declare const resolve_5: (context: LocatorContext) => Element[];
+
+declare const resolve_6: (context: LocatorContext, index: number) => Element[];
+
+declare const resolve_7: (context: LocatorContext, options?: OperationTimeoutOptions & {
+    position?: {
+        x?: number | undefined;
+        y?: number | undefined;
+    } | undefined;
+}) => void;
+
+declare const resolve_8: (context: LocatorContext, value: string, _options?: OperationTimeoutOptions) => void;
+
+declare const resolve_9: (context: LocatorContext, _options?: OperationTimeoutOptions) => void;
+
+declare const resolvePeer: BarrierResolver;
+
+declare const resolvePeer_2: BarrierResolver;
+
+export declare const revive: <T extends BoxedVideoElement, T2 extends RevivableContext>(value: T, context: T2) => T[typeof UnderlyingType];
+
+declare type SelectorModule = {
+    type: string;
+    resolve: (context: LocatorContext, ...args: any[]) => Element[];
+    nextLocatorType?: 'locator' | 'frameLocator';
+    resolvePeer?: BarrierResolver;
+    render?: SelectorRenderer;
+};
+
+declare type SelectorPart<L extends LocatorModuleUnion = LocatorModuleUnion> = L extends LocatorModuleUnion ? L['selectorModules'][number] extends infer M extends SelectorModule ? {
+    locatorType: L['type'];
+    type: ExtractType<M>;
+    args: ExtractResolverArgs<M>;
+} : never : never;
+
+declare type SelectorRenderer = (...args: any[]) => SelectorRenderResult;
+
+declare type SelectorRenderResult = {
+    fragment: string;
+    separator?: 'descend' | 'frame-down' | 'frame-up';
+};
+
+declare class Server extends EventEmitter implements Server_2 {
+    _localAddress?: {
+        address: string;
+        family: string;
+        port: number;
+    };
+    _webVPNTcpSocketListenerPromise?: Promise<Awaited<ReturnType<Resolvers['webVpnTcpSocketListener']>> | undefined>;
+    constructor(options?: ServerOpts & EventEmitterOptions & {
+        connection?: ReturnType<Resolvers['webVpnTcpSocketListener']>;
+    }, connectionListener?: (socket: Socket) => void);
+    __webvpn_tcp_socket_listener_init__(connection: ReturnType<Resolvers['webVpnTcpSocketListener']>): Promise<{
+        localAddress: string;
+        localFamily: "IPv4" | "IPv6";
+        localPort: number;
+        close: () => Promise<void>;
+    } | undefined>;
+    listen(port?: number | undefined, hostname?: string | undefined, backlog?: number | undefined, listeningListener?: (() => void) | undefined): this;
+    listen(port?: number | undefined, hostname?: string | undefined, listeningListener?: (() => void) | undefined): this;
+    listen(port?: number | undefined, backlog?: number | undefined, listeningListener?: (() => void) | undefined): this;
+    listen(port?: number | undefined, listeningListener?: (() => void) | undefined): this;
+    listen(path: string, backlog?: number | undefined, listeningListener?: (() => void) | undefined): this;
+    listen(path: string, listeningListener?: (() => void) | undefined): this;
+    listen(options: ListenOptions, listeningListener?: (() => void) | undefined): this;
+    listen(handle: any, backlog?: number | undefined, listeningListener?: (() => void) | undefined): this;
+    listen(handle: any, listeningListener?: (() => void) | undefined): this;
+    listen(port?: unknown, hostname?: unknown, backlog?: unknown, listeningListener?: unknown): this;
+    close(callback?: ((err?: Error | undefined) => void) | undefined): this;
+    address(): string | AddressInfo | null;
+    getConnections(cb: (error: Error | null, count: number) => void): this;
+    ref(): this;
+    unref(): this;
+    maxConnections: number;
+    connections: number;
+    listening: boolean;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+
+export declare const serverProxyFetch: (input: FetchParameters[0], init?: FetchParameters[1]) => Promise<Response>;
+
+declare class Socket extends Stream.Duplex implements Socket_2 {
+    _localAddress?: {
+        address: string;
+        family: string;
+        port: number;
+    };
+    _remoteAddress?: {
+        address: string;
+        family: string;
+        port: number;
+    };
+    _webVPNTcpSocketPromise?: Promise<(Awaited<ReturnType<Resolvers['webVpnTcpSocket']>> & {
+        reader: ReadableStreamDefaultReader<Uint8Array>;
+        writer: WritableStreamDefaultWriter<Uint8Array>;
+    }) | undefined>;
+    constructor(options?: SocketConstructorOpts & DuplexOptions & {
+        connection?: ReturnType<Resolvers['webVpnTcpSocket']>;
+    });
+    __webvpn_tcp_socket_init__(connection: ReturnType<Resolvers['webVpnTcpSocket']>): Promise<({
+        localAddress: string;
+        localFamily: "IPv4" | "IPv6";
+        localPort: number;
+        remoteAddress: string;
+        remoteFamily: "IPv4" | "IPv6";
+        remotePort: number;
+        dataReadableStream: ReadableStream<Uint8Array<ArrayBufferLike>>;
+        dataWritableStream: WritableStream<Uint8Array<ArrayBufferLike>>;
+        end: () => Promise<void>;
+        destroy: () => Promise<void>;
+        destroySoon: () => Promise<void>;
+        resetAndDestroy: () => Promise<void>;
+        setOption: (option: TcpSocketOption) => Promise<void>;
+    } & {
+        reader: ReadableStreamDefaultReader<Uint8Array>;
+        writer: WritableStreamDefaultWriter<Uint8Array>;
+    }) | undefined>;
+    /** STREAM IMPL */
+    _read(size: number): void;
+    _write(chunk: Uint8Array, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+    /** SOCKET IMPL */
+    connect(options: SocketConnectOpts, connectionListener?: (() => void) | undefined): this;
+    connect(port: number, host: string, connectionListener?: (() => void) | undefined): this;
+    connect(port: number, connectionListener?: (() => void) | undefined): this;
+    connect(path: string, connectionListener?: (() => void) | undefined): this;
+    connect(port: unknown, host?: unknown, connectionListener?: unknown): this;
+    _end(chunk: any, cb?: () => void): this;
+    _end(chunk: any, encoding?: BufferEncoding, cb?: () => void): this;
+    _destroy(error?: Error | null | undefined): this;
+    destroySoon(): void;
+    resetAndDestroy(): this;
+    _timeoutMs?: number;
+    _timeoutTimer?: ReturnType<typeof setTimeout>;
+    _restartTimeoutTimer(): void;
+    setTimeout(timeout: number, callback?: (() => void) | undefined): this;
+    setNoDelay(noDelay?: boolean | undefined): this;
+    setKeepAlive(enable?: boolean | undefined, initialDelay?: number | undefined): this;
+    setSendBufferSize(size: number): this;
+    setRecvBufferSize(size: number): this;
+    _setTcpOption(option: TcpSocketOption): void;
+    write(buffer: Uint8Array | string, cb?: (err?: Error) => void): boolean;
+    write(str: Uint8Array | string, encoding?: BufferEncoding, cb?: (err?: Error) => void): boolean;
+    address(): AddressInfo | {};
+    unref(): this;
+    ref(): this;
+    autoSelectFamilyAttemptedAddresses: string[];
+    bufferSize: number;
+    bytesRead: number;
+    bytesWritten: number;
+    connecting: boolean;
+    pending: boolean;
+    get localAddress(): string;
+    get localPort(): number;
+    get localFamily(): string;
+    readyState: 'opening' | 'open' | 'readOnly' | 'writeOnly' | 'closed';
+    get remoteAddress(): string;
+    get remotePort(): number;
+    get remoteFamily(): string;
+    timeout?: number | undefined;
+}
+
+declare class Socket_3 extends EventEmitter implements Socket_4 {
+    _type: 'udp4' | 'udp6';
+    _localAddress?: {
+        address: string;
+        family: string;
+        port: number;
+    };
+    _remoteAddress?: {
+        address: string;
+        family: string;
+        port: number;
+    };
+    _webVPNUdpSocketPromise?: Promise<Awaited<ReturnType<Resolvers['webVpnUdpSocket']>> | undefined>;
+    constructor(options: SocketOptions & EventEmitterOptions_2 & {
+        connection?: ReturnType<Resolvers['webVpnUdpSocket']>;
+    });
+    _lastRecvBufferSize: number;
+    _lastSendBufferSize: number;
+    _lastTtl: number;
+    _lastMulticastTtl: number;
+    _lastMulticastLoopback: boolean;
+    _setUdpOption(option: UdpSocketOption): void;
+    addMembership(multicastAddress: string, multicastInterface?: string | undefined): void;
+    address(): AddressInfo;
+    bind(port?: number | undefined, address?: string | undefined, callback?: (() => void) | undefined): this;
+    bind(port?: number | undefined, callback?: (() => void) | undefined): this;
+    bind(callback?: (() => void) | undefined): this;
+    bind(options: BindOptions, callback?: (() => void) | undefined): this;
+    close(callback?: (() => void) | undefined): this;
+    connect(port: number, address?: string, callback?: () => void): void;
+    connect(port: number, callback: () => void): void;
+    disconnect(): void;
+    dropMembership(multicastAddress: string, multicastInterface?: string | undefined): void;
+    getRecvBufferSize(): number;
+    getSendBufferSize(): number;
+    getSendQueueSize(): number;
+    getSendQueueCount(): number;
+    ref(): this;
+    remoteAddress(): AddressInfo;
+    send(msg: string | readonly any[] | Uint8Array, port?: number | undefined, address?: string | undefined, callback?: ((error: Error | null, bytes: number) => void) | undefined): void;
+    send(msg: string | readonly any[] | Uint8Array, port?: number | undefined, callback?: ((error: Error | null, bytes: number) => void) | undefined): void;
+    send(msg: string | readonly any[] | Uint8Array, callback?: ((error: Error | null, bytes: number) => void) | undefined): void;
+    send(msg: string | Uint8Array, offset: number, length: number, port?: number | undefined, address?: string | undefined, callback?: ((error: Error | null, bytes: number) => void) | undefined): void;
+    send(msg: string | Uint8Array, offset: number, length: number, port?: number | undefined, callback?: ((error: Error | null, bytes: number) => void) | undefined): void;
+    send(msg: string | Uint8Array, offset: number, length: number, callback?: ((error: Error | null, bytes: number) => void) | undefined): void;
+    send(msg: unknown, offset?: unknown, length?: unknown, port?: unknown, address?: unknown, callback?: unknown): void;
+    setBroadcast(flag: boolean): void;
+    setMulticastInterface(multicastInterface: string): void;
+    setMulticastLoopback(flag: boolean): boolean;
+    setMulticastTTL(ttl: number): number;
+    setRecvBufferSize(size: number): void;
+    setSendBufferSize(size: number): void;
+    setTTL(ttl: number): number;
+    unref(): this;
+    addSourceSpecificMembership(sourceAddress: string, groupAddress: string, multicastInterface?: string | undefined): void;
+    dropSourceSpecificMembership(sourceAddress: string, groupAddress: string, multicastInterface?: string | undefined): void;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+
+declare namespace textContent {
+    export {
+        type_11 as type,
+        resolve_10 as resolve
+    }
+}
+
+declare type TimeRangesTuple = [number, number][];
+
+export declare const type: "videoElement";
+
+declare const type_10: "hover";
+
+declare const type_11: "textContent";
+
+declare const type_12: "isVisible";
+
+declare const type_13: "count";
+
+declare const type_14: "exists";
+
+declare const type_15: "getAttribute";
+
+declare const type_16: "videoElement";
+
+declare const type_17: "frameLocator";
+
+declare const type_18: "owner";
+
+declare const type_19: "addStyleTag";
+
+declare const type_2: "locator";
+
+declare const type_3: "getByRole";
+
+declare const type_4: "getByText";
+
+declare const type_5: "getByTestId";
+
+declare const type_6: "first";
+
+declare const type_7: "nth";
+
+declare const type_8: "click";
+
+declare const type_9: "fill";
+
+declare namespace videoElement {
+    export {
+        type_16 as type,
+        resolve_15 as resolve
+    }
+}
+
+declare namespace videoElement_2 {
+    export {
+        type,
+        VideoElementState,
+        RemoteVideoElement,
+        BoxedVideoElement,
+        createVideoElementHandle,
+        isType,
+        box,
+        revive
+    }
+}
+
+export declare type VideoElementState = {
+    currentTime: number;
+    volume: number;
+    muted: boolean;
+    playbackRate: number;
+    src: string;
+    loop: boolean;
+    autoplay: boolean;
+    preload: string;
+    poster: string;
+    disableRemotePlayback: boolean;
+    duration: number;
+    paused: boolean;
+    ended: boolean;
+    seeking: boolean;
+    readyState: number;
+    currentSrc: string;
+    buffered: TimeRangesTuple;
+    seekable: TimeRangesTuple;
+    error: {
+        code: number;
+        message: string;
+    } | null;
+};
+
+export { }