@openvtc/trust-tasks 0.8.2 → 0.9.0

package/dist/vault/release/0.2/payload.d.ts

@@ -162,16 +162,832 @@ export type Payload = VaultReleasePayload;
 export declare const RESPONSE_TYPE_URI: "https://trusttasks.org/spec/vault/release/0.2#response";
 /** Stable alias for this specification's success-response payload shape. */
 export type Response = VaultReleaseResponsePayload;
+/**
+ * This specification's payload schema, as a value.
+ *
+ * SPEC.md §7.2 item 2 is performed against this. It is shipped as data
+ * rather than only as a `.json` file because TypeScript types are erased
+ * at runtime: without a schema a consumer has nothing to validate, and
+ * every REQUIRED payload member is optional in practice. Cross-file
+ * `$ref`s are already inlined, so it needs no resolver.
+ */
+export declare const PAYLOAD_SCHEMA: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://trusttasks.org/spec/vault/release/0.2";
+    readonly title: "Vault Release — payload";
+    readonly description: "Consumer requests that the maintainer release the cleartext secret material of a vault entry. The response carries the secret in a pluggable cipher envelope (see vault/_shared/0.1/sealed-envelope); the cleartext shape is `vault/_shared/0.1/vault-secret#/$defs/VaultSecret`. This is the fallback when proxy-login is not viable (`vault/proxy-login:not_proxyable`) or when the consumer needs the raw secret for a flow the maintainer cannot perform (e.g. autofill into a desktop app, copy-to-clipboard for offline use).";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["entryId"];
+    readonly properties: {
+        readonly entryId: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly target: {
+            readonly $ref: "#/$defs/SiteTarget";
+            readonly description: "Optional — for entries with multiple targets, indicates which one the consumer is acting against. The maintainer's policy may decide release based on the target (e.g. release for web origin allowed, release for iOS app denied).";
+        };
+        readonly consumerContext: {
+            readonly $ref: "#/$defs/ConsumerContext";
+            readonly description: "Caller's situational context — fed to the policy engine.";
+        };
+        readonly stepUpProof: {
+            readonly $ref: "#/$defs/StepUpProof";
+            readonly description: "Step-up proof on retry after step_up_required.";
+        };
+        readonly ttlSecondsHint: {
+            readonly type: "integer";
+            readonly minimum: 1;
+            readonly maximum: 600;
+            readonly description: "Consumer's requested cache TTL for the released secret. The maintainer MAY cap this; the consumer MUST honour the maintainer's decision.";
+        };
+        readonly ext: {
+            readonly $ref: "#/$defs/Ext";
+        };
+    };
+    readonly $defs: {
+        readonly Response: {
+            readonly $anchor: "response";
+            readonly title: "Vault Release — response payload";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["sealedSecret", "secretKind", "ttlSeconds"];
+            readonly properties: {
+                readonly sealedSecret: {
+                    readonly $ref: "#/$defs/SealedEnvelope";
+                    readonly description: "Pluggable cipher envelope. Cleartext is a `vault/_shared/0.1/vault-secret#/$defs/VaultSecret`. Consumers reject envelope kinds they don't implement with `vault/release:envelope_unsupported`.";
+                };
+                readonly secretKind: {
+                    readonly $ref: "#/$defs/SecretKind";
+                    readonly description: "Discriminator so the consumer can pre-allocate the right type before unsealing.";
+                };
+                readonly ttlSeconds: {
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                    readonly maximum: 600;
+                    readonly description: "Cache TTL the consumer MUST enforce — wipe the cleartext after this many seconds, even if the user has not finished interacting with it.";
+                };
+                readonly ext: {
+                    readonly $ref: "#/$defs/Ext";
+                };
+            };
+        };
+        readonly Ext: {
+            readonly title: "Ext";
+            readonly description: "Vendor-namespaced extension object per SPEC.md §4.5.1. Each immediate key MUST be a reverse-DNS namespace; structure under each namespace is opaque to the framework.";
+            readonly type: "object";
+            readonly minProperties: 1;
+            readonly additionalProperties: true;
+            readonly propertyNames: {
+                readonly pattern: "^[a-z][a-z0-9-]*(\\.[a-z0-9-]+)+$";
+            };
+        };
+        readonly SecretKind: {
+            readonly title: "SecretKind";
+            readonly type: "string";
+            readonly enum: readonly ["password", "passkey", "oauthTokens", "didSelfIssued", "didcommPeer", "bearerToken", "sshKey", "custom"];
+            readonly description: "Discriminator for the secret type stored in the entry. Definitions:\n- `password` — username + password (+ optional TOTP seed).\n- `passkey` — WebAuthn discoverable credential (private key + rpId + userHandle).\n- `oauthTokens` — OAuth 2.0 refresh + access token bundle for a specific provider.\n- `didSelfIssued` — Self-Issued OpenID Provider v2 (SIOP) credential: the entry points at a DID + signing key already managed by the VTA.\n- `didcommPeer` — DIDComm peer identity used to authenticate against a DIDComm-speaking relying party.\n- `bearerToken` — opaque bearer token carried in a maintainer-named header (covers API tokens, long-lived JWTs, personal-access tokens).\n- `sshKey` — SSH private key + comment.\n- `custom` — arbitrary structured fields; release-time consumer responsible for interpretation.";
+        };
+        readonly SealedEnvelope: {
+            readonly title: "SealedEnvelope";
+            readonly description: "Discriminated by `envelope`. Exactly one variant matches per document.";
+            readonly oneOf: readonly [{
+                readonly $ref: "#/$defs/DidcommAuthcryptEnvelope";
+            }, {
+                readonly $ref: "#/$defs/HpkeArmoredEnvelope";
+            }, {
+                readonly $ref: "#/$defs/TspMessageEnvelope";
+            }];
+        };
+        readonly TspMessageEnvelope: {
+            readonly title: "TspMessageEnvelope";
+            readonly description: "Trust Spanning Protocol message (https://trustoverip.github.io/tswg-tsp-specification/). Reserved variant; no OpenVTC component reads or emits this today. Listed in the union so implementations can declare intent to use TSP in discovery and so consumers reject `tspMessage` envelopes explicitly (`envelope_unsupported`) until they're wired up — rather than silently failing in DIDComm parsing.";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["envelope", "message"];
+            readonly properties: {
+                readonly envelope: {
+                    readonly const: "tspMessage";
+                };
+                readonly message: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly description: "Base64url-encoded TSP message bytes. Format reference: https://trustoverip.github.io/tswg-tsp-specification/#message-format";
+                };
+            };
+        };
+        readonly HpkeArmoredEnvelope: {
+            readonly title: "HpkeArmoredEnvelope";
+            readonly description: "OpenPGP-style ASCII-armored HPKE bundle — the existing OpenVTC sealed-transfer wire form (X25519-HKDF-SHA256 KEM + ChaCha20-Poly1305 AEAD, framed in armor with Bundle-Id / Digest-Algo headers and a CRC24 checksum). Producer assertion (`didSigned` / `attested` / `pinnedOnly`) is the integrity / authenticity anchor.\n\nNo open-source implementation reads this yet outside vta-sdk's `sealed_transfer` crate; new code SHOULD prefer the DIDComm variant. Defined here for parity with the existing offline-bundle / cross-VTA workflows that the design plan reserves for M5+.";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["envelope", "armored", "recipientKeyId"];
+            readonly properties: {
+                readonly envelope: {
+                    readonly const: "hpkeArmored";
+                };
+                readonly armored: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly description: "ASCII-armored bundle text. Multi-line base64 with framing headers + CRC24.";
+                };
+                readonly recipientKeyId: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly description: "did:key identifier of the X25519 public key the envelope was sealed to. The recipient uses this to select the matching private key.";
+                };
+                readonly producerAssertion: {
+                    readonly type: "string";
+                    readonly enum: readonly ["didSigned", "attested", "pinnedOnly"];
+                    readonly default: "didSigned";
+                    readonly description: "Producer-assertion mode per the sealed-transfer framework. `didSigned` = Ed25519 signature by issuer; `attested` = TEE attestation quote (e.g. Nitro); `pinnedOnly` = OOB SHA-256 digest only (dev/test, NOT for production).";
+                };
+            };
+        };
+        readonly DidcommAuthcryptEnvelope: {
+            readonly title: "DidcommAuthcryptEnvelope";
+            readonly description: "DIDComm v2 authcrypt JWE (ECDH-1PU + A256CBC-HS512, X25519/P-256 key agreement). Sender authentication is the JWE's `skid` — the producer's DID#keyAgreement. The maintainer's keyAgreement key is the recipient. Cleartext is JCS-canonical JSON of the variant's payload type.\n\nM2A is the only implementation today; this is also the canonical default for new code.";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["envelope", "jwe"];
+            readonly properties: {
+                readonly envelope: {
+                    readonly const: "didcommAuthcrypt";
+                };
+                readonly jwe: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly description: "Compact DIDComm v2 JWE (base64url-encoded, dot-separated). Unpacks via the framework's standard DIDComm machinery; cleartext is the payload-specific JSON.";
+                };
+            };
+        };
+        readonly StepUpProof: {
+            readonly title: "StepUpProof";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["kind", "proof", "challengeId"];
+            readonly properties: {
+                readonly kind: {
+                    readonly type: "string";
+                    readonly enum: readonly ["webauthnUv", "pushApproval", "totp"];
+                };
+                readonly proof: {
+                    readonly type: "string";
+                    readonly description: "Format depends on kind: WebAuthn assertion (base64url), DIDComm approval-response message id, or 6–8-digit TOTP code.";
+                };
+                readonly challengeId: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly description: "Maintainer-issued challenge id the proof responds to.";
+                };
+            };
+        };
+        readonly ConsumerContext: {
+            readonly title: "ConsumerContext";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly deviceId: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly description: "Device-binding id assigned at registration. The maintainer cross-checks this against the authenticated transport identity.";
+                };
+                readonly lastUserVerificationAt: {
+                    readonly type: "string";
+                    readonly format: "date-time";
+                    readonly description: "Most recent local user-verification on the consumer device (WebAuthn UV, biometric unlock). The maintainer's policy may require this to be within N seconds.";
+                };
+                readonly networkClass: {
+                    readonly type: "string";
+                    readonly enum: readonly ["unknown", "home", "corp", "public", "vpn"];
+                    readonly description: "Producer-supplied network classification. Advisory.";
+                };
+            };
+        };
+        readonly SiteTarget: {
+            readonly title: "SiteTarget";
+            readonly description: "A single binding target for a vault entry. Tagged union over the discriminator `kind`. A VaultEntry's `targets` array MAY mix any number of these.";
+            readonly oneOf: readonly [{
+                readonly title: "WebOrigin";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["kind", "origin"];
+                readonly properties: {
+                    readonly kind: {
+                        readonly const: "webOrigin";
+                    };
+                    readonly origin: {
+                        readonly type: "string";
+                        readonly format: "uri";
+                        readonly description: "Web origin per RFC 6454 (scheme + host + optional port), e.g. \"https://github.com\". Compared by exact string equality after canonicalisation (lowercase host, default port elided). Consumers wanting subdomain coverage SHOULD add multiple targets, not encode a wildcard.";
+                    };
+                };
+            }, {
+                readonly title: "Did";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["kind", "did"];
+                readonly properties: {
+                    readonly kind: {
+                        readonly const: "did";
+                    };
+                    readonly did: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly description: "DID identifying the relying party (e.g. did:web:rp.example). The vault maintainer is responsible for any DID resolution required to act on this entry.";
+                    };
+                };
+            }, {
+                readonly title: "IosApp";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["kind", "bundleId"];
+                readonly properties: {
+                    readonly kind: {
+                        readonly const: "iosApp";
+                    };
+                    readonly bundleId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^[A-Za-z0-9.-]+$";
+                        readonly description: "iOS bundle identifier in reverse-DNS form (e.g. \"com.github.stwalkerster.codehub\"). Compared by exact string equality. Matches when an iOS Companion identifies the requesting app via its bundle id (typically via the OS Credential Manager integration).";
+                    };
+                    readonly teamId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^[A-Z0-9]+$";
+                        readonly description: "Optional Apple Developer Team identifier (10-character alphanumeric). When supplied, the maintainer SHOULD also verify the team id of the requesting app before matching — defense in depth against bundle-id squatting on jailbroken devices.";
+                    };
+                };
+            }, {
+                readonly title: "AndroidApp";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["kind", "packageName", "sha256CertFingerprints"];
+                readonly properties: {
+                    readonly kind: {
+                        readonly const: "androidApp";
+                    };
+                    readonly packageName: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^[A-Za-z][A-Za-z0-9_]*(\\.[A-Za-z][A-Za-z0-9_]*)+$";
+                        readonly description: "Android package name in reverse-DNS form (e.g. \"com.github.android\").";
+                    };
+                    readonly sha256CertFingerprints: {
+                        readonly type: "array";
+                        readonly minItems: 1;
+                        readonly items: {
+                            readonly type: "string";
+                            readonly pattern: "^[0-9A-F]{2}(:[0-9A-F]{2}){31}$";
+                        };
+                        readonly uniqueItems: true;
+                        readonly description: "SHA-256 fingerprints of the app's signing certificates, in colon-separated hex (the format `apksigner` and the Play Console emit). At least one fingerprint MUST be present. The maintainer matches when ANY of the provided fingerprints matches the requesting app's signature — this supports apps signed by multiple keys (e.g. during certificate rotation via Play App Signing).";
+                    };
+                };
+            }];
+        };
+    };
+};
+/** As {@link PAYLOAD_SCHEMA}, for the success-response variant. */
+export declare const RESPONSE_PAYLOAD_SCHEMA: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $ref: "#/$defs/Response";
+    readonly $defs: {
+        readonly Response: {
+            readonly $anchor: "response";
+            readonly title: "Vault Release — response payload";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["sealedSecret", "secretKind", "ttlSeconds"];
+            readonly properties: {
+                readonly sealedSecret: {
+                    readonly $ref: "#/$defs/SealedEnvelope";
+                    readonly description: "Pluggable cipher envelope. Cleartext is a `vault/_shared/0.1/vault-secret#/$defs/VaultSecret`. Consumers reject envelope kinds they don't implement with `vault/release:envelope_unsupported`.";
+                };
+                readonly secretKind: {
+                    readonly $ref: "#/$defs/SecretKind";
+                    readonly description: "Discriminator so the consumer can pre-allocate the right type before unsealing.";
+                };
+                readonly ttlSeconds: {
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                    readonly maximum: 600;
+                    readonly description: "Cache TTL the consumer MUST enforce — wipe the cleartext after this many seconds, even if the user has not finished interacting with it.";
+                };
+                readonly ext: {
+                    readonly $ref: "#/$defs/Ext";
+                };
+            };
+        };
+        readonly Ext: {
+            readonly title: "Ext";
+            readonly description: "Vendor-namespaced extension object per SPEC.md §4.5.1. Each immediate key MUST be a reverse-DNS namespace; structure under each namespace is opaque to the framework.";
+            readonly type: "object";
+            readonly minProperties: 1;
+            readonly additionalProperties: true;
+            readonly propertyNames: {
+                readonly pattern: "^[a-z][a-z0-9-]*(\\.[a-z0-9-]+)+$";
+            };
+        };
+        readonly SecretKind: {
+            readonly title: "SecretKind";
+            readonly type: "string";
+            readonly enum: readonly ["password", "passkey", "oauthTokens", "didSelfIssued", "didcommPeer", "bearerToken", "sshKey", "custom"];
+            readonly description: "Discriminator for the secret type stored in the entry. Definitions:\n- `password` — username + password (+ optional TOTP seed).\n- `passkey` — WebAuthn discoverable credential (private key + rpId + userHandle).\n- `oauthTokens` — OAuth 2.0 refresh + access token bundle for a specific provider.\n- `didSelfIssued` — Self-Issued OpenID Provider v2 (SIOP) credential: the entry points at a DID + signing key already managed by the VTA.\n- `didcommPeer` — DIDComm peer identity used to authenticate against a DIDComm-speaking relying party.\n- `bearerToken` — opaque bearer token carried in a maintainer-named header (covers API tokens, long-lived JWTs, personal-access tokens).\n- `sshKey` — SSH private key + comment.\n- `custom` — arbitrary structured fields; release-time consumer responsible for interpretation.";
+        };
+        readonly SealedEnvelope: {
+            readonly title: "SealedEnvelope";
+            readonly description: "Discriminated by `envelope`. Exactly one variant matches per document.";
+            readonly oneOf: readonly [{
+                readonly $ref: "#/$defs/DidcommAuthcryptEnvelope";
+            }, {
+                readonly $ref: "#/$defs/HpkeArmoredEnvelope";
+            }, {
+                readonly $ref: "#/$defs/TspMessageEnvelope";
+            }];
+        };
+        readonly TspMessageEnvelope: {
+            readonly title: "TspMessageEnvelope";
+            readonly description: "Trust Spanning Protocol message (https://trustoverip.github.io/tswg-tsp-specification/). Reserved variant; no OpenVTC component reads or emits this today. Listed in the union so implementations can declare intent to use TSP in discovery and so consumers reject `tspMessage` envelopes explicitly (`envelope_unsupported`) until they're wired up — rather than silently failing in DIDComm parsing.";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["envelope", "message"];
+            readonly properties: {
+                readonly envelope: {
+                    readonly const: "tspMessage";
+                };
+                readonly message: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly description: "Base64url-encoded TSP message bytes. Format reference: https://trustoverip.github.io/tswg-tsp-specification/#message-format";
+                };
+            };
+        };
+        readonly HpkeArmoredEnvelope: {
+            readonly title: "HpkeArmoredEnvelope";
+            readonly description: "OpenPGP-style ASCII-armored HPKE bundle — the existing OpenVTC sealed-transfer wire form (X25519-HKDF-SHA256 KEM + ChaCha20-Poly1305 AEAD, framed in armor with Bundle-Id / Digest-Algo headers and a CRC24 checksum). Producer assertion (`didSigned` / `attested` / `pinnedOnly`) is the integrity / authenticity anchor.\n\nNo open-source implementation reads this yet outside vta-sdk's `sealed_transfer` crate; new code SHOULD prefer the DIDComm variant. Defined here for parity with the existing offline-bundle / cross-VTA workflows that the design plan reserves for M5+.";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["envelope", "armored", "recipientKeyId"];
+            readonly properties: {
+                readonly envelope: {
+                    readonly const: "hpkeArmored";
+                };
+                readonly armored: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly description: "ASCII-armored bundle text. Multi-line base64 with framing headers + CRC24.";
+                };
+                readonly recipientKeyId: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly description: "did:key identifier of the X25519 public key the envelope was sealed to. The recipient uses this to select the matching private key.";
+                };
+                readonly producerAssertion: {
+                    readonly type: "string";
+                    readonly enum: readonly ["didSigned", "attested", "pinnedOnly"];
+                    readonly default: "didSigned";
+                    readonly description: "Producer-assertion mode per the sealed-transfer framework. `didSigned` = Ed25519 signature by issuer; `attested` = TEE attestation quote (e.g. Nitro); `pinnedOnly` = OOB SHA-256 digest only (dev/test, NOT for production).";
+                };
+            };
+        };
+        readonly DidcommAuthcryptEnvelope: {
+            readonly title: "DidcommAuthcryptEnvelope";
+            readonly description: "DIDComm v2 authcrypt JWE (ECDH-1PU + A256CBC-HS512, X25519/P-256 key agreement). Sender authentication is the JWE's `skid` — the producer's DID#keyAgreement. The maintainer's keyAgreement key is the recipient. Cleartext is JCS-canonical JSON of the variant's payload type.\n\nM2A is the only implementation today; this is also the canonical default for new code.";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["envelope", "jwe"];
+            readonly properties: {
+                readonly envelope: {
+                    readonly const: "didcommAuthcrypt";
+                };
+                readonly jwe: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly description: "Compact DIDComm v2 JWE (base64url-encoded, dot-separated). Unpacks via the framework's standard DIDComm machinery; cleartext is the payload-specific JSON.";
+                };
+            };
+        };
+        readonly StepUpProof: {
+            readonly title: "StepUpProof";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["kind", "proof", "challengeId"];
+            readonly properties: {
+                readonly kind: {
+                    readonly type: "string";
+                    readonly enum: readonly ["webauthnUv", "pushApproval", "totp"];
+                };
+                readonly proof: {
+                    readonly type: "string";
+                    readonly description: "Format depends on kind: WebAuthn assertion (base64url), DIDComm approval-response message id, or 6–8-digit TOTP code.";
+                };
+                readonly challengeId: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly description: "Maintainer-issued challenge id the proof responds to.";
+                };
+            };
+        };
+        readonly ConsumerContext: {
+            readonly title: "ConsumerContext";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly deviceId: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly description: "Device-binding id assigned at registration. The maintainer cross-checks this against the authenticated transport identity.";
+                };
+                readonly lastUserVerificationAt: {
+                    readonly type: "string";
+                    readonly format: "date-time";
+                    readonly description: "Most recent local user-verification on the consumer device (WebAuthn UV, biometric unlock). The maintainer's policy may require this to be within N seconds.";
+                };
+                readonly networkClass: {
+                    readonly type: "string";
+                    readonly enum: readonly ["unknown", "home", "corp", "public", "vpn"];
+                    readonly description: "Producer-supplied network classification. Advisory.";
+                };
+            };
+        };
+        readonly SiteTarget: {
+            readonly title: "SiteTarget";
+            readonly description: "A single binding target for a vault entry. Tagged union over the discriminator `kind`. A VaultEntry's `targets` array MAY mix any number of these.";
+            readonly oneOf: readonly [{
+                readonly title: "WebOrigin";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["kind", "origin"];
+                readonly properties: {
+                    readonly kind: {
+                        readonly const: "webOrigin";
+                    };
+                    readonly origin: {
+                        readonly type: "string";
+                        readonly format: "uri";
+                        readonly description: "Web origin per RFC 6454 (scheme + host + optional port), e.g. \"https://github.com\". Compared by exact string equality after canonicalisation (lowercase host, default port elided). Consumers wanting subdomain coverage SHOULD add multiple targets, not encode a wildcard.";
+                    };
+                };
+            }, {
+                readonly title: "Did";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["kind", "did"];
+                readonly properties: {
+                    readonly kind: {
+                        readonly const: "did";
+                    };
+                    readonly did: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly description: "DID identifying the relying party (e.g. did:web:rp.example). The vault maintainer is responsible for any DID resolution required to act on this entry.";
+                    };
+                };
+            }, {
+                readonly title: "IosApp";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["kind", "bundleId"];
+                readonly properties: {
+                    readonly kind: {
+                        readonly const: "iosApp";
+                    };
+                    readonly bundleId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^[A-Za-z0-9.-]+$";
+                        readonly description: "iOS bundle identifier in reverse-DNS form (e.g. \"com.github.stwalkerster.codehub\"). Compared by exact string equality. Matches when an iOS Companion identifies the requesting app via its bundle id (typically via the OS Credential Manager integration).";
+                    };
+                    readonly teamId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^[A-Z0-9]+$";
+                        readonly description: "Optional Apple Developer Team identifier (10-character alphanumeric). When supplied, the maintainer SHOULD also verify the team id of the requesting app before matching — defense in depth against bundle-id squatting on jailbroken devices.";
+                    };
+                };
+            }, {
+                readonly title: "AndroidApp";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["kind", "packageName", "sha256CertFingerprints"];
+                readonly properties: {
+                    readonly kind: {
+                        readonly const: "androidApp";
+                    };
+                    readonly packageName: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^[A-Za-z][A-Za-z0-9_]*(\\.[A-Za-z][A-Za-z0-9_]*)+$";
+                        readonly description: "Android package name in reverse-DNS form (e.g. \"com.github.android\").";
+                    };
+                    readonly sha256CertFingerprints: {
+                        readonly type: "array";
+                        readonly minItems: 1;
+                        readonly items: {
+                            readonly type: "string";
+                            readonly pattern: "^[0-9A-F]{2}(:[0-9A-F]{2}){31}$";
+                        };
+                        readonly uniqueItems: true;
+                        readonly description: "SHA-256 fingerprints of the app's signing certificates, in colon-separated hex (the format `apksigner` and the Play Console emit). At least one fingerprint MUST be present. The maintainer matches when ANY of the provided fingerprints matches the requesting app's signature — this supports apps signed by multiple keys (e.g. during certificate rotation via Play App Signing).";
+                    };
+                };
+            }];
+        };
+    };
+};
 /**
  * SPEC.md §7.2 policy for the request variant, from this specification's
  * front matter. Pass to `consumeInbound` — items 5b, 7 and 8 are
- * per-specification and cannot be derived from the document alone.
+ * per-specification and cannot be derived from the document alone, and
+ * item 2 needs the schema this carries.
  */
 export declare const SPEC: {
     readonly typeUri: "https://trusttasks.org/spec/vault/release/0.2";
     readonly isBearer: false;
     readonly isProofRequired: true;
     readonly isRecipientRequired: true;
+    readonly payloadSchema: {
+        readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+        readonly $id: "https://trusttasks.org/spec/vault/release/0.2";
+        readonly title: "Vault Release — payload";
+        readonly description: "Consumer requests that the maintainer release the cleartext secret material of a vault entry. The response carries the secret in a pluggable cipher envelope (see vault/_shared/0.1/sealed-envelope); the cleartext shape is `vault/_shared/0.1/vault-secret#/$defs/VaultSecret`. This is the fallback when proxy-login is not viable (`vault/proxy-login:not_proxyable`) or when the consumer needs the raw secret for a flow the maintainer cannot perform (e.g. autofill into a desktop app, copy-to-clipboard for offline use).";
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly required: readonly ["entryId"];
+        readonly properties: {
+            readonly entryId: {
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+            readonly target: {
+                readonly $ref: "#/$defs/SiteTarget";
+                readonly description: "Optional — for entries with multiple targets, indicates which one the consumer is acting against. The maintainer's policy may decide release based on the target (e.g. release for web origin allowed, release for iOS app denied).";
+            };
+            readonly consumerContext: {
+                readonly $ref: "#/$defs/ConsumerContext";
+                readonly description: "Caller's situational context — fed to the policy engine.";
+            };
+            readonly stepUpProof: {
+                readonly $ref: "#/$defs/StepUpProof";
+                readonly description: "Step-up proof on retry after step_up_required.";
+            };
+            readonly ttlSecondsHint: {
+                readonly type: "integer";
+                readonly minimum: 1;
+                readonly maximum: 600;
+                readonly description: "Consumer's requested cache TTL for the released secret. The maintainer MAY cap this; the consumer MUST honour the maintainer's decision.";
+            };
+            readonly ext: {
+                readonly $ref: "#/$defs/Ext";
+            };
+        };
+        readonly $defs: {
+            readonly Response: {
+                readonly $anchor: "response";
+                readonly title: "Vault Release — response payload";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["sealedSecret", "secretKind", "ttlSeconds"];
+                readonly properties: {
+                    readonly sealedSecret: {
+                        readonly $ref: "#/$defs/SealedEnvelope";
+                        readonly description: "Pluggable cipher envelope. Cleartext is a `vault/_shared/0.1/vault-secret#/$defs/VaultSecret`. Consumers reject envelope kinds they don't implement with `vault/release:envelope_unsupported`.";
+                    };
+                    readonly secretKind: {
+                        readonly $ref: "#/$defs/SecretKind";
+                        readonly description: "Discriminator so the consumer can pre-allocate the right type before unsealing.";
+                    };
+                    readonly ttlSeconds: {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                        readonly maximum: 600;
+                        readonly description: "Cache TTL the consumer MUST enforce — wipe the cleartext after this many seconds, even if the user has not finished interacting with it.";
+                    };
+                    readonly ext: {
+                        readonly $ref: "#/$defs/Ext";
+                    };
+                };
+            };
+            readonly Ext: {
+                readonly title: "Ext";
+                readonly description: "Vendor-namespaced extension object per SPEC.md §4.5.1. Each immediate key MUST be a reverse-DNS namespace; structure under each namespace is opaque to the framework.";
+                readonly type: "object";
+                readonly minProperties: 1;
+                readonly additionalProperties: true;
+                readonly propertyNames: {
+                    readonly pattern: "^[a-z][a-z0-9-]*(\\.[a-z0-9-]+)+$";
+                };
+            };
+            readonly SecretKind: {
+                readonly title: "SecretKind";
+                readonly type: "string";
+                readonly enum: readonly ["password", "passkey", "oauthTokens", "didSelfIssued", "didcommPeer", "bearerToken", "sshKey", "custom"];
+                readonly description: "Discriminator for the secret type stored in the entry. Definitions:\n- `password` — username + password (+ optional TOTP seed).\n- `passkey` — WebAuthn discoverable credential (private key + rpId + userHandle).\n- `oauthTokens` — OAuth 2.0 refresh + access token bundle for a specific provider.\n- `didSelfIssued` — Self-Issued OpenID Provider v2 (SIOP) credential: the entry points at a DID + signing key already managed by the VTA.\n- `didcommPeer` — DIDComm peer identity used to authenticate against a DIDComm-speaking relying party.\n- `bearerToken` — opaque bearer token carried in a maintainer-named header (covers API tokens, long-lived JWTs, personal-access tokens).\n- `sshKey` — SSH private key + comment.\n- `custom` — arbitrary structured fields; release-time consumer responsible for interpretation.";
+            };
+            readonly SealedEnvelope: {
+                readonly title: "SealedEnvelope";
+                readonly description: "Discriminated by `envelope`. Exactly one variant matches per document.";
+                readonly oneOf: readonly [{
+                    readonly $ref: "#/$defs/DidcommAuthcryptEnvelope";
+                }, {
+                    readonly $ref: "#/$defs/HpkeArmoredEnvelope";
+                }, {
+                    readonly $ref: "#/$defs/TspMessageEnvelope";
+                }];
+            };
+            readonly TspMessageEnvelope: {
+                readonly title: "TspMessageEnvelope";
+                readonly description: "Trust Spanning Protocol message (https://trustoverip.github.io/tswg-tsp-specification/). Reserved variant; no OpenVTC component reads or emits this today. Listed in the union so implementations can declare intent to use TSP in discovery and so consumers reject `tspMessage` envelopes explicitly (`envelope_unsupported`) until they're wired up — rather than silently failing in DIDComm parsing.";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["envelope", "message"];
+                readonly properties: {
+                    readonly envelope: {
+                        readonly const: "tspMessage";
+                    };
+                    readonly message: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly description: "Base64url-encoded TSP message bytes. Format reference: https://trustoverip.github.io/tswg-tsp-specification/#message-format";
+                    };
+                };
+            };
+            readonly HpkeArmoredEnvelope: {
+                readonly title: "HpkeArmoredEnvelope";
+                readonly description: "OpenPGP-style ASCII-armored HPKE bundle — the existing OpenVTC sealed-transfer wire form (X25519-HKDF-SHA256 KEM + ChaCha20-Poly1305 AEAD, framed in armor with Bundle-Id / Digest-Algo headers and a CRC24 checksum). Producer assertion (`didSigned` / `attested` / `pinnedOnly`) is the integrity / authenticity anchor.\n\nNo open-source implementation reads this yet outside vta-sdk's `sealed_transfer` crate; new code SHOULD prefer the DIDComm variant. Defined here for parity with the existing offline-bundle / cross-VTA workflows that the design plan reserves for M5+.";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["envelope", "armored", "recipientKeyId"];
+                readonly properties: {
+                    readonly envelope: {
+                        readonly const: "hpkeArmored";
+                    };
+                    readonly armored: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly description: "ASCII-armored bundle text. Multi-line base64 with framing headers + CRC24.";
+                    };
+                    readonly recipientKeyId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly description: "did:key identifier of the X25519 public key the envelope was sealed to. The recipient uses this to select the matching private key.";
+                    };
+                    readonly producerAssertion: {
+                        readonly type: "string";
+                        readonly enum: readonly ["didSigned", "attested", "pinnedOnly"];
+                        readonly default: "didSigned";
+                        readonly description: "Producer-assertion mode per the sealed-transfer framework. `didSigned` = Ed25519 signature by issuer; `attested` = TEE attestation quote (e.g. Nitro); `pinnedOnly` = OOB SHA-256 digest only (dev/test, NOT for production).";
+                    };
+                };
+            };
+            readonly DidcommAuthcryptEnvelope: {
+                readonly title: "DidcommAuthcryptEnvelope";
+                readonly description: "DIDComm v2 authcrypt JWE (ECDH-1PU + A256CBC-HS512, X25519/P-256 key agreement). Sender authentication is the JWE's `skid` — the producer's DID#keyAgreement. The maintainer's keyAgreement key is the recipient. Cleartext is JCS-canonical JSON of the variant's payload type.\n\nM2A is the only implementation today; this is also the canonical default for new code.";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["envelope", "jwe"];
+                readonly properties: {
+                    readonly envelope: {
+                        readonly const: "didcommAuthcrypt";
+                    };
+                    readonly jwe: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly description: "Compact DIDComm v2 JWE (base64url-encoded, dot-separated). Unpacks via the framework's standard DIDComm machinery; cleartext is the payload-specific JSON.";
+                    };
+                };
+            };
+            readonly StepUpProof: {
+                readonly title: "StepUpProof";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["kind", "proof", "challengeId"];
+                readonly properties: {
+                    readonly kind: {
+                        readonly type: "string";
+                        readonly enum: readonly ["webauthnUv", "pushApproval", "totp"];
+                    };
+                    readonly proof: {
+                        readonly type: "string";
+                        readonly description: "Format depends on kind: WebAuthn assertion (base64url), DIDComm approval-response message id, or 6–8-digit TOTP code.";
+                    };
+                    readonly challengeId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly description: "Maintainer-issued challenge id the proof responds to.";
+                    };
+                };
+            };
+            readonly ConsumerContext: {
+                readonly title: "ConsumerContext";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly properties: {
+                    readonly deviceId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly description: "Device-binding id assigned at registration. The maintainer cross-checks this against the authenticated transport identity.";
+                    };
+                    readonly lastUserVerificationAt: {
+                        readonly type: "string";
+                        readonly format: "date-time";
+                        readonly description: "Most recent local user-verification on the consumer device (WebAuthn UV, biometric unlock). The maintainer's policy may require this to be within N seconds.";
+                    };
+                    readonly networkClass: {
+                        readonly type: "string";
+                        readonly enum: readonly ["unknown", "home", "corp", "public", "vpn"];
+                        readonly description: "Producer-supplied network classification. Advisory.";
+                    };
+                };
+            };
+            readonly SiteTarget: {
+                readonly title: "SiteTarget";
+                readonly description: "A single binding target for a vault entry. Tagged union over the discriminator `kind`. A VaultEntry's `targets` array MAY mix any number of these.";
+                readonly oneOf: readonly [{
+                    readonly title: "WebOrigin";
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly required: readonly ["kind", "origin"];
+                    readonly properties: {
+                        readonly kind: {
+                            readonly const: "webOrigin";
+                        };
+                        readonly origin: {
+                            readonly type: "string";
+                            readonly format: "uri";
+                            readonly description: "Web origin per RFC 6454 (scheme + host + optional port), e.g. \"https://github.com\". Compared by exact string equality after canonicalisation (lowercase host, default port elided). Consumers wanting subdomain coverage SHOULD add multiple targets, not encode a wildcard.";
+                        };
+                    };
+                }, {
+                    readonly title: "Did";
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly required: readonly ["kind", "did"];
+                    readonly properties: {
+                        readonly kind: {
+                            readonly const: "did";
+                        };
+                        readonly did: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                            readonly description: "DID identifying the relying party (e.g. did:web:rp.example). The vault maintainer is responsible for any DID resolution required to act on this entry.";
+                        };
+                    };
+                }, {
+                    readonly title: "IosApp";
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly required: readonly ["kind", "bundleId"];
+                    readonly properties: {
+                        readonly kind: {
+                            readonly const: "iosApp";
+                        };
+                        readonly bundleId: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                            readonly pattern: "^[A-Za-z0-9.-]+$";
+                            readonly description: "iOS bundle identifier in reverse-DNS form (e.g. \"com.github.stwalkerster.codehub\"). Compared by exact string equality. Matches when an iOS Companion identifies the requesting app via its bundle id (typically via the OS Credential Manager integration).";
+                        };
+                        readonly teamId: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                            readonly pattern: "^[A-Z0-9]+$";
+                            readonly description: "Optional Apple Developer Team identifier (10-character alphanumeric). When supplied, the maintainer SHOULD also verify the team id of the requesting app before matching — defense in depth against bundle-id squatting on jailbroken devices.";
+                        };
+                    };
+                }, {
+                    readonly title: "AndroidApp";
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly required: readonly ["kind", "packageName", "sha256CertFingerprints"];
+                    readonly properties: {
+                        readonly kind: {
+                            readonly const: "androidApp";
+                        };
+                        readonly packageName: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                            readonly pattern: "^[A-Za-z][A-Za-z0-9_]*(\\.[A-Za-z][A-Za-z0-9_]*)+$";
+                            readonly description: "Android package name in reverse-DNS form (e.g. \"com.github.android\").";
+                        };
+                        readonly sha256CertFingerprints: {
+                            readonly type: "array";
+                            readonly minItems: 1;
+                            readonly items: {
+                                readonly type: "string";
+                                readonly pattern: "^[0-9A-F]{2}(:[0-9A-F]{2}){31}$";
+                            };
+                            readonly uniqueItems: true;
+                            readonly description: "SHA-256 fingerprints of the app's signing certificates, in colon-separated hex (the format `apksigner` and the Play Console emit). At least one fingerprint MUST be present. The maintainer matches when ANY of the provided fingerprints matches the requesting app's signature — this supports apps signed by multiple keys (e.g. during certificate rotation via Play App Signing).";
+                        };
+                    };
+                }];
+            };
+        };
+    };
 };
 /**
  * SPEC.md §7.2 policy for the success-response variant. `isRecipientRequired`
@@ -183,5 +999,252 @@ export declare const RESPONSE_SPEC: {
     readonly isBearer: false;
     readonly isProofRequired: true;
     readonly isRecipientRequired: true;
+    readonly payloadSchema: {
+        readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+        readonly $ref: "#/$defs/Response";
+        readonly $defs: {
+            readonly Response: {
+                readonly $anchor: "response";
+                readonly title: "Vault Release — response payload";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["sealedSecret", "secretKind", "ttlSeconds"];
+                readonly properties: {
+                    readonly sealedSecret: {
+                        readonly $ref: "#/$defs/SealedEnvelope";
+                        readonly description: "Pluggable cipher envelope. Cleartext is a `vault/_shared/0.1/vault-secret#/$defs/VaultSecret`. Consumers reject envelope kinds they don't implement with `vault/release:envelope_unsupported`.";
+                    };
+                    readonly secretKind: {
+                        readonly $ref: "#/$defs/SecretKind";
+                        readonly description: "Discriminator so the consumer can pre-allocate the right type before unsealing.";
+                    };
+                    readonly ttlSeconds: {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                        readonly maximum: 600;
+                        readonly description: "Cache TTL the consumer MUST enforce — wipe the cleartext after this many seconds, even if the user has not finished interacting with it.";
+                    };
+                    readonly ext: {
+                        readonly $ref: "#/$defs/Ext";
+                    };
+                };
+            };
+            readonly Ext: {
+                readonly title: "Ext";
+                readonly description: "Vendor-namespaced extension object per SPEC.md §4.5.1. Each immediate key MUST be a reverse-DNS namespace; structure under each namespace is opaque to the framework.";
+                readonly type: "object";
+                readonly minProperties: 1;
+                readonly additionalProperties: true;
+                readonly propertyNames: {
+                    readonly pattern: "^[a-z][a-z0-9-]*(\\.[a-z0-9-]+)+$";
+                };
+            };
+            readonly SecretKind: {
+                readonly title: "SecretKind";
+                readonly type: "string";
+                readonly enum: readonly ["password", "passkey", "oauthTokens", "didSelfIssued", "didcommPeer", "bearerToken", "sshKey", "custom"];
+                readonly description: "Discriminator for the secret type stored in the entry. Definitions:\n- `password` — username + password (+ optional TOTP seed).\n- `passkey` — WebAuthn discoverable credential (private key + rpId + userHandle).\n- `oauthTokens` — OAuth 2.0 refresh + access token bundle for a specific provider.\n- `didSelfIssued` — Self-Issued OpenID Provider v2 (SIOP) credential: the entry points at a DID + signing key already managed by the VTA.\n- `didcommPeer` — DIDComm peer identity used to authenticate against a DIDComm-speaking relying party.\n- `bearerToken` — opaque bearer token carried in a maintainer-named header (covers API tokens, long-lived JWTs, personal-access tokens).\n- `sshKey` — SSH private key + comment.\n- `custom` — arbitrary structured fields; release-time consumer responsible for interpretation.";
+            };
+            readonly SealedEnvelope: {
+                readonly title: "SealedEnvelope";
+                readonly description: "Discriminated by `envelope`. Exactly one variant matches per document.";
+                readonly oneOf: readonly [{
+                    readonly $ref: "#/$defs/DidcommAuthcryptEnvelope";
+                }, {
+                    readonly $ref: "#/$defs/HpkeArmoredEnvelope";
+                }, {
+                    readonly $ref: "#/$defs/TspMessageEnvelope";
+                }];
+            };
+            readonly TspMessageEnvelope: {
+                readonly title: "TspMessageEnvelope";
+                readonly description: "Trust Spanning Protocol message (https://trustoverip.github.io/tswg-tsp-specification/). Reserved variant; no OpenVTC component reads or emits this today. Listed in the union so implementations can declare intent to use TSP in discovery and so consumers reject `tspMessage` envelopes explicitly (`envelope_unsupported`) until they're wired up — rather than silently failing in DIDComm parsing.";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["envelope", "message"];
+                readonly properties: {
+                    readonly envelope: {
+                        readonly const: "tspMessage";
+                    };
+                    readonly message: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly description: "Base64url-encoded TSP message bytes. Format reference: https://trustoverip.github.io/tswg-tsp-specification/#message-format";
+                    };
+                };
+            };
+            readonly HpkeArmoredEnvelope: {
+                readonly title: "HpkeArmoredEnvelope";
+                readonly description: "OpenPGP-style ASCII-armored HPKE bundle — the existing OpenVTC sealed-transfer wire form (X25519-HKDF-SHA256 KEM + ChaCha20-Poly1305 AEAD, framed in armor with Bundle-Id / Digest-Algo headers and a CRC24 checksum). Producer assertion (`didSigned` / `attested` / `pinnedOnly`) is the integrity / authenticity anchor.\n\nNo open-source implementation reads this yet outside vta-sdk's `sealed_transfer` crate; new code SHOULD prefer the DIDComm variant. Defined here for parity with the existing offline-bundle / cross-VTA workflows that the design plan reserves for M5+.";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["envelope", "armored", "recipientKeyId"];
+                readonly properties: {
+                    readonly envelope: {
+                        readonly const: "hpkeArmored";
+                    };
+                    readonly armored: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly description: "ASCII-armored bundle text. Multi-line base64 with framing headers + CRC24.";
+                    };
+                    readonly recipientKeyId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly description: "did:key identifier of the X25519 public key the envelope was sealed to. The recipient uses this to select the matching private key.";
+                    };
+                    readonly producerAssertion: {
+                        readonly type: "string";
+                        readonly enum: readonly ["didSigned", "attested", "pinnedOnly"];
+                        readonly default: "didSigned";
+                        readonly description: "Producer-assertion mode per the sealed-transfer framework. `didSigned` = Ed25519 signature by issuer; `attested` = TEE attestation quote (e.g. Nitro); `pinnedOnly` = OOB SHA-256 digest only (dev/test, NOT for production).";
+                    };
+                };
+            };
+            readonly DidcommAuthcryptEnvelope: {
+                readonly title: "DidcommAuthcryptEnvelope";
+                readonly description: "DIDComm v2 authcrypt JWE (ECDH-1PU + A256CBC-HS512, X25519/P-256 key agreement). Sender authentication is the JWE's `skid` — the producer's DID#keyAgreement. The maintainer's keyAgreement key is the recipient. Cleartext is JCS-canonical JSON of the variant's payload type.\n\nM2A is the only implementation today; this is also the canonical default for new code.";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["envelope", "jwe"];
+                readonly properties: {
+                    readonly envelope: {
+                        readonly const: "didcommAuthcrypt";
+                    };
+                    readonly jwe: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly description: "Compact DIDComm v2 JWE (base64url-encoded, dot-separated). Unpacks via the framework's standard DIDComm machinery; cleartext is the payload-specific JSON.";
+                    };
+                };
+            };
+            readonly StepUpProof: {
+                readonly title: "StepUpProof";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["kind", "proof", "challengeId"];
+                readonly properties: {
+                    readonly kind: {
+                        readonly type: "string";
+                        readonly enum: readonly ["webauthnUv", "pushApproval", "totp"];
+                    };
+                    readonly proof: {
+                        readonly type: "string";
+                        readonly description: "Format depends on kind: WebAuthn assertion (base64url), DIDComm approval-response message id, or 6–8-digit TOTP code.";
+                    };
+                    readonly challengeId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly description: "Maintainer-issued challenge id the proof responds to.";
+                    };
+                };
+            };
+            readonly ConsumerContext: {
+                readonly title: "ConsumerContext";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly properties: {
+                    readonly deviceId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly description: "Device-binding id assigned at registration. The maintainer cross-checks this against the authenticated transport identity.";
+                    };
+                    readonly lastUserVerificationAt: {
+                        readonly type: "string";
+                        readonly format: "date-time";
+                        readonly description: "Most recent local user-verification on the consumer device (WebAuthn UV, biometric unlock). The maintainer's policy may require this to be within N seconds.";
+                    };
+                    readonly networkClass: {
+                        readonly type: "string";
+                        readonly enum: readonly ["unknown", "home", "corp", "public", "vpn"];
+                        readonly description: "Producer-supplied network classification. Advisory.";
+                    };
+                };
+            };
+            readonly SiteTarget: {
+                readonly title: "SiteTarget";
+                readonly description: "A single binding target for a vault entry. Tagged union over the discriminator `kind`. A VaultEntry's `targets` array MAY mix any number of these.";
+                readonly oneOf: readonly [{
+                    readonly title: "WebOrigin";
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly required: readonly ["kind", "origin"];
+                    readonly properties: {
+                        readonly kind: {
+                            readonly const: "webOrigin";
+                        };
+                        readonly origin: {
+                            readonly type: "string";
+                            readonly format: "uri";
+                            readonly description: "Web origin per RFC 6454 (scheme + host + optional port), e.g. \"https://github.com\". Compared by exact string equality after canonicalisation (lowercase host, default port elided). Consumers wanting subdomain coverage SHOULD add multiple targets, not encode a wildcard.";
+                        };
+                    };
+                }, {
+                    readonly title: "Did";
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly required: readonly ["kind", "did"];
+                    readonly properties: {
+                        readonly kind: {
+                            readonly const: "did";
+                        };
+                        readonly did: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                            readonly description: "DID identifying the relying party (e.g. did:web:rp.example). The vault maintainer is responsible for any DID resolution required to act on this entry.";
+                        };
+                    };
+                }, {
+                    readonly title: "IosApp";
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly required: readonly ["kind", "bundleId"];
+                    readonly properties: {
+                        readonly kind: {
+                            readonly const: "iosApp";
+                        };
+                        readonly bundleId: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                            readonly pattern: "^[A-Za-z0-9.-]+$";
+                            readonly description: "iOS bundle identifier in reverse-DNS form (e.g. \"com.github.stwalkerster.codehub\"). Compared by exact string equality. Matches when an iOS Companion identifies the requesting app via its bundle id (typically via the OS Credential Manager integration).";
+                        };
+                        readonly teamId: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                            readonly pattern: "^[A-Z0-9]+$";
+                            readonly description: "Optional Apple Developer Team identifier (10-character alphanumeric). When supplied, the maintainer SHOULD also verify the team id of the requesting app before matching — defense in depth against bundle-id squatting on jailbroken devices.";
+                        };
+                    };
+                }, {
+                    readonly title: "AndroidApp";
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly required: readonly ["kind", "packageName", "sha256CertFingerprints"];
+                    readonly properties: {
+                        readonly kind: {
+                            readonly const: "androidApp";
+                        };
+                        readonly packageName: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                            readonly pattern: "^[A-Za-z][A-Za-z0-9_]*(\\.[A-Za-z][A-Za-z0-9_]*)+$";
+                            readonly description: "Android package name in reverse-DNS form (e.g. \"com.github.android\").";
+                        };
+                        readonly sha256CertFingerprints: {
+                            readonly type: "array";
+                            readonly minItems: 1;
+                            readonly items: {
+                                readonly type: "string";
+                                readonly pattern: "^[0-9A-F]{2}(:[0-9A-F]{2}){31}$";
+                            };
+                            readonly uniqueItems: true;
+                            readonly description: "SHA-256 fingerprints of the app's signing certificates, in colon-separated hex (the format `apksigner` and the Play Console emit). At least one fingerprint MUST be present. The maintainer matches when ANY of the provided fingerprints matches the requesting app's signature — this supports apps signed by multiple keys (e.g. during certificate rotation via Play App Signing).";
+                        };
+                    };
+                }];
+            };
+        };
+    };
 };
 //# sourceMappingURL=payload.d.ts.map