@api.global/typedsocket 6.3.0 → 7.0.0

package/dist_ts/classes.nativebyteerror.d.ts

@@ -1,26 +0,0 @@
-export declare class NativeByteError extends Error {
-    readonly code: string;
-    constructor(messageArg: string, code: string, optionsArg?: ErrorOptions);
-}
-export declare class NativeByteProtocolError extends NativeByteError {
-    constructor(messageArg: string, optionsArg?: ErrorOptions);
-}
-export declare class NativeByteCapabilityError extends NativeByteError {
-    constructor(messageArg?: string, optionsArg?: ErrorOptions);
-}
-export declare class NativeByteStreamClosedError extends NativeByteError {
-    constructor(messageArg?: string, optionsArg?: ErrorOptions);
-}
-export declare class NativeMessageError extends Error {
-    readonly code: string;
-    constructor(messageArg: string, code: string, optionsArg?: ErrorOptions);
-}
-export declare class NativeMessageProtocolError extends NativeMessageError {
-    constructor(messageArg: string, optionsArg?: ErrorOptions);
-}
-export declare class NativeMessageCapabilityError extends NativeMessageError {
-    constructor(messageArg?: string, optionsArg?: ErrorOptions);
-}
-export declare class NativeMessageChannelClosedError extends NativeMessageError {
-    constructor(messageArg?: string, optionsArg?: ErrorOptions);
-}

package/dist_ts/classes.nativebyteerror.js

@@ -1,51 +0,0 @@
-export class NativeByteError extends Error {
-    constructor(messageArg, code, optionsArg) {
-        super(messageArg, optionsArg);
-        this.code = code;
-        this.name = 'NativeByteError';
-    }
-}
-export class NativeByteProtocolError extends NativeByteError {
-    constructor(messageArg, optionsArg) {
-        super(messageArg, 'NATIVE_BYTE_PROTOCOL_ERROR', optionsArg);
-        this.name = 'NativeByteProtocolError';
-    }
-}
-export class NativeByteCapabilityError extends NativeByteError {
-    constructor(messageArg = 'native-byte-v1 is unavailable', optionsArg) {
-        super(messageArg, 'NATIVE_BYTE_CAPABILITY_UNAVAILABLE', optionsArg);
-        this.name = 'NativeByteCapabilityError';
-    }
-}
-export class NativeByteStreamClosedError extends NativeByteError {
-    constructor(messageArg = 'Native byte stream is closed', optionsArg) {
-        super(messageArg, 'NATIVE_BYTE_STREAM_CLOSED', optionsArg);
-        this.name = 'NativeByteStreamClosedError';
-    }
-}
-export class NativeMessageError extends Error {
-    constructor(messageArg, code, optionsArg) {
-        super(messageArg, optionsArg);
-        this.code = code;
-        this.name = 'NativeMessageError';
-    }
-}
-export class NativeMessageProtocolError extends NativeMessageError {
-    constructor(messageArg, optionsArg) {
-        super(messageArg, 'NATIVE_MESSAGE_PROTOCOL_ERROR', optionsArg);
-        this.name = 'NativeMessageProtocolError';
-    }
-}
-export class NativeMessageCapabilityError extends NativeMessageError {
-    constructor(messageArg = 'native-message-v1 is unavailable', optionsArg) {
-        super(messageArg, 'NATIVE_MESSAGE_CAPABILITY_UNAVAILABLE', optionsArg);
-        this.name = 'NativeMessageCapabilityError';
-    }
-}
-export class NativeMessageChannelClosedError extends NativeMessageError {
-    constructor(messageArg = 'Native message channel is closed', optionsArg) {
-        super(messageArg, 'NATIVE_MESSAGE_CHANNEL_CLOSED', optionsArg);
-        this.name = 'NativeMessageChannelClosedError';
-    }
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5uYXRpdmVieXRlZXJyb3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9jbGFzc2VzLm5hdGl2ZWJ5dGVlcnJvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLE9BQU8sZUFBZ0IsU0FBUSxLQUFLO0lBQ3hDLFlBQ0UsVUFBa0IsRUFDRixJQUFZLEVBQzVCLFVBQXlCO1FBRXpCLEtBQUssQ0FBQyxVQUFVLEVBQUUsVUFBVSxDQUFDLENBQUM7UUFIZCxTQUFJLEdBQUosSUFBSSxDQUFRO1FBSTVCLElBQUksQ0FBQyxJQUFJLEdBQUcsaUJBQWlCLENBQUM7SUFDaEMsQ0FBQztDQUNGO0FBRUQsTUFBTSxPQUFPLHVCQUF3QixTQUFRLGVBQWU7SUFDMUQsWUFBWSxVQUFrQixFQUFFLFVBQXlCO1FBQ3ZELEtBQUssQ0FBQyxVQUFVLEVBQUUsNEJBQTRCLEVBQUUsVUFBVSxDQUFDLENBQUM7UUFDNUQsSUFBSSxDQUFDLElBQUksR0FBRyx5QkFBeUIsQ0FBQztJQUN4QyxDQUFDO0NBQ0Y7QUFFRCxNQUFNLE9BQU8seUJBQTBCLFNBQVEsZUFBZTtJQUM1RCxZQUFZLFVBQVUsR0FBRywrQkFBK0IsRUFBRSxVQUF5QjtRQUNqRixLQUFLLENBQUMsVUFBVSxFQUFFLG9DQUFvQyxFQUFFLFVBQVUsQ0FBQyxDQUFDO1FBQ3BFLElBQUksQ0FBQyxJQUFJLEdBQUcsMkJBQTJCLENBQUM7SUFDMUMsQ0FBQztDQUNGO0FBRUQsTUFBTSxPQUFPLDJCQUE0QixTQUFRLGVBQWU7SUFDOUQsWUFBWSxVQUFVLEdBQUcsOEJBQThCLEVBQUUsVUFBeUI7UUFDaEYsS0FBSyxDQUFDLFVBQVUsRUFBRSwyQkFBMkIsRUFBRSxVQUFVLENBQUMsQ0FBQztRQUMzRCxJQUFJLENBQUMsSUFBSSxHQUFHLDZCQUE2QixDQUFDO0lBQzVDLENBQUM7Q0FDRjtBQUVELE1BQU0sT0FBTyxrQkFBbUIsU0FBUSxLQUFLO0lBQzNDLFlBQ0UsVUFBa0IsRUFDRixJQUFZLEVBQzVCLFVBQXlCO1FBRXpCLEtBQUssQ0FBQyxVQUFVLEVBQUUsVUFBVSxDQUFDLENBQUM7UUFIZCxTQUFJLEdBQUosSUFBSSxDQUFRO1FBSTVCLElBQUksQ0FBQyxJQUFJLEdBQUcsb0JBQW9CLENBQUM7SUFDbkMsQ0FBQztDQUNGO0FBRUQsTUFBTSxPQUFPLDBCQUEyQixTQUFRLGtCQUFrQjtJQUNoRSxZQUFZLFVBQWtCLEVBQUUsVUFBeUI7UUFDdkQsS0FBSyxDQUFDLFVBQVUsRUFBRSwrQkFBK0IsRUFBRSxVQUFVLENBQUMsQ0FBQztRQUMvRCxJQUFJLENBQUMsSUFBSSxHQUFHLDRCQUE0QixDQUFDO0lBQzNDLENBQUM7Q0FDRjtBQUVELE1BQU0sT0FBTyw0QkFBNkIsU0FBUSxrQkFBa0I7SUFDbEUsWUFBWSxVQUFVLEdBQUcsa0NBQWtDLEVBQUUsVUFBeUI7UUFDcEYsS0FBSyxDQUFDLFVBQVUsRUFBRSx1Q0FBdUMsRUFBRSxVQUFVLENBQUMsQ0FBQztRQUN2RSxJQUFJLENBQUMsSUFBSSxHQUFHLDhCQUE4QixDQUFDO0lBQzdDLENBQUM7Q0FDRjtBQUVELE1BQU0sT0FBTywrQkFBZ0MsU0FBUSxrQkFBa0I7SUFDckUsWUFBWSxVQUFVLEdBQUcsa0NBQWtDLEVBQUUsVUFBeUI7UUFDcEYsS0FBSyxDQUFDLFVBQVUsRUFBRSwrQkFBK0IsRUFBRSxVQUFVLENBQUMsQ0FBQztRQUMvRCxJQUFJLENBQUMsSUFBSSxHQUFHLGlDQUFpQyxDQUFDO0lBQ2hELENBQUM7Q0FDRiJ9

package/dist_ts/classes.nativebytemanager.d.ts

@@ -1,505 +0,0 @@
-import * as plugins from './plugins.js';
-import { NativeByteStreamClosedError, NativeMessageChannelClosedError } from './classes.nativebyteerror.js';
-import type { INativeByteCapabilityStatus, INativeByteCreateReceiveGrantOptions, INativeByteDescriptor, INativeByteOpenSenderOptions, INativeByteReceipt, INativeByteReceiveGrant, INativeByteRuntime, INativeByteStats, TNativeByteCapabilityMode, TNativeByteConnectionBinding, TNativeByteRevalidate } from './interfaces.nativebytes.js';
-import type { INativeMessageCapabilityStatus, INativeMessageCreateReceiveGrantOptions, INativeMessageDescriptor, INativeMessageOpenSenderOptions, INativeMessageReceiveGrant, INativeMessageReceiver, INativeMessageSender, INativeMessageStats, TNativeMessageCapabilityMode, TNativeMessageRevalidate } from './interfaces.nativemessages.js';
-import type { TNativeByteDiagnosticEvent } from './interfaces.diagnostics.js';
-type TNativeStreamTransport = plugins.typedrequestInterfaces.INativeStreamTransport;
-type TNativeStreamEndpoint = plugins.typedrequestInterfaces.INativeStreamTransportEndpoint;
-type TSha256Hasher = ReturnType<typeof plugins.smarthash.createSha256Hasher>;
-interface IDeferred<T> {
-    readonly promise: Promise<T>;
-    readonly settled: boolean;
-    resolve(valueArg: T): void;
-    reject(errorArg: unknown): void;
-}
-interface IOutboundFrame {
-    readonly bytes: Uint8Array<ArrayBuffer>;
-    readonly streamId: string;
-    readonly protocol: 'nativeByte' | 'nativeMessage';
-    readonly producer?: IProducerState;
-    readonly payloadBytes: number;
-    readonly settlement: IDeferred<void>;
-    accountingReleased: boolean;
-    timer?: unknown;
-}
-interface INativeMessageCompleted {
-    readonly sequence: number;
-    readonly payload: Uint8Array<ArrayBuffer>;
-}
-interface INativeMessageReassembly {
-    readonly sequence: number;
-    readonly totalLength: number;
-    readonly payload: Uint8Array<ArrayBuffer>;
-    nextOffset: number;
-}
-interface INativeMessageTombstone {
-    readonly channelId: string;
-    readonly expiresAt: number;
-    readonly retainedBytes: number;
-}
-interface IProducerAdmission {
-    readonly payload: Uint8Array;
-    remainingPayloadBytes: number;
-    sourceAccountingOwned: boolean;
-    pendingOperationOwned: boolean;
-}
-interface ITombstone {
-    readonly streamId: string;
-    readonly expiresAt: number;
-    readonly confirmedFin: boolean;
-    readonly byteLength: number;
-    readonly sha256: string;
-    readonly finAck?: Uint8Array<ArrayBuffer>;
-    readonly retainedBytes: number;
-}
-type TConsumerStatus = 'grant' | 'validating-open' | 'open' | 'fin-validated' | 'awaiting-confirmation' | 'closed';
-type TProducerStatus = 'opening' | 'open' | 'finishing' | 'closed';
-type TConsumerTerminalOperation = {
-    readonly kind: 'confirm';
-    readonly promise: Promise<INativeByteReceipt>;
-} | {
-    readonly kind: 'reject';
-    readonly promise: Promise<void>;
-};
-interface IConsumerState {
-    readonly role: 'consumer';
-    readonly connection: IConnectionState;
-    readonly descriptor: INativeByteDescriptor;
-    readonly revalidate: TNativeByteRevalidate;
-    readonly principalId: string;
-    readonly revisions: {
-        readonly credentialRevision: string;
-        readonly configRevision: string;
-        readonly bindingRevision: string;
-    };
-    readonly endpoint: NativeByteReceiver;
-    readonly completion: IDeferred<INativeByteReceipt>;
-    readonly opened: IDeferred<NativeByteReceiver>;
-    readonly closedSignal: IDeferred<never>;
-    readonly revalidationControllers: Set<AbortController>;
-    readonly authorityMetadataBytes: number;
-    readonly receiveQueue: Array<Uint8Array | undefined>;
-    receiveQueueHead: number;
-    readonly receiveWaiters: Set<IDeferred<void>>;
-    readonly hasher: TSha256Hasher;
-    status: TConsumerStatus;
-    consumerReadActive: boolean;
-    timer?: unknown;
-    nextSequence: number;
-    receivedOffset: number;
-    consumedOffset: number;
-    receiveLimitOffset: number;
-    windowReservationBytes: number;
-    queuedPayloadBytes: number;
-    terminalOperation?: TConsumerTerminalOperation;
-    finalSha256?: string;
-    closeError?: NativeByteStreamClosedError;
-}
-interface IProducerState {
-    readonly role: 'producer';
-    readonly connection: IConnectionState;
-    readonly descriptor: INativeByteDescriptor;
-    readonly endpoint: NativeByteSender;
-    readonly completion: IDeferred<INativeByteReceipt>;
-    readonly opened: IDeferred<NativeByteSender>;
-    readonly closedSignal: IDeferred<never>;
-    readonly windowWaiters: Set<IDeferred<void>>;
-    readonly hasher: TSha256Hasher;
-    status: TProducerStatus;
-    operationTail: Promise<void>;
-    terminalRequested: boolean;
-    terminalPromise?: Promise<void>;
-    openTimer?: unknown;
-    idleTimer?: unknown;
-    ackTimer?: unknown;
-    finAckTimer?: unknown;
-    nextSequence: number;
-    sentOffset: number;
-    admittedOffset: number;
-    acknowledgedOffset: number;
-    receiveLimitOffset: number;
-    queuedPayloadBytes: number;
-    finalSha256?: string;
-    closeError?: NativeByteStreamClosedError;
-}
-type TStreamState = IConsumerState | IProducerState;
-type TNativeMessageReceiverStatus = 'grant' | 'validating-open' | 'open' | 'closing' | 'closed';
-type TNativeMessageSenderStatus = 'opening' | 'open' | 'closing' | 'closed';
-interface INativeMessageReceiverState {
-    readonly role: 'messageReceiver';
-    readonly connection: IConnectionState;
-    readonly descriptor: INativeMessageDescriptor;
-    readonly revalidate: TNativeMessageRevalidate;
-    readonly principalId: string;
-    readonly revisions: {
-        readonly credentialRevision: string;
-        readonly configRevision: string;
-        readonly bindingRevision: string;
-    };
-    readonly authorityMetadataBytes: number;
-    readonly endpoint: NativeMessageReceiver;
-    readonly opened: IDeferred<NativeMessageReceiver>;
-    readonly completion: IDeferred<void>;
-    readonly closedSignal: IDeferred<never>;
-    readonly receiveWaiters: Set<IDeferred<void>>;
-    readonly revalidationControllers: Set<AbortController>;
-    status: TNativeMessageReceiverStatus;
-    receiveActive: boolean;
-    nextSequence: number;
-    acceptedMaxMessageBytes: number;
-    reassembly?: INativeMessageReassembly;
-    completed?: INativeMessageCompleted;
-    remoteClosed: boolean;
-    timer?: unknown;
-    closeError?: NativeMessageChannelClosedError;
-}
-interface INativeMessageSenderState {
-    readonly role: 'messageSender';
-    readonly connection: IConnectionState;
-    readonly descriptor: INativeMessageDescriptor;
-    readonly endpoint: NativeMessageSender;
-    readonly opened: IDeferred<NativeMessageSender>;
-    readonly completion: IDeferred<void>;
-    readonly closedSignal: IDeferred<never>;
-    status: TNativeMessageSenderStatus;
-    acceptedMaxMessageBytes: number;
-    operationTail: Promise<void>;
-    nextSequence: number;
-    pendingMessages: number;
-    pendingMessageBytes: number;
-    terminalRequested: boolean;
-    closePromise?: Promise<void>;
-    awaitingAck?: {
-        readonly sequence: number;
-        readonly deferred: IDeferred<void>;
-    };
-    openTimer?: unknown;
-    progressTimer?: unknown;
-    closeTimer?: unknown;
-    closeError?: NativeMessageChannelClosedError;
-}
-type TNativeMessageChannelState = INativeMessageReceiverState | INativeMessageSenderState;
-interface IConnectionState {
-    readonly binding: TNativeByteConnectionBinding;
-    readonly transport: NativeByteConnectionTransport;
-    readonly grants: Map<string, IConsumerState>;
-    readonly streams: Map<string, TStreamState>;
-    readonly tombstones: Map<string, ITombstone>;
-    readonly messageGrants: Map<string, INativeMessageReceiverState>;
-    readonly messageChannels: Map<string, TNativeMessageChannelState>;
-    readonly messageTombstones: Map<string, INativeMessageTombstone>;
-    readonly rawQueue: Uint8Array[];
-    readonly controlQueue: IOutboundFrame[];
-    readonly dataQueue: IOutboundFrame[];
-    serverInflightFrame?: IOutboundFrame;
-    serverInflightTransportFrame?: Extract<plugins.TWebSocketOutboundRawFrame, {
-        type: 'binary';
-    }>;
-    readonly revalidationControllers: Set<AbortController>;
-    negotiated: boolean;
-    nativeEnabled: boolean;
-    messageNegotiated: boolean;
-    nativeMessageEnabled: boolean;
-    closed: boolean;
-    processingRaw: boolean;
-    rawQueueBytes: number;
-    processingRawBytes: number;
-    queuedPayloadBytes: number;
-    nativeMessageQueuedPayloadBytes: number;
-    authorityMetadataBytes: number;
-    tombstoneBytes: number;
-    receiveWindowReservedBytes: number;
-    pendingProducerDataOperations: number;
-    retainedRevalidations: number;
-    serverWakeOutstanding: boolean;
-    clientTurnScheduled: boolean;
-    clientBackpressureTimer?: unknown;
-    negotiationTimer?: unknown;
-    nativeMessageNegotiationTimer?: unknown;
-}
-export declare class NativeByteReceiver implements TNativeStreamEndpoint {
-    private readonly manager;
-    private readonly state;
-    readonly protocol: "native-byte-v1";
-    readonly direction: "receive";
-    readonly readable: ReadableStream<Uint8Array>;
-    private manifestInternal;
-    constructor(manager: NativeByteManager, state: IConsumerState);
-    get closed(): Promise<void>;
-    get manifest(): plugins.typedrequestInterfaces.INativeByteStreamManifest;
-    get completion(): Promise<INativeByteReceipt>;
-    sendData(_dataArg: Uint8Array): Promise<void>;
-    fetchData(): Promise<Uint8Array>;
-    readFromWebstream(_readableStreamArg: ReadableStream<Uint8Array>): Promise<void>;
-    writeToWebstream(writableStreamArg: WritableStream<Uint8Array>): Promise<void>;
-    close(_sendClosingBitArg?: boolean): Promise<void>;
-    abort(reasonArg?: unknown): Promise<void>;
-    reject(reasonArg?: unknown): Promise<void>;
-    confirmDurable(): Promise<INativeByteReceipt>;
-}
-export declare class NativeByteSender implements TNativeStreamEndpoint {
-    private readonly manager;
-    private readonly state;
-    readonly protocol: "native-byte-v1";
-    readonly direction: "send";
-    readonly writable: WritableStream<Uint8Array>;
-    private manifestInternal;
-    constructor(manager: NativeByteManager, state: IProducerState);
-    get closed(): Promise<void>;
-    get manifest(): plugins.typedrequestInterfaces.INativeByteStreamManifest;
-    get completion(): Promise<INativeByteReceipt>;
-    sendData(dataArg: Uint8Array): Promise<void>;
-    fetchData(): Promise<Uint8Array>;
-    readFromWebstream(readableStreamArg: ReadableStream<Uint8Array>, closeAfterReadingArg?: boolean): Promise<void>;
-    writeToWebstream(_writableStreamArg: WritableStream<Uint8Array>): Promise<void>;
-    close(_sendClosingBitArg?: boolean): Promise<void>;
-    abort(reasonArg?: unknown): Promise<void>;
-}
-export declare class NativeMessageReceiver implements INativeMessageReceiver {
-    private readonly manager;
-    private readonly state;
-    constructor(manager: NativeByteManager, state: INativeMessageReceiverState);
-    get closed(): Promise<void>;
-    receive(): Promise<Uint8Array | undefined>;
-    reject(reasonArg?: unknown): Promise<void>;
-}
-export declare class NativeMessageSender implements INativeMessageSender {
-    private readonly manager;
-    private readonly state;
-    constructor(manager: NativeByteManager, state: INativeMessageSenderState);
-    get closed(): Promise<void>;
-    send(messageArg: Uint8Array): Promise<void>;
-    close(): Promise<void>;
-}
-export declare class NativeMessageFacade {
-    #private;
-    constructor(managerArg: NativeByteManager);
-    createReceiveGrant(optionsArg: INativeMessageCreateReceiveGrantOptions): INativeMessageReceiveGrant;
-    openSender(descriptorArg: INativeMessageDescriptor, optionsArg?: INativeMessageOpenSenderOptions): Promise<INativeMessageSender>;
-    getCapability(targetArg?: {
-        readonly peer: plugins.IWebSocketPeer;
-    } | plugins.IWebSocketPeer): INativeMessageCapabilityStatus;
-    getStats(targetArg?: {
-        readonly peer: plugins.IWebSocketPeer;
-    } | plugins.IWebSocketPeer): INativeMessageStats;
-    normalizeMaxMessageBytes(valueArg: unknown): number;
-}
-declare class NativeByteConnectionTransport implements TNativeStreamTransport {
-    private readonly manager;
-    private readonly connection;
-    constructor(manager: NativeByteManager, connection: IConnectionState);
-    get capabilities(): readonly ['native-byte-v1'] | readonly [];
-    requireCapability(requirementArg: plugins.typedrequestInterfaces.INativeStreamCapabilityRequirement): void;
-    registerNativeStream(): plugins.typedrequestInterfaces.INativeStreamTransportRegistration;
-    openNativeStream(descriptorArg: plugins.typedrequestInterfaces.TNativeStreamDescriptor): Promise<TNativeStreamEndpoint>;
-}
-export interface INativeByteManagerOptions {
-    readonly side: 'client' | 'server';
-    readonly capabilityMode?: TNativeByteCapabilityMode;
-    readonly nativeMessageCapabilityMode?: TNativeMessageCapabilityMode;
-    readonly runtime?: INativeByteRuntime;
-    /** Structured close/rejection diagnostics; must not throw, errors are swallowed. */
-    readonly onDiagnostic?: (eventArg: TNativeByteDiagnosticEvent) => void;
-}
-export declare class NativeByteManager {
-    readonly webSocketTransportOwner: plugins.IWebSocketTransportOwner;
-    readonly messages: NativeMessageFacade;
-    private readonly side;
-    private readonly capabilityMode;
-    private readonly nativeMessageCapabilityMode;
-    private readonly runtime;
-    private readonly onDiagnostic?;
-    private readonly clientNativeStreamTransport;
-    private readonly serverConnections;
-    private readonly serverSettlementConnections;
-    private readonly serverAccountingConnections;
-    private currentClientConnection;
-    private serverAttached;
-    private retainedRevalidations;
-    private readonly retainedRevalidationsByPrincipal;
-    constructor(optionsArg: INativeByteManagerOptions);
-    attachServer(): void;
-    detachServer(): void;
-    bindClientConnection(webSocketArg: WebSocket, generationArg: number): void;
-    unbindClientConnection(webSocketArg: WebSocket, generationArg: number, reasonArg?: unknown): void;
-    enqueueClientRawFrame(webSocketArg: WebSocket, generationArg: number, dataArg: ArrayBuffer | ArrayBufferView): void;
-    getClientNegotiationAdvertisement(): {
-        protocolMajor: 6;
-        capabilities: readonly ['native-byte-v1'] | readonly [];
-    };
-    completeClientNegotiation(webSocketArg: WebSocket, generationArg: number, responseArg: {
-        protocolMajor: number;
-        capabilities: readonly string[];
-        required?: boolean;
-    }): void;
-    failOptionalClientNegotiation(webSocketArg: WebSocket, generationArg: number): void;
-    negotiateServerPeer(peerArg: plugins.IWebSocketPeer, requestArg: {
-        protocolMajor: number;
-        capabilities: readonly string[];
-    }): {
-        protocolMajor: 6;
-        capabilities: readonly ['native-byte-v1'] | readonly [];
-        required: boolean;
-    };
-    getClientNativeMessageNegotiationAdvertisement(): {
-        protocolMajor: 1;
-        capabilities: readonly ['native-message-v1'] | readonly [];
-    };
-    completeClientNativeMessageNegotiation(webSocketArg: WebSocket, generationArg: number, responseArg: {
-        protocolMajor: number;
-        capabilities: readonly string[];
-        required?: boolean;
-    }): void;
-    failOptionalClientNativeMessageNegotiation(webSocketArg: WebSocket, generationArg: number): void;
-    negotiateServerNativeMessages(peerArg: plugins.IWebSocketPeer, requestArg: {
-        protocolMajor: number;
-        capabilities: readonly string[];
-    }): {
-        protocolMajor: 1;
-        capabilities: readonly ['native-message-v1'] | readonly [];
-        required: boolean;
-    };
-    connectionHasNativeMessageCapability(connectionArg: IConnectionState): boolean;
-    getClientNativeStreamTransport(): TNativeStreamTransport | undefined;
-    getServerNativeStreamTransport(peerArg: plugins.IWebSocketPeer): TNativeStreamTransport | undefined;
-    connectionHasCapability(connectionArg: IConnectionState): boolean;
-    createReceiveGrant(optionsArg: INativeByteCreateReceiveGrantOptions): INativeByteReceiveGrant;
-    normalizeManifest(manifestArg: plugins.typedrequestInterfaces.INativeByteStreamManifest): plugins.typedrequestInterfaces.INativeByteStreamManifest;
-    createReceiveRegistration(optionsArg: INativeByteCreateReceiveGrantOptions): plugins.typedrequestInterfaces.INativeByteStreamTransportRegistration;
-    openSender(descriptorArg: INativeByteDescriptor, optionsArg?: INativeByteOpenSenderOptions): Promise<NativeByteSender>;
-    getCapability(targetArg?: {
-        readonly peer: plugins.IWebSocketPeer;
-    } | plugins.IWebSocketPeer): INativeByteCapabilityStatus;
-    getStats(targetArg?: {
-        readonly peer: plugins.IWebSocketPeer;
-    } | plugins.IWebSocketPeer): INativeByteStats;
-    createNativeMessageReceiveGrant(optionsArg: INativeMessageCreateReceiveGrantOptions): INativeMessageReceiveGrant;
-    openNativeMessageSender(descriptorArg: INativeMessageDescriptor, optionsArg?: INativeMessageOpenSenderOptions): Promise<NativeMessageSender>;
-    getNativeMessageCapability(targetArg?: {
-        readonly peer: plugins.IWebSocketPeer;
-    } | plugins.IWebSocketPeer): INativeMessageCapabilityStatus;
-    getNativeMessageStats(targetArg?: {
-        readonly peer: plugins.IWebSocketPeer;
-    } | plugins.IWebSocketPeer): INativeMessageStats;
-    registerGenericNativeStream(connectionArg: IConnectionState): plugins.typedrequestInterfaces.INativeStreamTransportRegistration;
-    openSenderOnConnection(connectionArg: IConnectionState, descriptorArg: plugins.typedrequestInterfaces.TNativeStreamDescriptor): Promise<NativeByteSender>;
-    enqueueProducerData(stateArg: IProducerState, dataArg: Uint8Array): Promise<void>;
-    closeProducer(stateArg: IProducerState): Promise<void>;
-    private admitProducerData;
-    private releaseProducerAdmission;
-    sendProducerData(stateArg: IProducerState, admissionArg: IProducerAdmission): Promise<void>;
-    finishProducer(stateArg: IProducerState): Promise<void>;
-    abortProducer(stateArg: IProducerState, reasonArg?: unknown): Promise<void>;
-    sendNativeMessage(stateArg: INativeMessageSenderState, messageArg: Uint8Array): Promise<void>;
-    private admitNativeMessage;
-    private sendNativeMessageAdmission;
-    private releaseNativeMessageAdmission;
-    closeNativeMessageSender(stateArg: INativeMessageSenderState): Promise<void>;
-    private finishNativeMessageSender;
-    receiveNativeMessage(stateArg: INativeMessageReceiverState): Promise<Uint8Array | undefined>;
-    rejectNativeMessageReceiver(stateArg: INativeMessageReceiverState, reasonArg?: unknown): Promise<void>;
-    private refreshNativeMessageSenderProgressTimer;
-    private refreshNativeMessageReceiverProgressTimer;
-    private getConsumerQueueLength;
-    consumeReceiverData(stateArg: IConsumerState): Promise<Uint8Array | undefined>;
-    private consumeReceiverDataOnce;
-    getConsumerCloseError(stateArg: IConsumerState, messageArg?: string): NativeByteStreamClosedError;
-    confirmConsumerDurable(stateArg: IConsumerState): Promise<INativeByteReceipt>;
-    private confirmConsumerDurableOnce;
-    rejectConsumer(stateArg: IConsumerState, reasonArg?: unknown): Promise<void>;
-    private rejectConsumerOnce;
-    private createConnection;
-    private bindServerPeer;
-    private unbindServerPeer;
-    private enqueueServerRawFrame;
-    private enqueueRawFrame;
-    private processRawQueue;
-    private handleFrame;
-    private handleNativeMessageFrame;
-    private handleNativeMessageOpen;
-    private handleNativeMessageOpenAck;
-    private handleNativeMessageFragment;
-    private handleNativeMessageAck;
-    private handleNativeMessageClose;
-    private handleNativeMessageCloseAck;
-    private handleNativeMessageReset;
-    private handleOpen;
-    private handleOpenAck;
-    private handleData;
-    private handleAck;
-    private handleFin;
-    private handleFinAck;
-    private handleReset;
-    private createReceiveGrantOnConnection;
-    private validateDescriptor;
-    private validateNativeMessageDescriptor;
-    private resolveNativeMessageConnection;
-    private requireNativeMessageCapability;
-    private reserveNativeMessageChannelSlot;
-    private resolveConnection;
-    private resolveConnectionForInspection;
-    private requireConnectionCapability;
-    private reserveStreamSlot;
-    private normalizePrincipalId;
-    private normalizeAuthorityRevision;
-    private getServerConnectionCount;
-    private getServerNativeByteStreamCount;
-    private getServerAggregateSlotCount;
-    private getServerRetainedBytes;
-    private getServerReceiveReservationBytes;
-    private assertServerRetainedByteCapacity;
-    private assertServerReceiveReservationCapacity;
-    private maybeReleaseServerAccountingConnection;
-    private revalidateNativeMessageReceiver;
-    private getNativeMessageRevalidationResetCode;
-    private assertNativeMessageReceiverOwned;
-    private assertNativeMessageSenderOpen;
-    private wakeNativeMessageReceiveWaiters;
-    private failNativeMessageChannelProtocol;
-    private failNativeMessageSender;
-    private failNativeMessageReceiver;
-    private cleanupNativeMessageSender;
-    private cleanupNativeMessageReceiver;
-    private tryAddNativeMessageTombstone;
-    private addNativeMessageTombstone;
-    private pruneNativeMessageTombstones;
-    private deleteNativeMessageTombstone;
-    private revalidateConsumer;
-    private getRevalidationResetCode;
-    private assertConsumerOwned;
-    private assertProducerOpen;
-    private waitForProducerWindow;
-    private wakeProducerWindowWaiters;
-    private wakeConsumerReceiveWaiters;
-    private refreshProducerIdleTimer;
-    private refreshProducerAckTimer;
-    private refreshConsumerIdleTimer;
-    private enterAwaitingConfirmation;
-    private clearProducerProgressTimers;
-    private failStreamProtocol;
-    private failProducer;
-    private failConsumer;
-    private cleanupProducer;
-    private cleanupConsumer;
-    private tryAddCleanupTombstone;
-    private addTombstone;
-    private pruneTombstones;
-    private deleteTombstone;
-    private sendReset;
-    private sendNativeMessageReset;
-    private enqueueNativeMessageFrame;
-    private enqueueFrame;
-    private enqueueEncodedFrame;
-    private wakeOutbound;
-    private runClientOutboundTurn;
-    private pullServerBinaryFrame;
-    private settleServerOutboundFrame;
-    private settleOutboundFrame;
-    private releaseOutboundQueueBytes;
-    private releaseProducerPayloadAccounting;
-    private removeQueuedFramesForStream;
-    private emitDiagnostic;
-    private closeConnection;
-    private failConnection;
-}
-export {};