@seams/wallet 0.8.0 → 0.9.1

package/dist/esm/shared-ts/src/device-linking/parsers.js

@@ -1,13 +1,9 @@
-import { requireArray, requireRecord } from "../utils/validation.js";
-import { exactRecord } from "../utils/exactRecord.js";
-import { wireLiteral, wireNullable, wireObject, wireUnion } from "../utils/wireSchema.js";
-import { delegatedWalletPermissionNamesV1 } from "../authorization/delegatedAuthority.js";
+import { requireRecord } from "../utils/validation.js";
+import "../authorization/delegatedAuthority.js";
 import { base64UrlDecode, base64UrlEncode } from "../utils/base64.js";
-import { parseEd25519PublicKeyB64u } from "../passkey-custody/primitives.js";
-import { authorizationDeviceId, credentialId, digest, enrollmentId, linkedDeviceId, parseDelegatedWalletAuthority, parseNonEmptyToken, parseNonNegativeSafeInteger, parseTargetEmail, parseUnixTime, rpId, sessionId, walletAuthMethodId, walletAuthorityId, walletId, walletKeyId, walletSessionAuthorizationId, walletSessionId } from "./wireFields.js";
-import { requireRouterAbX25519PublicKey } from "../utils/routerAbPublicKeyset.js";
-import { parseWalletAddAuthMethodRegistrationOptions } from "../utils/addAuthMethodRegistration.js";
-import { parseLinkedDeviceOrdinaryMaterialSourceContributionPreparationTupleV1, parseLinkedDeviceOrdinaryMaterialSourceContributionTupleV1 } from "./sourceContribution.js";
+import { exactRecord } from "../utils/exactRecord.js";
+import { parseDelegatedWalletAuthority, parseTargetEmail, parseUnixTime, sessionId } from "./wireFields.js";
+import "./sourceContribution.js";
 import "./committedSignerPackages.js";
 //#region ../shared-ts/src/device-linking/parsers.ts
 const QR_FIELDS = [
@@ -31,16 +27,6 @@ const COMPACT_QR_FIELDS = [
 	"i",
 	"e"
 ];
-function supportedLiteral(...values) {
-	return (raw, label) => {
-		if (!values.includes(raw)) throw new Error(`${label} is unsupported`);
-		return raw;
-	};
-}
-function parseEmailHashHex(raw, label) {
-	if (typeof raw !== "string" || !/^[0-9a-f]{64}$/.test(raw)) throw new Error(`${label} must be 32 canonical lowercase hex bytes`);
-	return raw;
-}
 function parsePublicKey(raw, label) {
 	if (typeof raw !== "string" || raw.length === 0 || !/^[A-Za-z0-9_-]+$/.test(raw)) throw new Error(`${label} must be canonical unpadded base64url`);
 	try {
@@ -51,87 +37,10 @@ function parsePublicKey(raw, label) {
 	}
 	return raw;
 }
-function parseCanonicalBase64UrlBytes(raw, label) {
-	if (typeof raw !== "string" || raw.length === 0 || !/^[A-Za-z0-9_-]+$/.test(raw)) throw new Error(`${label} must be canonical unpadded base64url`);
-	try {
-		const decoded = base64UrlDecode(raw);
-		if (decoded.length === 0 || base64UrlEncode(decoded) !== raw) throw new Error("non-canonical");
-	} catch {
-		throw new Error(`${label} must be canonical unpadded base64url`);
-	}
-	return raw;
-}
-function parseCanonicalFixedBase64UrlBytes(raw, length, label) {
-	const value = parseCanonicalBase64UrlBytes(raw, label);
-	const decoded = base64UrlDecode(value);
-	try {
-		if (decoded.length !== length) throw new Error(`${label} must encode ${length} bytes`);
-		return value;
-	} finally {
-		decoded.fill(0);
-	}
-}
-const P256_FIELD_PRIME = BigInt("0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff");
-const P256_CURVE_A = P256_FIELD_PRIME - 3n;
-const P256_CURVE_B = BigInt("0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b");
-function bigEndianBytesToBigInt(bytes) {
-	let value = 0n;
-	for (const byte of bytes) value = value << 8n | BigInt(byte);
-	return value;
-}
-function isP256Point(decoded) {
-	const x = bigEndianBytesToBigInt(decoded.subarray(1, 33));
-	const y = bigEndianBytesToBigInt(decoded.subarray(33, 65));
-	if (x >= P256_FIELD_PRIME || y >= P256_FIELD_PRIME) return false;
-	return y * y % P256_FIELD_PRIME === (x * x * x % P256_FIELD_PRIME + P256_CURVE_A * x % P256_FIELD_PRIME + P256_CURVE_B) % P256_FIELD_PRIME;
-}
-function parseUncompressedP256PointB64u(raw, label) {
-	const value = parseCanonicalFixedBase64UrlBytes(raw, 65, label);
-	const decoded = base64UrlDecode(value);
-	try {
-		if (decoded[0] !== 4) throw new Error(`${label} must be an uncompressed SEC1 P-256 point`);
-		if (!isP256Point(decoded)) throw new Error(`${label} must be an on-curve P-256 point`);
-		return value;
-	} finally {
-		decoded.fill(0);
-	}
-}
-function parseLinkDevicePublicKeyB64u(raw) {
-	return parsePublicKey(raw, "LinkDevicePublicKeyB64u");
-}
-function parseCredential(raw, label) {
-	return credentialId(parseCanonicalBase64UrlBytes(raw, label), label);
-}
-function parseKeyFamily(raw, label) {
-	if (raw !== "ed25519" && raw !== "ecdsa_secp256k1") throw new Error(`${label} must identify a supported key family`);
-	return raw;
-}
+BigInt("0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff") - 3n;
 function assertExpiryAfterIssued(issuedAtMs, expiresAtMs, label) {
 	if (expiresAtMs <= issuedAtMs) throw new Error(`${label}.expiresAtMs must be after issuedAtMs`);
 }
-function delegatedWalletAuthorityWireValue(value) {
-	return {
-		kind: value.kind,
-		permissions: [...delegatedWalletPermissionNamesV1(value)]
-	};
-}
-function qrPayloadWireValue(payload) {
-	const base = {
-		version: payload.version,
-		purpose: payload.purpose,
-		linkSessionId: payload.linkSessionId,
-		linkPublicKeyB64u: payload.linkPublicKeyB64u,
-		devicePublicKeyB64u: payload.devicePublicKeyB64u,
-		requestedPermission: delegatedWalletAuthorityWireValue(payload.requestedPermission),
-		targetFactor: payload.targetFactor,
-		issuedAtMs: payload.issuedAtMs,
-		expiresAtMs: payload.expiresAtMs
-	};
-	return payload.targetFactor.kind === "email_otp" ? {
-		...base,
-		targetEmail: payload.targetEmail
-	} : base;
-}
 function parseTargetFactor(raw, label) {
 	switch (exactRecord(raw, ["kind"], label).kind) {
 		case "passkey_prf": return { kind: "passkey_prf" };
@@ -139,65 +48,6 @@ function parseTargetFactor(raw, label) {
 		default: throw new Error(`${label}.kind is unsupported`);
 	}
 }
-function passkeyTargetFactorV1() {
-	return wireObject({ kind: wireLiteral("passkey_prf") });
-}
-function emailOtpTargetFactorV1() {
-	return wireObject({ kind: wireLiteral("email_otp") });
-}
-function existingEnrollmentV1() {
-	return wireObject({ kind: wireLiteral("existing_enrollment") });
-}
-function newEnrollmentV1() {
-	return wireObject({ kind: wireLiteral("new_enrollment") });
-}
-function emailOtpEnrollmentSelectionV1() {
-	return wireUnion("kind", [existingEnrollmentV1(), newEnrollmentV1()]);
-}
-function parseEmailOtpEnrollmentSelection(raw, label) {
-	return emailOtpEnrollmentSelectionV1()(raw, label);
-}
-function emailOtpEnrollmentMaterialV1() {
-	return wireObject({
-		enrollmentSealKeyVersion: parseNonEmptyToken,
-		clientUnlockPublicKeyB64u: parseNonEmptyToken,
-		unlockKeyVersion: parseNonEmptyToken,
-		serverSealedFactorCiphertextB64u: parseNonEmptyToken
-	});
-}
-function parseApprovedTargetFactor(raw, label) {
-	const record = requireRecord(raw, label);
-	if (record.kind === "passkey_prf") {
-		exactRecord(record, ["kind"], label);
-		return { kind: "passkey_prf" };
-	}
-	if (record.kind === "email_otp") {
-		const enrollment = parseEmailOtpEnrollmentSelection(record.enrollment, `${label}.enrollment`);
-		const targetEmail = parseTargetEmail(record.targetEmail, `${label}.targetEmail`);
-		if (enrollment.kind === "existing_enrollment") return {
-			kind: "email_otp",
-			targetEmail,
-			enrollment,
-			baseWalletAuthMethodId: walletAuthMethodId(exactRecord(record, [
-				"kind",
-				"targetEmail",
-				"enrollment",
-				"baseWalletAuthMethodId"
-			], label).baseWalletAuthMethodId, `${label}.baseWalletAuthMethodId`)
-		};
-		exactRecord(record, [
-			"kind",
-			"targetEmail",
-			"enrollment"
-		], label);
-		return {
-			kind: "email_otp",
-			targetEmail,
-			enrollment
-		};
-	}
-	throw new Error(`${label}.kind is unsupported`);
-}
 function parseQrPayloadRecord(record) {
 	if (record.version !== "v5") throw new Error("QrLinkedDeviceSessionPayloadV5.version is invalid");
 	if (record.purpose !== "linked_device_lane_creation") throw new Error("QrLinkedDeviceSessionPayloadV5.purpose is invalid");
@@ -229,23 +79,6 @@ function parseQrLinkedDeviceSessionPayloadV5(raw) {
 	const candidate = requireRecord(raw, "QrLinkedDeviceSessionPayloadV5");
 	return parseQrPayloadRecord(exactRecord(candidate, parseTargetFactor(candidate.targetFactor, "QrLinkedDeviceSessionPayloadV5.targetFactor").kind === "email_otp" ? [...QR_FIELDS, "targetEmail"] : QR_FIELDS, "QrLinkedDeviceSessionPayloadV5"));
 }
-function serializeQrLinkedDeviceSessionPayloadV5(payload) {
-	const parsed = parseQrPayloadRecord(qrPayloadWireValue(payload));
-	const compact = {
-		v: 5,
-		s: parsed.linkSessionId,
-		l: parsed.linkPublicKeyB64u,
-		d: parsed.devicePublicKeyB64u,
-		a: delegatedWalletAuthorityWireValue(parsed.requestedPermission),
-		f: parsed.targetFactor.kind === "passkey_prf" ? "p" : "e",
-		i: parsed.issuedAtMs,
-		e: parsed.expiresAtMs
-	};
-	return parsed.targetFactor.kind === "email_otp" ? JSON.stringify({
-		...compact,
-		t: parsed.targetEmail
-	}) : JSON.stringify(compact);
-}
 function parseQrLinkedDeviceSessionTextV5(raw) {
 	let decoded;
 	try {
@@ -276,754 +109,7 @@ function parseQrLinkedDeviceSessionTextV5(raw) {
 		targetFactor: { kind: "passkey_prf" }
 	});
 }
-function linkedDeviceOwnerAuthorizationRequestV1() {
-	return wireObject({
-		payload: parseQrLinkedDeviceSessionPayloadV5,
-		requestedAtMs: parseUnixTime
-	});
-}
-function parseLinkedDeviceOwnerAuthorizationRequestV1(raw) {
-	return linkedDeviceOwnerAuthorizationRequestV1()(raw, "LinkedDeviceOwnerAuthorizationRequestV1");
-}
-function linkSessionStatesV1() {
-	const withDevice = (state) => wireObject({
-		state: wireLiteral(state),
-		deviceId: authorizationDeviceId
-	});
-	return [
-		wireObject({ state: wireLiteral("displaying_qr") }),
-		withDevice("claimed"),
-		withDevice("awaiting_target_factor"),
-		withDevice("awaiting_source_contribution"),
-		withDevice("provisioning"),
-		wireObject({
-			state: wireLiteral("authority_pending_local_install"),
-			deviceId: authorizationDeviceId,
-			authorityId: walletAuthorityId,
-			packageSetDigestB64u: digest
-		}),
-		wireObject({
-			state: wireLiteral("active"),
-			deviceId: authorizationDeviceId,
-			authorityId: walletAuthorityId,
-			activatedAtMs: parseUnixTime
-		}),
-		wireObject({
-			state: wireLiteral("failed_before_commit"),
-			error: parseLinkPrecommitFailureV1
-		}),
-		wireObject({
-			state: wireLiteral("cancelled"),
-			cancelledAtMs: parseUnixTime
-		}),
-		wireObject({
-			state: wireLiteral("expired"),
-			expiredAtMs: parseUnixTime
-		})
-	];
-}
-function parseLinkSessionStateV1(raw) {
-	const state = requireRecord(raw, "LinkSessionStateV1").state;
-	if (typeof state !== "string") throw new Error("LinkSessionStateV1.state is invalid");
-	const schema = linkSessionStatesV1().find((variant) => variant.shape.state.literals.includes(state));
-	if (!schema) throw new Error(`LinkSessionStateV1.state ${state} is unsupported`);
-	return schema(raw, `LinkSessionStateV1.${state}`);
-}
-function parseLinkPrecommitFailureV1(raw) {
-	const record = exactRecord(raw, ["kind", "reason"], "LinkPrecommitFailureV1");
-	if (record.kind !== "invalid_input" && record.kind !== "unauthorized_source" && record.kind !== "revoked_source" && record.kind !== "permission_attenuation_failed" && record.kind !== "target_factor_failed" && record.kind !== "expired_session" && record.kind !== "cancelled_session" && record.kind !== "claim_conflict" && record.kind !== "package_preparation_failed") throw new Error("LinkPrecommitFailureV1.kind is invalid");
-	return {
-		kind: record.kind,
-		reason: parseNonEmptyToken(record.reason, "LinkPrecommitFailureV1.reason")
-	};
-}
-function linkSessionProjectionV1() {
-	return wireObject({
-		kind: wireLiteral("linked_device_session_projection_v1"),
-		linkSessionId: sessionId,
-		qrPayload: parseQrLinkedDeviceSessionPayloadV5,
-		revision: parseNonNegativeSafeInteger,
-		createdAtMs: parseUnixTime,
-		updatedAtMs: parseUnixTime,
-		state: parseLinkSessionStateV1
-	});
-}
-function parseLinkSessionProjectionV1(raw) {
-	return linkSessionProjectionV1()(raw, "LinkSessionProjectionV1");
-}
-function linkSessionTransportEventV1() {
-	return wireObject({
-		kind: wireLiteral("linked_device_session_event_v1"),
-		linkSessionId: sessionId,
-		state: parseLinkSessionStateV1,
-		emittedAtMs: parseUnixTime
-	});
-}
-function parseLinkSessionTransportEventV1(raw) {
-	return linkSessionTransportEventV1()(raw, "LinkSessionTransportEventV1");
-}
-function linkedDeviceApprovalResultV1() {
-	return wireUnion("outcome", [wireObject({
-		outcome: wireLiteral("pending"),
-		state: parsePendingApprovalState
-	}), wireObject({
-		outcome: wireLiteral("replayed"),
-		replay: wireObject({
-			state: () => "pending",
-			session: parsePendingApprovalState
-		})
-	})]);
-}
-function parseLinkedDeviceApprovalResultV1(raw) {
-	return linkedDeviceApprovalResultV1()(raw, "LinkedDeviceApprovalResultV1");
-}
-function parsePendingApprovalState(raw) {
-	const state = parseLinkSessionStateV1(raw);
-	switch (state.state) {
-		case "awaiting_target_factor":
-		case "awaiting_source_contribution":
-		case "provisioning":
-		case "authority_pending_local_install": return state;
-		default: throw new Error("LinkedDeviceApprovalResultV1 state is not pending");
-	}
-}
-function linkedDeviceSessionClaimV1() {
-	return wireObject({
-		kind: wireLiteral("linked_device_session_claim_v1"),
-		linkSessionId: sessionId,
-		walletId,
-		enrollmentId,
-		deviceId: linkedDeviceId,
-		devicePublicKeyB64u: parsePublicKey,
-		targetFactor: parseTargetFactor,
-		sessionRevision: parseUnixTime,
-		claimedAtMs: parseUnixTime,
-		claimExpiresAtMs: parseUnixTime
-	}, (claim, label) => assertExpiryAfterIssued(claim.claimedAtMs, claim.claimExpiresAtMs, label));
-}
-function parseLinkedDeviceSessionClaimV1(raw) {
-	return linkedDeviceSessionClaimV1()(raw, "LinkedDeviceSessionClaimV1");
-}
-function walletSessionOwnerAuthorizationV1() {
-	return wireObject({
-		kind: wireLiteral("wallet_session"),
-		walletSessionId,
-		authorizationId: walletSessionAuthorizationId
-	});
-}
-function parseLinkedDeviceOwnerAuthorizationSourceV1(raw, label = "ownerAuthorization") {
-	if (requireRecord(raw, label).kind !== "wallet_session") throw new Error(`${label}.kind is unsupported`);
-	return walletSessionOwnerAuthorizationV1()(raw, label);
-}
-function linkedDeviceApprovalFields() {
-	return {
-		kind: wireLiteral("linked_device_approval_v1"),
-		linkSessionId: sessionId,
-		walletId,
-		enrollmentId,
-		deviceId: linkedDeviceId,
-		linkPublicKeyB64u: parsePublicKey,
-		devicePublicKeyB64u: parsePublicKey,
-		permission: parseDelegatedWalletAuthority,
-		targetFactor: parseApprovedTargetFactor,
-		ownerAuthorization: parseLinkedDeviceOwnerAuthorizationSourceV1,
-		approvedAtMs: parseUnixTime,
-		expiresAtMs: parseUnixTime
-	};
-}
-function approvedBeforeExpiry(approval, label) {
-	assertExpiryAfterIssued(approval.approvedAtMs, approval.expiresAtMs, label);
-}
-function linkedDeviceApprovalV1() {
-	return wireObject(linkedDeviceApprovalFields(), approvedBeforeExpiry);
-}
-function linkedDeviceSourceContributionApprovalV1() {
-	return wireObject({
-		...linkedDeviceApprovalFields(),
-		sourceContribution: parseLinkedDeviceOrdinaryMaterialSourceContributionTupleV1
-	}, approvedBeforeExpiry);
-}
-function parseLinkedDeviceApprovalV1(raw) {
-	const record = requireRecord(raw, "LinkedDeviceApprovalV1");
-	return (record.sourceContribution === void 0 ? linkedDeviceApprovalV1() : linkedDeviceSourceContributionApprovalV1())(record, "LinkedDeviceApprovalV1");
-}
-function linkedDeviceApprovalDeliveryV1() {
-	return wireObject({
-		kind: wireLiteral("linked_device_approval_delivery_v1"),
-		approval: parseLinkedDeviceApprovalV1
-	});
-}
-function parseLinkedDeviceApprovalDeliveryV1(raw) {
-	return linkedDeviceApprovalDeliveryV1()(raw, "LinkedDeviceApprovalDeliveryV1");
-}
-function linkedDeviceTargetPreparationFields() {
-	return {
-		kind: wireLiteral("linked_device_target_preparation_v1"),
-		linkSessionId: sessionId,
-		walletId,
-		enrollmentId,
-		deviceId: linkedDeviceId,
-		deliveryRecipientPublicKey65B64u: parseUncompressedP256PointB64u,
-		walletAuthMethodId,
-		ed25519ExportRoot: wireNullable(ed25519ExportRootPreparationV1()),
-		ordinarySignerMaterialRecipientRequirements: parseRecipientRequirements,
-		issuedAtMs: parseUnixTime,
-		expiresAtMs: parseUnixTime
-	};
-}
-function preparationExpiresAfterIssue(preparation, label) {
-	if (preparation.expiresAtMs <= preparation.issuedAtMs) throw new Error(`${label}.expiresAtMs must follow issuedAtMs`);
-}
-function passkeyTargetPreparationV1() {
-	return wireObject({
-		...linkedDeviceTargetPreparationFields(),
-		targetFactor: passkeyTargetFactorV1(),
-		passkeyCreationOptions: parseLinkedDevicePasskeyCreationOptionsV1,
-		passkeyConfigurationDigestB64u: digest
-	}, (preparation, label) => {
-		preparationExpiresAfterIssue(preparation, label);
-		if (preparation.passkeyCreationOptions.walletAuthMethodId !== preparation.walletAuthMethodId) throw new Error(`${label}.passkeyCreationOptions.walletAuthMethodId must match the preparation`);
-	});
-}
-function emailOtpTargetPreparationV1() {
-	return wireObject({
-		...linkedDeviceTargetPreparationFields(),
-		targetFactor: emailOtpTargetFactorV1(),
-		targetEmail: parseTargetEmail,
-		enrollment: existingEnrollmentV1(),
-		baseWalletAuthMethodId: walletAuthMethodId
-	}, preparationExpiresAfterIssue);
-}
-function newEmailOtpTargetPreparationV1() {
-	return wireObject({
-		...linkedDeviceTargetPreparationFields(),
-		targetFactor: emailOtpTargetFactorV1(),
-		targetEmail: parseTargetEmail,
-		enrollment: newEnrollmentV1()
-	}, preparationExpiresAfterIssue);
-}
-function parseLinkedDeviceTargetPreparationV1(raw) {
-	const label = "LinkedDeviceTargetPreparationV1";
-	const record = requireRecord(raw, label);
-	if (parseTargetFactor(record.targetFactor, `${label}.targetFactor`).kind === "passkey_prf") return passkeyTargetPreparationV1()(record, label);
-	return (parseEmailOtpEnrollmentSelection(record.enrollment, `${label}.enrollment`).kind === "new_enrollment" ? newEmailOtpTargetPreparationV1() : emailOtpTargetPreparationV1())(record, label);
-}
-function linkedDeviceTargetPreparationRequestV1() {
-	return wireObject({
-		kind: wireLiteral("linked_device_target_preparation_request_v1"),
-		linkSessionId: sessionId,
-		deliveryRecipientPublicKey65B64u: parseUncompressedP256PointB64u
-	});
-}
-function parseLinkedDeviceTargetPreparationRequestV1(raw) {
-	return linkedDeviceTargetPreparationRequestV1()(raw, "LinkedDeviceTargetPreparationRequestV1");
-}
-function emailOtpBaseFactorChoiceV1() {
-	return wireObject({
-		baseWalletAuthMethodId: walletAuthMethodId,
-		maskedEmailHint: (raw, label) => {
-			if (typeof raw !== "string" || raw.length === 0) throw new Error(`${label} is invalid`);
-			return raw;
-		}
-	});
-}
-function emailOtpBaseFactorResolutionsV1() {
-	const choice = emailOtpBaseFactorChoiceV1();
-	const parseChoice = (raw) => choice(raw, "LinkedDeviceEmailOtpBaseFactorChoiceV1");
-	return {
-		selected: wireObject({
-			kind: wireLiteral("selected"),
-			choice: parseChoice
-		}),
-		selection_required: wireObject({
-			kind: wireLiteral("selection_required"),
-			choices: (raw, label) => {
-				if (!Array.isArray(raw) || raw.length === 0) throw new Error(`${label} must not be empty`);
-				const choices = raw.map(parseChoice);
-				return [choices[0], ...choices.slice(1)];
-			}
-		}),
-		unavailable: wireObject({
-			kind: wireLiteral("unavailable"),
-			reason: supportedLiteral("no_active_email_otp_base_factor")
-		})
-	};
-}
-function parseLinkedDeviceEmailOtpBaseFactorResolutionV1(raw) {
-	const label = "LinkedDeviceEmailOtpBaseFactorResolutionV1";
-	const record = requireRecord(raw, label);
-	const resolutions = emailOtpBaseFactorResolutionsV1();
-	switch (record.kind) {
-		case "selected":
-		case "selection_required":
-		case "unavailable": return resolutions[record.kind](record, label);
-		default: throw new Error(`${label}.kind is unsupported`);
-	}
-}
-function emailOtpBaseFactorResolutionResultV1() {
-	return wireObject({
-		revision: parseUnixTime,
-		resolution: parseLinkedDeviceEmailOtpBaseFactorResolutionV1
-	});
-}
-function parseLinkedDeviceEmailOtpBaseFactorResolutionResultV1(raw) {
-	return emailOtpBaseFactorResolutionResultV1()(raw, "LinkedDeviceEmailOtpBaseFactorResolutionResultV1");
-}
-function parseLinkedDevicePasskeyCreationOptionsV1(raw, label) {
-	const record = exactRecord(raw, [
-		"kind",
-		"walletAuthMethodId",
-		"challengeId",
-		"challengeB64u",
-		"rpId",
-		"user",
-		"pubKeyCredParams",
-		"authenticatorSelection",
-		"timeoutMs",
-		"attestation",
-		"extensions",
-		"excludeCredentials"
-	], label);
-	const methodId = walletAuthMethodId(record.walletAuthMethodId, `${label}.walletAuthMethodId`);
-	exactRecord(record.user, [
-		"idB64u",
-		"name",
-		"displayName"
-	], `${label}.user`);
-	exactRecord(record.authenticatorSelection, ["residentKey", "userVerification"], `${label}.authenticatorSelection`);
-	exactRecord(exactRecord(exactRecord(record.extensions, ["prf"], `${label}.extensions`).prf, ["eval"], `${label}.extensions.prf`).eval, ["firstB64u", "secondB64u"], `${label}.extensions.prf.eval`);
-	if (!Array.isArray(record.pubKeyCredParams)) throw new Error(`${label}.pubKeyCredParams must be an array`);
-	record.pubKeyCredParams.forEach((entry, index) => {
-		exactRecord(entry, ["type", "alg"], `${label}.pubKeyCredParams[${index}]`);
-	});
-	if (!Array.isArray(record.excludeCredentials)) throw new Error(`${label}.excludeCredentials must be an array`);
-	record.excludeCredentials.forEach((entry, index) => {
-		exactRecord(entry, ["type", "id"], `${label}.excludeCredentials[${index}]`);
-	});
-	const options = parseWalletAddAuthMethodRegistrationOptions(record);
-	return {
-		kind: options.kind,
-		walletAuthMethodId: methodId,
-		challengeId: options.challengeId,
-		challengeB64u: options.challengeB64u,
-		rpId: options.rpId,
-		user: options.user,
-		pubKeyCredParams: options.pubKeyCredParams,
-		authenticatorSelection: options.authenticatorSelection,
-		timeoutMs: options.timeoutMs,
-		attestation: options.attestation,
-		extensions: options.extensions,
-		excludeCredentials: options.excludeCredentials
-	};
-}
-function ed25519ExportRootPreparationV1() {
-	return wireObject({
-		kind: wireLiteral("linked_device_ed25519_export_root_preparation_v1"),
-		walletKeyId,
-		applicationBindingDigestB64u: digest,
-		registeredPublicKeyB64u: parseEd25519PublicKeyB64u,
-		revocationEpoch: parseNonNegativeSafeInteger
-	});
-}
-function parseKeyFamilyEntries(raw, item, label) {
-	if (!Array.isArray(raw) || raw.length === 0 || raw.length > 2) throw new Error(`${label} must contain one or two entries`);
-	const entries = raw.map((entry, index) => item(entry, `${label}[${index}]`));
-	if (new Set(entries.map((entry) => entry.keyFamily)).size !== entries.length) throw new Error(`${label} repeats a key family`);
-	if (new Set(entries.map((entry) => String(entry.walletKeyId))).size !== entries.length) throw new Error(`${label} repeats a wallet key`);
-	if (entries.length === 2 && (entries[0]?.keyFamily !== "ed25519" || entries[1]?.keyFamily !== "ecdsa_secp256k1")) throw new Error(`${label} must be ordered Ed25519 then ECDSA`);
-	return entries;
-}
-function recipientRequirementV1() {
-	return wireObject({
-		kind: wireLiteral("ordinary_signer_material_recipient_requirement_v1"),
-		keyFamily: parseKeyFamily,
-		walletKeyId
-	});
-}
-function parseRecipientRequirements(raw) {
-	const requirements = parseKeyFamilyEntries(raw, recipientRequirementV1(), "LinkedDeviceTargetPreparationV1.ordinarySignerMaterialRecipientRequirements");
-	const first = requirements[0];
-	if (!first) throw new Error("ordinary signer material recipient requirements are empty");
-	return [first, ...requirements.slice(1)];
-}
-const webAuthnTransport = /* @__PURE__ */ wireLiteral("ble", "cable", "hybrid", "internal", "nfc", "smart-card", "usb");
-function parseWebAuthnTransports(raw, label) {
-	const transports = requireArray(raw, label).map((entry, index) => webAuthnTransport(entry, `${label}[${index}]`));
-	if (new Set(transports).size !== transports.length) throw new Error(`${label} contains duplicates`);
-	return transports;
-}
-function linkedDeviceWebAuthnRegistrationV1() {
-	return wireObject({
-		kind: wireLiteral("linked_device_webauthn_registration_v1"),
-		credentialIdB64u: parseCredential,
-		authenticatorAttachment: wireNullable(wireLiteral("platform", "cross-platform")),
-		clientDataJsonB64u: parseCanonicalBase64UrlBytes,
-		attestationObjectB64u: parseCanonicalBase64UrlBytes,
-		transports: parseWebAuthnTransports
-	});
-}
-function recipientRequestV1() {
-	const keyFamily = (family) => (raw, label) => {
-		if (raw !== family) throw new Error(`${label} does not match its kind`);
-		return family;
-	};
-	return wireUnion("kind", [wireObject({
-		kind: wireLiteral("ordinary_ed25519_signer_material_recipient_request_v1"),
-		keyFamily: keyFamily("ed25519"),
-		walletKeyId,
-		recipientPublicKeyB64u: (raw, label) => parseCanonicalFixedBase64UrlBytes(raw, 32, label)
-	}), wireObject({
-		kind: wireLiteral("ordinary_ecdsa_signer_material_recipient_request_v1"),
-		keyFamily: keyFamily("ecdsa_secp256k1"),
-		walletKeyId,
-		clientEphemeralPublicKey: requireRouterAbX25519PublicKey
-	})]);
-}
-function parseRecipientRequests(raw) {
-	const requests = parseKeyFamilyEntries(raw, recipientRequestV1(), "LinkedDeviceTargetCredentialRegistrationV1.ordinarySignerMaterialRecipientRequests");
-	const first = requests[0];
-	if (!first) throw new Error("ordinary signer material recipient requests are empty");
-	return [first, ...requests.slice(1)];
-}
-function targetCredentialRegistrationIdentity() {
-	return {
-		kind: wireLiteral("linked_device_target_credential_registration_v1"),
-		linkSessionId: sessionId,
-		walletId,
-		enrollmentId,
-		deviceId: linkedDeviceId,
-		walletAuthMethodId
-	};
-}
-function passkeyTargetCredentialRegistrationV1() {
-	return wireObject({
-		...targetCredentialRegistrationIdentity(),
-		targetFactor: passkeyTargetFactorV1(),
-		targetPreparationDigestB64u: digest,
-		ordinarySignerMaterialRecipientRequests: parseRecipientRequests,
-		webauthnRegistration: linkedDeviceWebAuthnRegistrationV1(),
-		registeredAtMs: parseUnixTime
-	});
-}
-function emailOtpTargetCredentialRegistrationV1() {
-	return wireObject({
-		...targetCredentialRegistrationIdentity(),
-		targetFactor: emailOtpTargetFactorV1(),
-		targetEmail: parseTargetEmail,
-		targetPreparationDigestB64u: digest,
-		ordinarySignerMaterialRecipientRequests: parseRecipientRequests,
-		emailOtpVerificationGrant: parseLinkedDeviceEmailOtpVerificationGrantV1,
-		registeredAtMs: parseUnixTime
-	});
-}
-function newEmailOtpTargetCredentialRegistrationV1() {
-	return wireObject({
-		...targetCredentialRegistrationIdentity(),
-		targetFactor: emailOtpTargetFactorV1(),
-		targetEmail: parseTargetEmail,
-		targetPreparationDigestB64u: digest,
-		ordinarySignerMaterialRecipientRequests: parseRecipientRequests,
-		emailOtpVerificationGrant: parseLinkedDeviceEmailOtpVerificationGrantV1,
-		emailOtpEnrollment: emailOtpEnrollmentMaterialV1(),
-		registeredAtMs: parseUnixTime
-	});
-}
-function parseLinkedDeviceTargetCredentialRegistrationV1(raw) {
-	const label = "LinkedDeviceTargetCredentialRegistrationV1";
-	const record = requireRecord(raw, label);
-	if (parseTargetFactor(record.targetFactor, `${label}.targetFactor`).kind === "passkey_prf") return passkeyTargetCredentialRegistrationV1()(record, label);
-	return (parseLinkedDeviceEmailOtpVerificationGrantV1(record.emailOtpVerificationGrant).enrollment.kind === "new_enrollment" ? newEmailOtpTargetCredentialRegistrationV1() : emailOtpTargetCredentialRegistrationV1())(record, label);
-}
-function targetCredentialRegistrationResultV1() {
-	return wireObject({
-		kind: wireLiteral("linked_device_target_credential_registration_result_v1"),
-		outcome: wireLiteral("applied", "replayed"),
-		linkSessionId: sessionId,
-		walletId,
-		enrollmentId,
-		deviceId: linkedDeviceId,
-		walletAuthMethodId,
-		targetPreparationDigestB64u: digest,
-		targetFactor: parseVerifiedTargetFactorV1,
-		ordinarySignerMaterialPreparations: parseLinkedDeviceOrdinaryMaterialSourceContributionPreparationTupleV1,
-		ordinarySignerMaterialRecipientRequests: parseRecipientRequests,
-		keyManifestDigestB64u: digest
-	}, (result, label) => {
-		const { authMethod } = result.targetFactor;
-		if (authMethod.walletAuthMethodId !== result.walletAuthMethodId || authMethod.walletId !== result.walletId) throw new Error(`${label} target identity differs`);
-	});
-}
-function parseLinkedDeviceTargetCredentialRegistrationResultV1(raw) {
-	return targetCredentialRegistrationResultV1()(raw, "LinkedDeviceTargetCredentialRegistrationResultV1");
-}
-function verifiedAfterCreation(target, label) {
-	if (target.verifiedAtMs < target.authMethod.createdAtMs) throw new Error(`${label}.verifiedAtMs precedes authMethod.createdAtMs`);
-}
-function verifiedPasskeyTargetV1() {
-	return wireObject({
-		kind: wireLiteral("verified_passkey_target_v1"),
-		authMethod: parsePasskeyWalletAuthMethodDraftV1,
-		verificationDigestB64u: digest,
-		verifiedAtMs: parseUnixTime
-	}, verifiedAfterCreation);
-}
-function verifiedEmailOtpTargetV1() {
-	return wireObject({
-		kind: wireLiteral("verified_email_otp_target_v1"),
-		authMethod: parseEmailOtpWalletAuthMethodDraftV1,
-		targetEmail: parseTargetEmail,
-		enrollment: existingEnrollmentV1(),
-		baseWalletAuthMethodId: walletAuthMethodId,
-		providerUserId: parseNonEmptyToken,
-		verificationDigestB64u: digest,
-		verifiedAtMs: parseUnixTime
-	}, verifiedAfterCreation);
-}
-function verifiedNewEmailOtpTargetV1() {
-	return wireObject({
-		kind: wireLiteral("verified_email_otp_target_v1"),
-		authMethod: parseEmailOtpWalletAuthMethodDraftV1,
-		targetEmail: parseTargetEmail,
-		enrollment: newEnrollmentV1(),
-		providerUserId: parseNonEmptyToken,
-		verificationDigestB64u: digest,
-		verifiedAtMs: parseUnixTime
-	}, verifiedAfterCreation);
-}
-function parseVerifiedTargetFactorV1(raw, label) {
-	const record = requireRecord(raw, label);
-	if (record.kind === "verified_passkey_target_v1") return verifiedPasskeyTargetV1()(record, label);
-	if (record.kind !== "verified_email_otp_target_v1") throw new Error(`${label}.kind is invalid`);
-	return (parseEmailOtpEnrollmentSelection(record.enrollment, `${label}.enrollment`).kind === "existing_enrollment" ? verifiedEmailOtpTargetV1() : verifiedNewEmailOtpTargetV1())(record, label);
-}
-function passkeyWalletAuthMethodDraftV1() {
-	return wireObject({
-		walletAuthMethodId,
-		walletId,
-		createdAtMs: parseUnixTime,
-		kind: wireLiteral("passkey"),
-		rpId,
-		credentialIdB64u: credentialId,
-		credentialPublicKeyB64u: parseCanonicalBase64UrlBytes,
-		counter: parseNonNegativeSafeInteger
-	});
-}
-function parsePasskeyWalletAuthMethodDraftV1(raw, label) {
-	return passkeyWalletAuthMethodDraftV1()(raw, label);
-}
-function emailOtpWalletAuthMethodDraftV1() {
-	return wireObject({
-		walletAuthMethodId,
-		walletId,
-		createdAtMs: parseUnixTime,
-		kind: wireLiteral("email_otp"),
-		emailHashHex: parseEmailHashHex,
-		registrationAuthorityId: parseNonEmptyToken
-	});
-}
-function parseEmailOtpWalletAuthMethodDraftV1(raw, label) {
-	return emailOtpWalletAuthMethodDraftV1()(raw, label);
-}
-function emailOtpVerificationGrantFields(enrollment) {
-	return {
-		kind: wireLiteral("linked_device_email_otp_verification_grant_v1"),
-		grantId: parseNonEmptyToken,
-		grantToken: parseNonEmptyToken,
-		challengeId: parseNonEmptyToken,
-		linkSessionId: sessionId,
-		walletId,
-		enrollmentId,
-		deviceId: linkedDeviceId,
-		targetPreparationDigestB64u: digest,
-		targetEmail: parseTargetEmail,
-		enrollment,
-		emailHashHex: parseEmailHashHex,
-		registrationAuthorityId: parseNonEmptyToken,
-		providerUserId: parseNonEmptyToken,
-		authorityDigestB64u: digest,
-		issuedAtMs: parseUnixTime,
-		expiresAtMs: parseUnixTime
-	};
-}
-function grantIssuedBeforeExpiry(grant, label) {
-	assertExpiryAfterIssued(grant.issuedAtMs, grant.expiresAtMs, label);
-}
-function emailOtpVerificationGrantV1() {
-	return wireObject({
-		...emailOtpVerificationGrantFields(existingEnrollmentV1()),
-		baseWalletAuthMethodId: walletAuthMethodId
-	}, grantIssuedBeforeExpiry);
-}
-function newEnrollmentEmailOtpVerificationGrantV1() {
-	return wireObject(emailOtpVerificationGrantFields(newEnrollmentV1()), grantIssuedBeforeExpiry);
-}
-function parseLinkedDeviceEmailOtpVerificationGrantV1(raw) {
-	const label = "LinkedDeviceEmailOtpVerificationGrantV1";
-	const record = requireRecord(raw, label);
-	return (parseEmailOtpEnrollmentSelection(record.enrollment, `${label}.enrollment`).kind === "new_enrollment" ? newEnrollmentEmailOtpVerificationGrantV1() : emailOtpVerificationGrantV1())(record, label);
-}
-function emailOtpFactorReleaseEnvelopeV1() {
-	return wireObject({
-		kind: wireLiteral("email_otp_factor_release_v1"),
-		challengeId: parseNonEmptyToken,
-		enrollmentId: parseNonEmptyToken,
-		enrollmentSealKeyVersion: parseNonEmptyToken,
-		serverEphemeralPublicKey65B64u: parseUncompressedP256PointB64u,
-		nonce12B64u: (raw, label) => parseCanonicalFixedBase64UrlBytes(raw, 12, label),
-		ciphertextB64u: parseCanonicalBase64UrlBytes
-	});
-}
-function parseLinkedDeviceEmailOtpFactorReleaseEnvelopeV1(raw) {
-	return emailOtpFactorReleaseEnvelopeV1()(raw, "LinkedDeviceEmailOtpFactorReleaseEnvelopeV1");
-}
-function emailOtpChallengeStartRequestV1() {
-	return wireObject({
-		kind: wireLiteral("linked_device_email_otp_challenge_start_request_v1"),
-		linkSessionId: sessionId,
-		workerEphemeralPublicKey65B64u: parseUncompressedP256PointB64u
-	});
-}
-function parseLinkedDeviceEmailOtpChallengeStartRequestV1(raw) {
-	return emailOtpChallengeStartRequestV1()(raw, "LinkedDeviceEmailOtpChallengeStartRequestV1");
-}
-function emailOtpChallengeResendRequestV1() {
-	return wireObject({
-		kind: wireLiteral("linked_device_email_otp_challenge_resend_request_v1"),
-		linkSessionId: sessionId,
-		challengeId: parseNonEmptyToken
-	});
-}
-function parseLinkedDeviceEmailOtpChallengeResendRequestV1(raw) {
-	return emailOtpChallengeResendRequestV1()(raw, "LinkedDeviceEmailOtpChallengeResendRequestV1");
-}
-function emailOtpChallengeVerifyRequestV1() {
-	return wireObject({
-		kind: wireLiteral("linked_device_email_otp_challenge_verify_request_v1"),
-		linkSessionId: sessionId,
-		challengeId: parseNonEmptyToken,
-		otpCode: (raw, label) => {
-			if (typeof raw !== "string" || !/^[0-9]{6,10}$/.test(raw)) throw new Error(`${label} is invalid`);
-			return raw;
-		}
-	});
-}
-function parseLinkedDeviceEmailOtpChallengeVerifyRequestV1(raw) {
-	return emailOtpChallengeVerifyRequestV1()(raw, "LinkedDeviceEmailOtpChallengeVerifyRequestV1");
-}
-function emailOtpChallengeResultV1() {
-	return wireObject({
-		kind: wireLiteral("linked_device_email_otp_challenge_result_v1"),
-		challengeId: parseNonEmptyToken,
-		maskedEmailHint: parseNonEmptyToken,
-		expiresAtMs: parseUnixTime,
-		resendAvailableAtMs: parseUnixTime
-	});
-}
-function parseLinkedDeviceEmailOtpChallengeResultV1(raw) {
-	return emailOtpChallengeResultV1()(raw, "LinkedDeviceEmailOtpChallengeResultV1");
-}
-function parseLinkedDeviceEmailOtpVerificationResultV1(raw) {
-	const record = exactRecord(raw, [
-		"kind",
-		"verificationGrant",
-		"factorRelease"
-	], "LinkedDeviceEmailOtpVerificationResultV1");
-	if (record.kind !== "linked_device_email_otp_verification_result_v1") throw new Error("LinkedDeviceEmailOtpVerificationResultV1.kind is invalid");
-	const verificationGrant = parseLinkedDeviceEmailOtpVerificationGrantV1(record.verificationGrant);
-	if (isNewEnrollmentEmailOtpVerificationGrantV1(verificationGrant)) {
-		if (record.factorRelease !== null) throw new Error("new linked-device Email OTP enrollment cannot carry a factor release");
-		return {
-			kind: "linked_device_email_otp_verification_result_v1",
-			verificationGrant,
-			factorRelease: null
-		};
-	}
-	const factorRelease = parseLinkedDeviceEmailOtpFactorReleaseEnvelopeV1(record.factorRelease);
-	if (factorRelease.challengeId !== verificationGrant.challengeId) throw new Error("LinkedDeviceEmailOtpVerificationResultV1 challenge binding changed");
-	return {
-		kind: "linked_device_email_otp_verification_result_v1",
-		verificationGrant,
-		factorRelease
-	};
-}
-function isNewEnrollmentEmailOtpVerificationGrantV1(grant) {
-	return grant.enrollment.kind === "new_enrollment";
-}
-function buildQrLinkedDeviceSessionPayloadV5(args) {
-	const issuedAtMs = parseUnixTime(args.issuedAtMs, "QrLinkedDeviceSessionPayloadV5.issuedAtMs");
-	const expiresAtMs = parseUnixTime(args.expiresAtMs, "QrLinkedDeviceSessionPayloadV5.expiresAtMs");
-	assertExpiryAfterIssued(issuedAtMs, expiresAtMs, "QrLinkedDeviceSessionPayloadV5");
-	const targetFactor = parseTargetFactor(args.targetFactor, "QrLinkedDeviceSessionPayloadV5.targetFactor");
-	if (targetFactor.kind === "passkey_prf") return {
-		version: "v5",
-		purpose: "linked_device_lane_creation",
-		linkSessionId: args.linkSessionId,
-		linkPublicKeyB64u: args.linkPublicKeyB64u,
-		devicePublicKeyB64u: args.devicePublicKeyB64u,
-		requestedPermission: parseDelegatedWalletAuthority(delegatedWalletAuthorityWireValue(args.requestedPermission), "QrLinkedDeviceSessionPayloadV5.requestedPermission"),
-		targetFactor,
-		issuedAtMs,
-		expiresAtMs
-	};
-	if (args.targetEmail === void 0) throw new Error("QrLinkedDeviceSessionPayloadV5.targetEmail is required for Email OTP");
-	return {
-		version: "v5",
-		purpose: "linked_device_lane_creation",
-		linkSessionId: args.linkSessionId,
-		linkPublicKeyB64u: args.linkPublicKeyB64u,
-		devicePublicKeyB64u: args.devicePublicKeyB64u,
-		requestedPermission: parseDelegatedWalletAuthority(delegatedWalletAuthorityWireValue(args.requestedPermission), "QrLinkedDeviceSessionPayloadV5.requestedPermission"),
-		targetFactor,
-		targetEmail: parseTargetEmail(args.targetEmail, "QrLinkedDeviceSessionPayloadV5.targetEmail"),
-		issuedAtMs,
-		expiresAtMs
-	};
-}
-function buildLinkedDeviceSessionClaimRequestV1(payload) {
-	return {
-		kind: "linked_device_session_claim_request_v1",
-		payload
-	};
-}
-function validateEnrollmentTimes(approvedAtMs, expiresAtMs, label) {
-	const approved = parseUnixTime(approvedAtMs, `${label}.approvedAtMs`);
-	const expires = parseUnixTime(expiresAtMs, `${label}.expiresAtMs`);
-	assertExpiryAfterIssued(approved, expires, label);
-	return {
-		approvedAtMs: approved,
-		expiresAtMs: expires
-	};
-}
-function buildLinkedDeviceApprovalV1(args) {
-	const times = validateEnrollmentTimes(args.approvedAtMs, args.expiresAtMs, "LinkedDeviceApprovalV1");
-	return parseLinkedDeviceApprovalV1({
-		kind: "linked_device_approval_v1",
-		...args,
-		...times
-	});
-}
-function buildLinkedDeviceTargetCredentialRegistrationV1(args) {
-	return parseLinkedDeviceTargetCredentialRegistrationV1({
-		kind: "linked_device_target_credential_registration_v1",
-		...args
-	});
-}
-function buildLinkedDeviceSessionCancelUnclaimedRequestV1(args) {
-	return {
-		kind: "linked_device_session_cancel_unclaimed_request_v1",
-		linkSessionId: args.linkSessionId,
-		reason: "user_cancelled",
-		requestedAtMs: parseUnixTime(args.requestedAtMs, "LinkedDeviceSessionCancelUnclaimedRequestV1.requestedAtMs")
-	};
-}
-function buildLinkedDeviceSessionCancelClaimedRequestV1(args) {
-	return {
-		kind: "linked_device_session_cancel_claimed_request_v1",
-		...args,
-		requestedAtMs: parseUnixTime(args.requestedAtMs, "LinkedDeviceSessionCancelClaimedRequestV1.requestedAtMs")
-	};
-}
 //#endregion
-export { buildLinkedDeviceApprovalV1, buildLinkedDeviceSessionCancelClaimedRequestV1, buildLinkedDeviceSessionCancelUnclaimedRequestV1, buildLinkedDeviceSessionClaimRequestV1, buildLinkedDeviceTargetCredentialRegistrationV1, buildQrLinkedDeviceSessionPayloadV5, parseLinkDevicePublicKeyB64u, parseLinkSessionProjectionV1, parseLinkSessionStateV1, parseLinkSessionTransportEventV1, parseLinkedDeviceApprovalDeliveryV1, parseLinkedDeviceApprovalResultV1, parseLinkedDeviceApprovalV1, parseLinkedDeviceEmailOtpBaseFactorResolutionResultV1, parseLinkedDeviceEmailOtpChallengeResendRequestV1, parseLinkedDeviceEmailOtpChallengeResultV1, parseLinkedDeviceEmailOtpChallengeStartRequestV1, parseLinkedDeviceEmailOtpChallengeVerifyRequestV1, parseLinkedDeviceEmailOtpFactorReleaseEnvelopeV1, parseLinkedDeviceEmailOtpVerificationGrantV1, parseLinkedDeviceEmailOtpVerificationResultV1, parseLinkedDeviceOwnerAuthorizationRequestV1, parseLinkedDeviceOwnerAuthorizationSourceV1, parseLinkedDeviceSessionClaimV1, parseLinkedDeviceTargetCredentialRegistrationResultV1, parseLinkedDeviceTargetCredentialRegistrationV1, parseLinkedDeviceTargetPreparationRequestV1, parseLinkedDeviceTargetPreparationV1, parseQrLinkedDeviceSessionPayloadV5, parseQrLinkedDeviceSessionTextV5, serializeQrLinkedDeviceSessionPayloadV5 };
+export { parseQrLinkedDeviceSessionPayloadV5, parseQrLinkedDeviceSessionTextV5 };
 
 //# sourceMappingURL=parsers.js.map