import { c as ProtocolName, $ as RouteDescriptor, K as ITransport, a0 as ProtocolCapability, a1 as ProtocolCapabilityMap, z as PayloadCrypto, a2 as CryptoStreams } from '../ITransport-yaruAmx3.js';
export { a3 as CryptoBiStream, a4 as RouteFamily, a5 as RouteKind } from '../ITransport-yaruAmx3.js';

declare const TRANSPORT_LABELS: readonly ProtocolName[];
declare function normalizeTransport(value: unknown): ProtocolName | undefined;
declare function isBaseIroh(value: unknown): boolean;
declare function isDirectIroh(value: unknown): boolean;
declare function isOptionalTransport(value: unknown): boolean;
declare function isWebRtc(value: unknown): boolean;
declare function isIndependent(value: unknown): boolean;

declare const ROUTE_DESCRIPTORS: readonly RouteDescriptor[];
declare function getRouteDescriptor(id: ProtocolName): RouteDescriptor;
declare function listRouteDescriptors(): readonly RouteDescriptor[];

declare class TransportFactory {
    private static readonly capabilityMap;
    /** @deprecated Only WebRTC implements the legacy ITransport construction API. */
    static createTransport(name: ProtocolName): ITransport;
    static getProtocolCapability(name: ProtocolName): ProtocolCapability;
    static getProtocolCapabilities(): ProtocolCapabilityMap;
    static preferredProtocols(options?: {
        runtime?: 'browser' | 'native' | 'any';
        includePathLabels?: boolean;
    }): ProtocolName[];
    static assertProtocolAvailable(name: ProtocolName): void;
}
declare function preferredProtocols(options?: Parameters<typeof TransportFactory.preferredProtocols>[0]): ProtocolName[];

declare function isEncryptedPayload(payload: Uint8Array): boolean;
declare function createSharedCrypto(key: Uint8Array, options?: {
    requireEncrypted?: boolean;
    randomBytes?: (byteLength: number) => Uint8Array;
    replayProtection?: boolean;
}): PayloadCrypto;
declare function createCryptoStreams(crypto: PayloadCrypto, options?: {
    typeId?: number;
    maxFrameBytes?: number;
}): CryptoStreams;

declare const PUBLIC_KEY_BYTES = 32;
declare const KEY_ALGORITHM = "openrtc:x25519-hkdf:v1";
interface KeyAgreementPayload {
    algorithm: typeof KEY_ALGORITHM;
    publicKey: string;
}
interface KeyAgreement {
    publicKey: Uint8Array;
    secretKey: Uint8Array;
}
declare function createKeyAgreement(randomBytes?: (byteLength: number) => Uint8Array): KeyAgreement;
declare function deriveCryptoKey(localSecretKey: Uint8Array, remotePublicKey: Uint8Array, localNodeId: string, remoteNodeId: string): Uint8Array;
declare function encodeKeyAgreement(publicKey: Uint8Array): KeyAgreementPayload;

export { CryptoStreams, KEY_ALGORITHM, type KeyAgreementPayload, PUBLIC_KEY_BYTES, PayloadCrypto, ProtocolName, ROUTE_DESCRIPTORS, RouteDescriptor, TRANSPORT_LABELS, createCryptoStreams, createKeyAgreement, createSharedCrypto, deriveCryptoKey, encodeKeyAgreement, getRouteDescriptor, isBaseIroh, isDirectIroh, isEncryptedPayload, isIndependent, isOptionalTransport, isWebRtc, listRouteDescriptors, normalizeTransport, preferredProtocols };