p2party 0.14.2 → 0.14.7

package/lib/blindRendezvous/pairPlaintext.d.ts

@@ -0,0 +1,240 @@
+/**
+ * Canonical pair-private plaintext codec (Sections 4.11–4.13).
+ *
+ * This module begins only after pair AEAD has authenticated a candidate. It
+ * owns the closed body union, initial direction/sequence/predecessor shapes,
+ * candidate-ID ordering, and the unique class-sized all-zero padding suffix.
+ * Pair secrets, HPKE, AEAD, admission, exact predecessor IDs, and durable fork
+ * state deliberately remain outside this codec.
+ *
+ * Status: PROPOSED, NOT FROZEN. Release use still requires the Phase-0
+ * canonical vectors and registry freeze named by the specification.
+ */
+import { PAIR_BOOTSTRAP_SUITE_ID_V1 } from "./pairBootstrapSuite";
+import type { AdmissionGrantV1 } from "./operationPayload";
+import type { OperationPayloadClassV1 } from "./operation";
+import type { RoomPqMode } from "../roomPolicy";
+export type PairStepKindV1 = "IDENTITY_HELLO" | "IDENTITY_ACCEPT" | "TRANSPORT_OFFER" | "TRANSPORT_ANSWER" | "V4_HANDSHAKE" | "PQ_CONTROL" | "QUIESCE_PROPOSE" | "QUIESCE_ACK" | "HEAL_COMPLETE" | "PAIR_CHECKPOINT";
+export type PairAttemptModeV1 = "planner" | "explicit";
+export interface StableIdentityBundleV1 {
+    readonly ed25519PublicKey: Uint8Array;
+    readonly x25519PublicKey: Uint8Array;
+    readonly x25519CrossSignature: Uint8Array;
+}
+export interface PairIdentityHelloUnsignedV1 {
+    readonly version: 1;
+    readonly attemptMode: PairAttemptModeV1;
+    readonly senderIdentity: StableIdentityBundleV1;
+    readonly senderPresenceCommitment: Uint8Array;
+    readonly senderAdmissionGrant: AdmissionGrantV1 | null;
+    readonly responseHybridKemPublicKey: Uint8Array;
+}
+export interface PairIdentityHelloV1 extends PairIdentityHelloUnsignedV1 {
+    readonly identityTranscriptSignature: Uint8Array;
+}
+export interface PairIdentityAcceptUnsignedV1 {
+    readonly version: 1;
+    readonly responderIdentity: StableIdentityBundleV1;
+    readonly responderPresenceCommitment: Uint8Array;
+    readonly responderAdmissionGrant: AdmissionGrantV1 | null;
+}
+export interface PairIdentityAcceptV1 extends PairIdentityAcceptUnsignedV1 {
+    readonly identityTranscriptSignature: Uint8Array;
+}
+export interface StableEdgeAttemptClaimUnsignedV1 {
+    readonly version: 1;
+    readonly stableEdgeId: Uint8Array;
+    readonly pairEdgeId: Uint8Array;
+    readonly confirmedPairTranscriptId: Uint8Array;
+    readonly claimantStableEd25519PublicKey: Uint8Array;
+    readonly claimNotBeforeLogicalWindow: bigint;
+    readonly claimNotAfterLogicalWindow: bigint;
+}
+export interface StableEdgeAttemptClaimV1 extends StableEdgeAttemptClaimUnsignedV1 {
+    readonly claimantSignature: Uint8Array;
+}
+export type PairTransportCandidateV1 = {
+    readonly version: 1;
+    readonly kind: "webrtc-complete";
+    readonly exactSdpUtf8: Uint8Array;
+} | {
+    readonly version: 1;
+    readonly kind: "operation-carrier";
+} | {
+    readonly version: 1;
+    readonly kind: "registered-local-link";
+    readonly adapterProtocolId: number;
+    readonly fixedCanonicalCandidate: Uint8Array;
+};
+export interface PairTransportOfferV1 {
+    readonly version: 1;
+    readonly initiatorStableEdgeClaim: StableEdgeAttemptClaimV1;
+    readonly candidates: readonly PairTransportCandidateV1[];
+}
+export interface PairTransportAnswerV1 {
+    readonly version: 1;
+    readonly responderStableEdgeClaim: StableEdgeAttemptClaimV1;
+    readonly selectedOfferCandidateId: Uint8Array;
+    readonly answer: PairTransportCandidateV1;
+}
+export interface QuiesceProposeV1 {
+    readonly version: 1;
+    readonly pqEpoch: bigint;
+}
+export interface QuiesceAckV1 {
+    readonly version: 1;
+    readonly pqEpoch: bigint;
+}
+export interface HealCompleteV1 {
+    readonly version: 1;
+    readonly newPqEpoch: bigint;
+}
+export interface PairCheckpointV1 {
+    readonly version: 1;
+    readonly pqEpoch: bigint;
+}
+export type PairStepBodyV1 = {
+    readonly kind: "IDENTITY_HELLO";
+    readonly value: PairIdentityHelloV1;
+} | {
+    readonly kind: "IDENTITY_ACCEPT";
+    readonly value: PairIdentityAcceptV1;
+} | {
+    readonly kind: "TRANSPORT_OFFER";
+    readonly value: PairTransportOfferV1;
+} | {
+    readonly kind: "TRANSPORT_ANSWER";
+    readonly value: PairTransportAnswerV1;
+} | {
+    readonly kind: "V4_HANDSHAKE";
+    readonly value: Uint8Array;
+} | {
+    readonly kind: "PQ_CONTROL";
+    readonly value: Uint8Array;
+} | {
+    readonly kind: "QUIESCE_PROPOSE";
+    readonly value: QuiesceProposeV1;
+} | {
+    readonly kind: "QUIESCE_ACK";
+    readonly value: QuiesceAckV1;
+} | {
+    readonly kind: "HEAL_COMPLETE";
+    readonly value: HealCompleteV1;
+} | {
+    readonly kind: "PAIR_CHECKPOINT";
+    readonly value: PairCheckpointV1;
+};
+export interface PairPlaintextV1 {
+    readonly version: 1;
+    readonly kind: PairStepKindV1;
+    readonly pairEdgeId: Uint8Array;
+    readonly endpointPresenceOperationIds: readonly [Uint8Array, Uint8Array];
+    readonly direction: 0 | 1;
+    readonly pairSequence: bigint;
+    readonly previousPairOperationId: Uint8Array | null;
+    readonly pairDependencies: readonly Uint8Array[];
+    readonly body: PairStepBodyV1;
+    readonly pairPadding: Uint8Array;
+}
+export type PairIdentityUnsignedBodyV1 = {
+    readonly kind: "IDENTITY_HELLO";
+    readonly value: PairIdentityHelloUnsignedV1;
+} | {
+    readonly kind: "IDENTITY_ACCEPT";
+    readonly value: PairIdentityAcceptUnsignedV1;
+};
+export interface PairIdentityUnsignedProjectionV1 {
+    readonly version: 1;
+    readonly kind: "IDENTITY_HELLO" | "IDENTITY_ACCEPT";
+    readonly pairEdgeId: Uint8Array;
+    readonly endpointPresenceOperationIds: readonly [Uint8Array, Uint8Array];
+    readonly direction: 0 | 1;
+    readonly pairSequence: bigint;
+    readonly previousPairOperationId: Uint8Array | null;
+    readonly pairDependencies: readonly Uint8Array[];
+    readonly body: PairIdentityUnsignedBodyV1;
+    readonly pairPadding: Uint8Array;
+}
+export interface PairOuterPrebindingV1 {
+    readonly version: 1;
+    readonly roomContextConfirmation: Uint8Array;
+    readonly policyHash: Uint8Array;
+    readonly logicalWindow: bigint;
+    readonly expiresAfterWindow: bigint;
+    readonly lifetime: "PAIR_CAUSAL";
+    readonly authorEpochEd25519Key: Uint8Array;
+    readonly authorSequence: bigint;
+    readonly previousAuthorOperationId: Uint8Array | null;
+    readonly kind: "PAIR_STEP";
+    readonly dependencies: readonly [];
+    readonly operationPayloadClass: OperationPayloadClassV1;
+    readonly bootstrapHeaderHash: Uint8Array;
+    readonly nonce: Uint8Array | null;
+}
+export interface PairOuterBindingV1 {
+    readonly prebinding: PairOuterPrebindingV1;
+    readonly pairRoutingTag: Uint8Array;
+    readonly semanticSlot: Uint8Array;
+}
+export interface PairFlightSlotV1 {
+    readonly kind: PairStepKindV1;
+    readonly direction: 0 | 1;
+    readonly pairSequence: bigint;
+}
+export type PairBootstrapRecipientBindingV1 = {
+    readonly kind: "presence";
+    readonly presenceOperationId: Uint8Array;
+} | {
+    readonly kind: "hello-response";
+    readonly helloOperationId: Uint8Array;
+};
+export interface PairBootstrapInfoV1 {
+    readonly version: 1;
+    readonly pairBootstrapSuite: typeof PAIR_BOOTSTRAP_SUITE_ID_V1;
+    readonly roomContextConfirmation: Uint8Array;
+    readonly policyHash: Uint8Array;
+    readonly stepKind: "IDENTITY_HELLO" | "IDENTITY_ACCEPT";
+    readonly logicalWindow: bigint;
+    readonly expiresAfterWindow: bigint;
+    readonly authorEpochEd25519Key: Uint8Array;
+    readonly authorSequence: bigint;
+    readonly previousAuthorOperationId: Uint8Array | null;
+    readonly operationPayloadClass: OperationPayloadClassV1;
+    readonly recipientBinding: PairBootstrapRecipientBindingV1;
+}
+export declare class PairPlaintextError extends Error {
+    readonly name = "PairPlaintextError";
+    constructor(message: string);
+}
+export declare const validatePairFlightSlotV1: (value: PairFlightSlotV1) => void;
+export declare const validatePairBootstrapInfoV1: (value: PairBootstrapInfoV1) => void;
+/** Canonical HPKE `info` bytes after the complete bootstrap-info gate. */
+export declare const encodePairBootstrapInfoV1: (value: PairBootstrapInfoV1) => Uint8Array;
+/**
+ * Select the numerically smallest class for an empty-padding plaintext.
+ *
+ * This calculation is intentionally available before encryption. A receiver
+ * invokes the same rule only after AEAD opening exposes the plaintext.
+ */
+export declare const pairOperationPayloadClassForV1: (plaintextWithEmptyPadding: PairPlaintextV1, bootstrapHeaderPresent: boolean) => OperationPayloadClassV1;
+/** Validate an already decoded pair plaintext without mutating caller bytes. */
+export declare const validatePairPlaintextV1: (plaintext: PairPlaintextV1, operationPayloadClass: OperationPayloadClassV1, bootstrapHeaderPresent: boolean, roomPqMode: RoomPqMode) => Promise<void>;
+/**
+ * Fill the unique authenticated zero suffix and return the selected outer
+ * class together with an independently owned plaintext.
+ */
+export declare const padPairPlaintextV1: (plaintextWithEmptyPadding: PairPlaintextV1, bootstrapHeaderPresent: boolean, roomPqMode: RoomPqMode) => Promise<{
+    readonly operationPayloadClass: OperationPayloadClassV1;
+    readonly plaintext: PairPlaintextV1;
+}>;
+/** Encode only the one canonical, minimally classified, target-sized value. */
+export declare const encodePairPlaintextV1: (plaintext: PairPlaintextV1, operationPayloadClass: OperationPayloadClassV1, bootstrapHeaderPresent: boolean, roomPqMode: RoomPqMode) => Promise<Uint8Array>;
+/** Strictly decode and validate the signed outer class/header state. */
+export declare const decodePairPlaintextV1: (encoded: Uint8Array, operationPayloadClass: OperationPayloadClassV1, bootstrapHeaderPresent: boolean, roomPqMode: RoomPqMode) => Promise<PairPlaintextV1>;
+/**
+ * Remove exactly the nested stable-identity transcript signature.
+ *
+ * The result uses a record descriptor rather than a new top-level union tag;
+ * every outer field and the exact pair padding remain in the projection.
+ */
+export declare const pairIdentityUnsignedProjectionV1: (plaintext: PairPlaintextV1) => PairIdentityUnsignedProjectionV1;

package/lib/blindRendezvous/pairStepEnvelope.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Canonical room-visible pair envelope framing (Section 4.11).
+ *
+ * This is deliberately only the endpoint-independent outer boundary. It
+ * validates routing-tag framing, bootstrap-header/nonce state, and exact
+ * class-sized ciphertext framing without opening pair AEAD or interpreting a
+ * `PairPlaintextV1`. Tag expectation/one-use, admission, and the edge-local
+ * pair state machine remain outside this module.
+ *
+ * Status: PROPOSED, NOT FROZEN. This implements the Phase-0 outer boundary,
+ * but does not by itself publish a release-registry vector or interoperability
+ * claim.
+ *
+ * The schema and operation class table are the size SSOTs. Framing overhead is
+ * measured from a canonical empty-ciphertext encoding, then the exact
+ * ciphertext and plaintext targets are derived from it. No second target table
+ * is maintained here.
+ */
+import { PAIR_BOOTSTRAP_SUITE_ID_V1 } from "./pairBootstrapSuite";
+import type { OperationPayloadClassV1 } from "./operation";
+export declare const PAIR_STEP_ENVELOPE_VERSION_V1 = 1;
+export declare const PAIR_BOOTSTRAP_HEADER_VERSION_V1 = 1;
+export { PAIR_BOOTSTRAP_SUITE_ID_V1 } from "./pairBootstrapSuite";
+export declare const PAIR_AEAD_TAG_BYTES_V1: number;
+export interface PairBootstrapHeaderV1 {
+    version: 1;
+    suiteId: typeof PAIR_BOOTSTRAP_SUITE_ID_V1;
+    hybridKemCiphertext: Uint8Array;
+}
+export interface PairStepEnvelopeV1 {
+    version: 1;
+    pairRoutingTag: Uint8Array;
+    bootstrapHeader: PairBootstrapHeaderV1 | null;
+    nonce: Uint8Array | null;
+    pairCiphertextAndTag: Uint8Array;
+}
+export declare class PairStepEnvelopeError extends Error {
+    readonly name = "PairStepEnvelopeError";
+    constructor(message: string);
+}
+/**
+ * These exported values are projections of the schema above, not literals.
+ * Changing an optional tag, fixed field, or length prefix changes them
+ * automatically and therefore changes every derived target/vector.
+ */
+export declare const PAIR_BOOTSTRAP_ENVELOPE_OVERHEAD_BYTES_V1: number;
+export declare const PAIR_ESTABLISHED_ENVELOPE_OVERHEAD_BYTES_V1: number;
+/**
+ * Exact `pairCiphertextAndTag` bytes for one permitted outer envelope form.
+ * Suite 1 deliberately has no class-1 bootstrap form.
+ */
+export declare const pairCiphertextAndTagTargetBytesV1: (operationPayloadClass: OperationPayloadClassV1, bootstrap: boolean) => number;
+/** Exact authenticated pair-plaintext target after removing the AEAD tag. */
+export declare const pairPlaintextTargetBytesV1: (operationPayloadClass: OperationPayloadClassV1, bootstrap: boolean) => number;
+/** Validate a decoded envelope against its signed outer payload class. */
+export declare const validatePairStepEnvelopeV1: (envelope: PairStepEnvelopeV1, operationPayloadClass: OperationPayloadClassV1) => void;
+/** Encode only after all class-dependent outer invariants hold. */
+export declare const encodePairStepEnvelopeV1: (envelope: PairStepEnvelopeV1, operationPayloadClass: OperationPayloadClassV1) => Uint8Array;
+/** Decode uniquely, then enforce the signed class-dependent invariants. */
+export declare const decodePairStepEnvelopeV1: (encoded: Uint8Array, operationPayloadClass: OperationPayloadClassV1) => PairStepEnvelopeV1;

package/lib/blindRendezvous/plannerState.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Canonical local planner/topology persistence state.
+ *
+ * Core room reduction deliberately contains no local topology preference.
+ * This module is the one local SSOT for planner policy, explicit requests,
+ * provisional pair edges, and active stable edges. Counts are always derived
+ * from canonical edge sets; there are no independently mutable counters.
+ *
+ * This module deliberately exposes no desired-neighbor or reservation
+ * authority yet. That transition must consume an opaque result of the trusted
+ * local `Project`, then compare-and-swap this exact captured row with every
+ * other admission fence. Raw caller-supplied "selected" booleans are not a
+ * planner proof.
+ */
+export type ConnectionPlannerModeV1 = "explicit" | "sparse-ring" | "full-mesh-small-room";
+export interface ConnectionPlannerPolicyV1 {
+    readonly version: 1;
+    readonly mode: ConnectionPlannerModeV1;
+    readonly sparseRadius: number;
+    readonly maxProvisionalEdges: number;
+    readonly maxActiveStableEdges: number;
+    readonly fullMeshMaxMembers: number;
+    readonly allowOnDemandEdges: boolean;
+}
+export interface ProvisionalTopologyEdgeV1 {
+    readonly pairEdgeId: Uint8Array;
+    readonly endpointPresenceOperationIds: readonly [Uint8Array, Uint8Array];
+    readonly remoteLocalPeerId: string;
+}
+export interface ActiveStableTopologyEdgeV1 {
+    readonly stableEdgeId: Uint8Array;
+    readonly remoteLocalPeerId: string;
+}
+export interface PlannerAndExplicitStateV1 {
+    readonly version: 1;
+    readonly roomContextId: Uint8Array;
+    readonly plannerPolicy: ConnectionPlannerPolicyV1;
+    readonly requestedExplicitPeerIds: readonly string[];
+    readonly provisionalEdges: readonly ProvisionalTopologyEdgeV1[];
+    readonly activeStableEdges: readonly ActiveStableTopologyEdgeV1[];
+}
+export interface PlannerStateValidationLimitsV1 {
+    readonly maxRoomMembers: number;
+    readonly maxPairLedgerEntriesPerRoom: number;
+}
+export declare class PlannerStateError extends Error {
+    readonly name = "PlannerStateError";
+    constructor(message: string);
+}
+/** Strictly own and validate one complete planner/topology state. */
+export declare const validateAndCopyPlannerAndExplicitStateV1: (value: unknown, limitsValue: PlannerStateValidationLimitsV1) => PlannerAndExplicitStateV1;
+/** Canonical durable planner/topology bytes. */
+export declare const encodePlannerAndExplicitStateV1: (value: unknown, limits: PlannerStateValidationLimitsV1) => Uint8Array;
+/** Strictly restore and own one canonical durable planner/topology row. */
+export declare const decodePlannerAndExplicitStateV1: (encoded: Uint8Array, limits: PlannerStateValidationLimitsV1) => PlannerAndExplicitStateV1;
+/**
+ * Prove every persisted provisional edge is bound to this exact room.
+ *
+ * All state and room bytes are owned before the first hash promise begins.
+ */
+export declare const assertPlannerStateRoomBindingV1: (stateValue: unknown, roomContextIdValue: Uint8Array, limits: PlannerStateValidationLimitsV1) => Promise<PlannerAndExplicitStateV1>;

package/lib/blindRendezvous/projections.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Generated projections of the canonical binary schema.
+ *
+ * REQ-024 and AC-047 make this indirection mandatory rather than stylistic:
+ * types, codecs, fixtures, protocol tables, and UI claim keys are projections
+ * of the schema, never a second hand-maintained authority. A validator that
+ * kept its own key list would silently disagree with the wire format the day
+ * one field is added.
+ *
+ * Everything here is derived by `recordFieldNames`/`enumValues` at module load
+ * from `schemas.ts`. There is nothing to keep in sync by hand, which is the
+ * point: `tests/blindRendezvous/projections.test.ts` proves the derivation
+ * covers every validator table and every specified field.
+ */
+export declare const KERNEL_MANIFEST_KEYS: ReadonlySet<string>;
+export declare const KERNEL_MODULE_KEYS: ReadonlySet<string>;
+export declare const KERNEL_ENTRYPOINT_KEYS: ReadonlySet<string>;
+export declare const CLAIM_REGISTRY_KEYS: ReadonlySet<string>;
+export declare const CLAIM_ASSUMPTION_KEYS: ReadonlySet<string>;
+export declare const CLAIM_EVIDENCE_KIND_KEYS: ReadonlySet<string>;
+export declare const CLAIM_DEFINITION_KEYS: ReadonlySet<string>;
+export declare const CLAIM_WORDING_KEY_LIST: readonly string[];
+export declare const CLAIM_WORDING_KEYS: ReadonlySet<string>;
+export declare const CLAIM_EVALUATION_KEYS: ReadonlySet<string>;
+export declare const CLAIM_EVALUATION_INPUT_KEYS: ReadonlySet<string>;
+export declare const CLAIM_ASSUMPTION_FOUNDATIONAL_VERIFICATION_KEYS: ReadonlySet<string>;
+export declare const CLAIM_ASSUMPTION_EVIDENCE_VERIFICATION_KEYS: ReadonlySet<string>;
+export declare const FORMAL_REGISTRY_KEYS: ReadonlySet<string>;
+export declare const FORMAL_OBLIGATION_KEYS: ReadonlySet<string>;
+export declare const FORMAL_RESULT_KEYS: ReadonlySet<string>;
+export declare const ROOM_POLICY_V4_KEYS: ReadonlySet<string>;
+export declare const DELIVERY_PROFILE_V1_KEYS: ReadonlySet<string>;
+export declare const AUTHENTICATED_ROOM_OPERATION_V1_KEYS: ReadonlySet<string>;
+export declare const PAIR_BOOTSTRAP_HEADER_V1_KEYS: ReadonlySet<string>;
+export declare const PAIR_STEP_ENVELOPE_V1_KEYS: ReadonlySet<string>;
+export declare const PAIR_PLAINTEXT_V1_KEYS: ReadonlySet<string>;
+export declare const PAIR_IDENTITY_UNSIGNED_PROJECTION_V1_KEYS: ReadonlySet<string>;
+export declare const STABLE_IDENTITY_BUNDLE_V1_KEYS: ReadonlySet<string>;
+export declare const PAIR_IDENTITY_HELLO_UNSIGNED_V1_KEYS: ReadonlySet<string>;
+export declare const PAIR_IDENTITY_HELLO_V1_KEYS: ReadonlySet<string>;
+export declare const PAIR_IDENTITY_ACCEPT_UNSIGNED_V1_KEYS: ReadonlySet<string>;
+export declare const PAIR_IDENTITY_ACCEPT_V1_KEYS: ReadonlySet<string>;
+export declare const PAIR_OUTER_PREBINDING_V1_KEYS: ReadonlySet<string>;
+export declare const PAIR_OUTER_BINDING_V1_KEYS: ReadonlySet<string>;
+export declare const PAIR_FLIGHT_SLOT_V1_KEYS: ReadonlySet<string>;
+export declare const PAIR_BOOTSTRAP_INFO_V1_KEYS: ReadonlySet<string>;
+export declare const PAIR_TRANSPORT_OFFER_V1_KEYS: ReadonlySet<string>;
+export declare const PAIR_TRANSPORT_ANSWER_V1_KEYS: ReadonlySet<string>;
+export declare const CARRIER_ENVELOPE_V1_KEYS: ReadonlySet<string>;
+export declare const CLAIM_EVALUATION_STATES_ORDER: readonly string[];
+export declare const CLAIM_SCOPE_KINDS_ORDER: readonly string[];
+export declare const CLAIM_ASSUMPTION_KINDS_ORDER: readonly string[];
+export declare const FORMAL_OBLIGATION_KINDS_ORDER: readonly string[];
+export declare const FORMAL_PROOF_RESULTS_ORDER: readonly string[];
+export declare const OPERATION_KINDS_ORDER: readonly string[];
+export declare const OPERATION_LIFETIMES_ORDER: readonly string[];
+export declare const PAIR_STEP_KINDS_ORDER: readonly string[];
+export declare const PAIR_ATTEMPT_MODES_ORDER: readonly string[];
+export declare const PAIR_BOOTSTRAP_RECIPIENT_KINDS_ORDER: readonly string[];
+export declare const PAIR_TRANSPORT_CANDIDATE_KINDS_ORDER: readonly string[];
+export declare const CLAIM_EVALUATION_STATES: ReadonlySet<string>;
+export declare const CLAIM_SCOPE_KINDS: ReadonlySet<string>;
+export declare const CLAIM_ASSUMPTION_KINDS: ReadonlySet<string>;
+export declare const FORMAL_OBLIGATION_KINDS: ReadonlySet<string>;
+export declare const FORMAL_PROOF_RESULTS: ReadonlySet<string>;
+export declare const OPERATION_KINDS: ReadonlySet<string>;
+export declare const OPERATION_LIFETIMES: ReadonlySet<string>;
+export declare const PAIR_STEP_KINDS: ReadonlySet<string>;
+export declare const PAIR_ATTEMPT_MODES: ReadonlySet<string>;
+export declare const PAIR_BOOTSTRAP_RECIPIENT_KINDS: ReadonlySet<string>;
+export declare const PAIR_TRANSPORT_CANDIDATE_KINDS: ReadonlySet<string>;