@openvtc/trust-tasks 0.26.18 → 0.26.19

package/dist/vtc/join-requests/manifest/0.4/payload.d.ts

@@ -0,0 +1,2303 @@
+/**
+ * Generated by scripts/build-ts-bindings.mjs — DO NOT EDIT BY HAND.
+ * Source: specs/vtc/join-requests/manifest/0.4/payload.schema.json
+ */
+import type { Audience, ClaimType, DigestMultibase, DirectoryDisclosure, DisclosedField, Ext, ExtCritical, FieldDescription, FieldKey, FieldLabel, FieldSource, FieldType, GroupDisclosure, Introductions, Listing, NewCardDefaults, VettingDocumentation, VettingMethod } from "../../../../_shared/components.js";
+/**
+ * An ISO 8601 duration in weeks, days, hours, minutes and seconds only (e.g. `P120D`, `P2W`, `P1DT12H`, `PT15M`). Years and months are refused: their length depends on the calendar, and an age limit that means different things on different days is not a limit.
+ */
+export type Duration = string;
+/**
+ * Discover a community's join criteria before applying. The request carries nothing. Version 0.2 adds, per criterion, an optional `vetting` requirements object — how many identity-vetting statements a community needs, by which methods, from whom — and a `requirementsDigest` that names the exact version of the criterion an applicant started under. The response may also carry `branding`, how the community asks to be shown. Version 0.4 adds `directoryDisclosure`: where the community has a member directory, the statement of what it would disclose about a member and to whom, so an applicant reads it before applying.
+ */
+export interface VTCJoinRequestsManifestPayload {
+    ext?: Ext;
+}
+export interface VTCJoinRequestsManifestResponsePayload {
+    communityDid: string;
+    criteria: Criterion[];
+    /**
+     * What the community asks an applicant to tell it about themselves, as claim types — never values. Answered in persona terms: the applicant's agent discloses those attributes from the face the applicant chooses, and they arrive on vtc/join-requests/submit as `attributes`. SELF-ASSERTED: a community MUST NOT describe an answer as verified, and MUST NOT make a decision that assumes it is. Outside every criterion, so no `requirementsDigest` covers it. Absent when the community asks nothing.
+     *
+     * @maxItems 32
+     */
+    requestedAttributes?: {
+        /**
+         * A claim-type token from the persona claim-type registry (persona/_shared/0.1/CLAIM-TYPES.md) — `name.display`, `address.country` — or an `x:` extension token.
+         */
+        type: string;
+        /**
+         * False for an attribute the applicant may decline. A submission missing a required one is refused with vtc/join-requests/submit:attributesMissing.
+         */
+        required?: boolean;
+        /**
+         * Why the community asks, in words shown to the applicant before they disclose.
+         */
+        purpose?: string;
+    }[];
+    branding?: CommunityBranding;
+    /**
+     * Present exactly where the community offers a member directory: the statement, generated from its configuration, of what the directory would disclose about a member and to whom — the same statement vtc/directory/disclosure returns. Outside every criterion, so no `requirementsDigest` covers it; it names itself with its own `statementDigest`.
+     */
+    directoryDisclosure?: DirectoryDisclosure;
+    ext?: Ext;
+}
+export interface Criterion {
+    id: string;
+    /**
+     * Plain-language summary of the criterion, authored by the community and shown to prospective applicants. Informative: where it and `vetting` disagree, `vetting` governs.
+     */
+    description?: string;
+    /**
+     * How the community decides a submission that meets this criterion. `automatic`: it admits the applicant without a person deciding. `review`: it refers the submission to an administrator, who decides.
+     */
+    admission: "automatic" | "review";
+    /**
+     * The credentials an applicant must present for this criterion (opaque here). Absent: the criterion requires no credential.
+     */
+    presentationDefinition?: {};
+    /**
+     * Whose credentials meet `presentationDefinition`: `community` (this community's own), `recognised` (this community's, or a community it recognises), or `any` (any issuer whose credential verifies). Present exactly when `presentationDefinition` is.
+     */
+    credentialIssuers?: "any" | "community" | "recognised";
+    /**
+     * True: the criterion is met only by a submission carrying a valid, unconsumed invitation this community issued to the applicant.
+     */
+    invitationRequired?: boolean;
+    vetting?: VettingRequirements;
+    /**
+     * Digest over the RFC 8785 (JCS) canonicalization of this criterion object with the `requirementsDigest` member removed, as a multibase-encoded multihash (SHA-256 and base58btc RECOMMENDED). Names one version of the criterion: an applicant records it when starting an application and echoes it to vetters and at submission.
+     */
+    requirementsDigest: DigestMultibase;
+}
+/**
+ * What identity-vetting evidence a criterion needs, beyond what a presentation-definition can express: distinct eligible vetters, per-method floors, independence caps. Every number is the community's own policy. This schema supplies no defaults — an absent optional member means the community imposes no constraint of that kind, never that some protocol value applies. Deliberately open: a consumer MUST ignore members it does not recognise, so a community publishing a newer shape does not make an older client unable to read the rest. Durations: `maxStatementAge` — a statement older than this at decision time does not count (absent: no limit beyond the statement's own validity); `decisionSla` — how long after submission the community undertakes to decide, including on a referred application; `requirementsGrace` — how long an application started under an earlier `requirementsDigest` is still evaluated under that version.
+ */
+export interface VettingRequirements {
+    /**
+     * Version of this requirements object's shape. `0.1` for the members defined here.
+     */
+    version: string;
+    /**
+     * The predicate IRI a counted vetting statement carries in `credentialSubject.predicate` — `https://registry.trustoverip.org/dtg/vsc/vetted/1`, the DTG VSC registry's identity-vetting predicate, or a predicate in a namespace the community controls — registered as one the community accepts via vtc/endorsement-types/register. A statement under any other predicate does not count.
+     */
+    statementType: string;
+    /**
+     * How many counted statements are needed, counting each vetter once however many DIDs they hold.
+     */
+    minStatements: number;
+    /**
+     * Per-method floors within `minStatements` — e.g. `{ "inPerson": 1 }`. Every method named MUST also be in `acceptedMethods`. Absent: no method floor.
+     */
+    minByMethod?: {
+        [k: string]: number | undefined;
+    };
+    /**
+     * Methods whose statements count at all.
+     *
+     * @minItems 1
+     */
+    acceptedMethods: [VettingMethod, ...VettingMethod[]];
+    /**
+     * Documentation a statement must have relied on in order to count. Absent — the expected case — means each vetter decides what documentation they accept, including none for prior acquaintance, and the community counts what they attest.
+     *
+     * @minItems 1
+     */
+    acceptedDocumentClasses?: [VettingDocumentation, ...VettingDocumentation[]];
+    /**
+     * Claim types the applicant's Vetting Card must carry, which the identity commitment is computed over, and which a counted statement must list as verified. Absent: none.
+     */
+    requiredClaims?: ClaimType[];
+    /**
+     * Claim types an applicant MAY add to the card and a vetter MAY verify. They never affect whether a statement counts.
+     */
+    optionalClaims?: ClaimType[];
+    maxStatementAge?: Duration;
+    /**
+     * How a vetter's eligibility is established.
+     */
+    eligibleVetters: {
+        /**
+         * The role a statement's issuer must hold, matched as the action `role:<role>` in a Verifiable Authority Credential (`AuthorityCredential`) the community issued to that issuer, whose `authority.scope` is the community's DID (see `vtc/vetting/vetters/grant/0.1`). A statement counts only if its issuer holds such a credential.
+         */
+        role: string;
+    };
+    /**
+     * Caps on how much evidence may come from people close to the applicant. Absent: no caps.
+     */
+    independence?: {
+        /**
+         * The most counted statements that may come from vetters declaring each relationship — e.g. `{ "family": 0 }`.
+         */
+        maxByDeclaredRelationship?: {
+            [k: string]: number | undefined;
+        };
+        /**
+         * When true, every counted statement must carry the same identity commitment — all vetters verified the same claimed identity. Absent: false.
+         */
+        requireConsistentIdentityCommitment?: boolean;
+    };
+    /**
+     * Whether an invitation credential must accompany the statements at submission (`required`), may (`optional`), or plays no part (`none`). Absent: the presentation-definition alone governs.
+     */
+    invitation?: "required" | "optional" | "none";
+    decisionSla?: Duration;
+    requirementsGrace?: Duration;
+    /**
+     * Where the community's vetting governance — including the attestation text vetters sign — is published.
+     */
+    governanceFrameworkUrl?: string;
+    /**
+     * Ecosystem-defined extension members per SPEC.md §4.5.1, for vetting parameters this version does not enumerate. A community publishing an admission mode the base members cannot express — the zero-knowledge parameters an applicant proves against, say — puts them under a namespace it controls, rather than waiting for a version that names them.
+     *
+     * This object is already `additionalProperties: true`, so an unknown member here has always validated. That is not the same as reaching a consumer: a generated type names the members this schema declares and drops the rest, so an undeclared member is parsed and discarded, and it is discarded again on the re-serialization `requirementsDigest` is computed over. `ext` is a declared member, so it survives both.
+     */
+    ext?: Ext;
+    /**
+     * Namespaces of `ext` an applicant MUST understand or refuse, per SPEC.md §4.5.1.
+     *
+     * A community marks a namespace here when applying under this criterion without understanding it would mean something other than what the community requires — an applicant that ignored a hidden-vetting namespace, for instance, would submit named statements to a criterion whose whole point was that it does not receive them. An applicant that does not recognize a marked namespace stops rather than downgrading silently.
+     *
+     * Absent, which is the common case, every namespace under `ext` is advisory and ignorable.
+     */
+    extCritical?: ExtCritical;
+    [k: string]: unknown | undefined;
+}
+/**
+ * OPTIONAL. How the community asks to be shown to a prospective applicant: a name, an accent colour and a logo. Presentation only, self-asserted and unverified — `communityDid` identifies the community, never `branding`. Not part of any criterion, so not covered by a `requirementsDigest`. Every member is optional.
+ */
+export interface CommunityBranding {
+    /**
+     * The community's name as it asks to be shown.
+     */
+    displayName?: string;
+    /**
+     * An sRGB colour as `#rrggbb`, compared case-insensitively. A community SHOULD write it in lower case.
+     */
+    accentColor?: string;
+    /**
+     * An https URL of the community's logo. Fetched by the client, so an untrusted image from wherever it points.
+     */
+    logoUrl?: string;
+    ext?: Ext;
+}
+/** Shared definitions this specification references, re-exported under the names it used to declare them with. */
+export type { Audience, ClaimType, DigestMultibase, DirectoryDisclosure, DisclosedField, Ext, ExtCritical, FieldDescription, FieldKey, FieldLabel, FieldSource, FieldType, GroupDisclosure, Introductions, Listing, NewCardDefaults, VettingDocumentation, VettingMethod };
+/** Trust Task type URI. */
+export declare const TYPE_URI: "https://trusttasks.org/spec/vtc/join-requests/manifest/0.4";
+/** Stable alias for this specification's request payload shape. */
+export type Payload = VTCJoinRequestsManifestPayload;
+/** Trust Task response type URI (request type URI + "#response"). */
+export declare const RESPONSE_TYPE_URI: "https://trusttasks.org/spec/vtc/join-requests/manifest/0.4#response";
+/** Stable alias for this specification's success-response payload shape. */
+export type Response = VTCJoinRequestsManifestResponsePayload;
+/**
+ * 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/vtc/join-requests/manifest/0.4";
+    readonly title: "VTC Join-Requests Manifest — payload";
+    readonly description: "Discover a community's join criteria before applying. The request carries nothing. Version 0.2 adds, per criterion, an optional `vetting` requirements object — how many identity-vetting statements a community needs, by which methods, from whom — and a `requirementsDigest` that names the exact version of the criterion an applicant started under. The response may also carry `branding`, how the community asks to be shown. Version 0.4 adds `directoryDisclosure`: where the community has a member directory, the statement of what it would disclose about a member and to whom, so an applicant reads it before applying.";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly properties: {
+        readonly ext: {
+            readonly $ref: "#/$defs/Ext";
+        };
+    };
+    readonly $defs: {
+        readonly Duration: {
+            readonly title: "Duration";
+            readonly type: "string";
+            readonly maxLength: 32;
+            readonly pattern: "^P(([0-9]+W)?([0-9]+D)?T([0-9]+H([0-9]+M)?([0-9]+S)?|[0-9]+M([0-9]+S)?|[0-9]+S)|[0-9]+W([0-9]+D)?|[0-9]+D)$";
+            readonly description: "An ISO 8601 duration in weeks, days, hours, minutes and seconds only (e.g. `P120D`, `P2W`, `P1DT12H`, `PT15M`). Years and months are refused: their length depends on the calendar, and an age limit that means different things on different days is not a limit.";
+        };
+        readonly Criterion: {
+            readonly title: "Criterion";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["id", "admission", "requirementsDigest"];
+            readonly properties: {
+                readonly id: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 128;
+                };
+                readonly description: {
+                    readonly type: "string";
+                    readonly maxLength: 1024;
+                    readonly description: "Plain-language summary of the criterion, authored by the community and shown to prospective applicants. Informative: where it and `vetting` disagree, `vetting` governs.";
+                };
+                readonly admission: {
+                    readonly type: "string";
+                    readonly enum: readonly ["automatic", "review"];
+                    readonly description: "How the community decides a submission that meets this criterion. `automatic`: it admits the applicant without a person deciding. `review`: it refers the submission to an administrator, who decides.";
+                };
+                readonly presentationDefinition: {
+                    readonly type: "object";
+                    readonly description: "The credentials an applicant must present for this criterion (opaque here). Absent: the criterion requires no credential.";
+                };
+                readonly credentialIssuers: {
+                    readonly type: "string";
+                    readonly enum: readonly ["any", "community", "recognised"];
+                    readonly description: "Whose credentials meet `presentationDefinition`: `community` (this community's own), `recognised` (this community's, or a community it recognises), or `any` (any issuer whose credential verifies). Present exactly when `presentationDefinition` is.";
+                };
+                readonly invitationRequired: {
+                    readonly type: "boolean";
+                    readonly description: "True: the criterion is met only by a submission carrying a valid, unconsumed invitation this community issued to the applicant.";
+                };
+                readonly vetting: {
+                    readonly $ref: "#/$defs/VettingRequirements";
+                };
+                readonly requirementsDigest: {
+                    readonly $ref: "#/$defs/DigestMultibase";
+                    readonly description: "Digest over the RFC 8785 (JCS) canonicalization of this criterion object with the `requirementsDigest` member removed, as a multibase-encoded multihash (SHA-256 and base58btc RECOMMENDED). Names one version of the criterion: an applicant records it when starting an application and echoes it to vetters and at submission.";
+                };
+            };
+            readonly dependentRequired: {
+                readonly presentationDefinition: readonly ["credentialIssuers"];
+                readonly credentialIssuers: readonly ["presentationDefinition"];
+            };
+        };
+        readonly VettingRequirements: {
+            readonly title: "VettingRequirements";
+            readonly type: "object";
+            readonly additionalProperties: true;
+            readonly required: readonly ["version", "statementType", "minStatements", "acceptedMethods", "eligibleVetters"];
+            readonly description: "What identity-vetting evidence a criterion needs, beyond what a presentation-definition can express: distinct eligible vetters, per-method floors, independence caps. Every number is the community's own policy. This schema supplies no defaults — an absent optional member means the community imposes no constraint of that kind, never that some protocol value applies. Deliberately open: a consumer MUST ignore members it does not recognise, so a community publishing a newer shape does not make an older client unable to read the rest. Durations: `maxStatementAge` — a statement older than this at decision time does not count (absent: no limit beyond the statement's own validity); `decisionSla` — how long after submission the community undertakes to decide, including on a referred application; `requirementsGrace` — how long an application started under an earlier `requirementsDigest` is still evaluated under that version.";
+            readonly properties: {
+                readonly version: {
+                    readonly type: "string";
+                    readonly pattern: "^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)$";
+                    readonly description: "Version of this requirements object's shape. `0.1` for the members defined here.";
+                };
+                readonly statementType: {
+                    readonly type: "string";
+                    readonly format: "uri";
+                    readonly minLength: 1;
+                    readonly maxLength: 512;
+                    readonly description: "The predicate IRI a counted vetting statement carries in `credentialSubject.predicate` — `https://registry.trustoverip.org/dtg/vsc/vetted/1`, the DTG VSC registry's identity-vetting predicate, or a predicate in a namespace the community controls — registered as one the community accepts via vtc/endorsement-types/register. A statement under any other predicate does not count.";
+                };
+                readonly minStatements: {
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                    readonly description: "How many counted statements are needed, counting each vetter once however many DIDs they hold.";
+                };
+                readonly minByMethod: {
+                    readonly type: "object";
+                    readonly propertyNames: {
+                        readonly $ref: "#/$defs/VettingMethod";
+                    };
+                    readonly additionalProperties: {
+                        readonly type: "integer";
+                        readonly minimum: 0;
+                    };
+                    readonly description: "Per-method floors within `minStatements` — e.g. `{ \"inPerson\": 1 }`. Every method named MUST also be in `acceptedMethods`. Absent: no method floor.";
+                };
+                readonly acceptedMethods: {
+                    readonly type: "array";
+                    readonly minItems: 1;
+                    readonly uniqueItems: true;
+                    readonly items: {
+                        readonly $ref: "#/$defs/VettingMethod";
+                    };
+                    readonly description: "Methods whose statements count at all.";
+                };
+                readonly acceptedDocumentClasses: {
+                    readonly type: "array";
+                    readonly minItems: 1;
+                    readonly uniqueItems: true;
+                    readonly items: {
+                        readonly $ref: "#/$defs/VettingDocumentation";
+                    };
+                    readonly description: "Documentation a statement must have relied on in order to count. Absent — the expected case — means each vetter decides what documentation they accept, including none for prior acquaintance, and the community counts what they attest.";
+                };
+                readonly requiredClaims: {
+                    readonly type: "array";
+                    readonly uniqueItems: true;
+                    readonly items: {
+                        readonly $ref: "#/$defs/ClaimType";
+                    };
+                    readonly description: "Claim types the applicant's Vetting Card must carry, which the identity commitment is computed over, and which a counted statement must list as verified. Absent: none.";
+                };
+                readonly optionalClaims: {
+                    readonly type: "array";
+                    readonly uniqueItems: true;
+                    readonly items: {
+                        readonly $ref: "#/$defs/ClaimType";
+                    };
+                    readonly description: "Claim types an applicant MAY add to the card and a vetter MAY verify. They never affect whether a statement counts.";
+                };
+                readonly maxStatementAge: {
+                    readonly $ref: "#/$defs/Duration";
+                };
+                readonly eligibleVetters: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly required: readonly ["role"];
+                    readonly properties: {
+                        readonly role: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                            readonly maxLength: 128;
+                            readonly pattern: "^[a-zA-Z][a-zA-Z0-9_-]*$";
+                            readonly description: "The role a statement's issuer must hold, matched as the action `role:<role>` in a Verifiable Authority Credential (`AuthorityCredential`) the community issued to that issuer, whose `authority.scope` is the community's DID (see `vtc/vetting/vetters/grant/0.1`). A statement counts only if its issuer holds such a credential.";
+                        };
+                    };
+                    readonly description: "How a vetter's eligibility is established.";
+                };
+                readonly independence: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly maxByDeclaredRelationship: {
+                            readonly type: "object";
+                            readonly propertyNames: {
+                                readonly $ref: "#/$defs/VettingRelationship";
+                            };
+                            readonly additionalProperties: {
+                                readonly type: "integer";
+                                readonly minimum: 0;
+                            };
+                            readonly description: "The most counted statements that may come from vetters declaring each relationship — e.g. `{ \"family\": 0 }`.";
+                        };
+                        readonly requireConsistentIdentityCommitment: {
+                            readonly type: "boolean";
+                            readonly description: "When true, every counted statement must carry the same identity commitment — all vetters verified the same claimed identity. Absent: false.";
+                        };
+                    };
+                    readonly description: "Caps on how much evidence may come from people close to the applicant. Absent: no caps.";
+                };
+                readonly invitation: {
+                    readonly type: "string";
+                    readonly enum: readonly ["required", "optional", "none"];
+                    readonly description: "Whether an invitation credential must accompany the statements at submission (`required`), may (`optional`), or plays no part (`none`). Absent: the presentation-definition alone governs.";
+                };
+                readonly decisionSla: {
+                    readonly $ref: "#/$defs/Duration";
+                };
+                readonly requirementsGrace: {
+                    readonly $ref: "#/$defs/Duration";
+                };
+                readonly governanceFrameworkUrl: {
+                    readonly type: "string";
+                    readonly format: "uri";
+                    readonly pattern: "^https://";
+                    readonly maxLength: 2048;
+                    readonly description: "Where the community's vetting governance — including the attestation text vetters sign — is published.";
+                };
+                readonly ext: {
+                    readonly description: "Ecosystem-defined extension members per SPEC.md §4.5.1, for vetting parameters this version does not enumerate. A community publishing an admission mode the base members cannot express — the zero-knowledge parameters an applicant proves against, say — puts them under a namespace it controls, rather than waiting for a version that names them.\n\nThis object is already `additionalProperties: true`, so an unknown member here has always validated. That is not the same as reaching a consumer: a generated type names the members this schema declares and drops the rest, so an undeclared member is parsed and discarded, and it is discarded again on the re-serialization `requirementsDigest` is computed over. `ext` is a declared member, so it survives both.";
+                    readonly $ref: "#/$defs/Ext";
+                };
+                readonly extCritical: {
+                    readonly description: "Namespaces of `ext` an applicant MUST understand or refuse, per SPEC.md §4.5.1.\n\nA community marks a namespace here when applying under this criterion without understanding it would mean something other than what the community requires — an applicant that ignored a hidden-vetting namespace, for instance, would submit named statements to a criterion whose whole point was that it does not receive them. An applicant that does not recognize a marked namespace stops rather than downgrading silently.\n\nAbsent, which is the common case, every namespace under `ext` is advisory and ignorable.";
+                    readonly $ref: "#/$defs/ExtCritical";
+                };
+            };
+        };
+        readonly CommunityBranding: {
+            readonly title: "CommunityBranding";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly description: "OPTIONAL. How the community asks to be shown to a prospective applicant: a name, an accent colour and a logo. Presentation only, self-asserted and unverified — `communityDid` identifies the community, never `branding`. Not part of any criterion, so not covered by a `requirementsDigest`. Every member is optional.";
+            readonly properties: {
+                readonly displayName: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 128;
+                    readonly description: "The community's name as it asks to be shown.";
+                };
+                readonly accentColor: {
+                    readonly type: "string";
+                    readonly pattern: "^#[0-9a-fA-F]{6}$";
+                    readonly description: "An sRGB colour as `#rrggbb`, compared case-insensitively. A community SHOULD write it in lower case.";
+                };
+                readonly logoUrl: {
+                    readonly type: "string";
+                    readonly format: "uri";
+                    readonly pattern: "^https://";
+                    readonly maxLength: 2048;
+                    readonly description: "An https URL of the community's logo. Fetched by the client, so an untrusted image from wherever it points.";
+                };
+                readonly ext: {
+                    readonly $ref: "#/$defs/Ext";
+                };
+            };
+        };
+        readonly Response: {
+            readonly $anchor: "response";
+            readonly title: "VTC Join-Requests Manifest — response payload";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["communityDid", "criteria"];
+            readonly properties: {
+                readonly communityDid: {
+                    readonly type: "string";
+                    readonly pattern: "^did:";
+                };
+                readonly criteria: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/$defs/Criterion";
+                    };
+                };
+                readonly requestedAttributes: {
+                    readonly type: "array";
+                    readonly maxItems: 32;
+                    readonly description: "What the community asks an applicant to tell it about themselves, as claim types — never values. Answered in persona terms: the applicant's agent discloses those attributes from the face the applicant chooses, and they arrive on vtc/join-requests/submit as `attributes`. SELF-ASSERTED: a community MUST NOT describe an answer as verified, and MUST NOT make a decision that assumes it is. Outside every criterion, so no `requirementsDigest` covers it. Absent when the community asks nothing.";
+                    readonly items: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly required: readonly ["type"];
+                        readonly properties: {
+                            readonly type: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                                readonly maxLength: 128;
+                                readonly pattern: "^(x:)?[a-z][A-Za-z0-9]*(\\.[a-z][A-Za-z0-9]*)*$";
+                                readonly description: "A claim-type token from the persona claim-type registry (persona/_shared/0.1/CLAIM-TYPES.md) — `name.display`, `address.country` — or an `x:` extension token.";
+                            };
+                            readonly required: {
+                                readonly type: "boolean";
+                                readonly default: true;
+                                readonly description: "False for an attribute the applicant may decline. A submission missing a required one is refused with vtc/join-requests/submit:attributesMissing.";
+                            };
+                            readonly purpose: {
+                                readonly type: "string";
+                                readonly maxLength: 256;
+                                readonly description: "Why the community asks, in words shown to the applicant before they disclose.";
+                            };
+                        };
+                    };
+                };
+                readonly branding: {
+                    readonly $ref: "#/$defs/CommunityBranding";
+                };
+                readonly directoryDisclosure: {
+                    readonly $ref: "#/$defs/DirectoryDisclosure";
+                    readonly description: "Present exactly where the community offers a member directory: the statement, generated from its configuration, of what the directory would disclose about a member and to whom — the same statement vtc/directory/disclosure returns. Outside every criterion, so no `requirementsDigest` covers it; it names itself with its own `statementDigest`.";
+                };
+                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 DirectoryDisclosure: {
+            readonly title: "DirectoryDisclosure";
+            readonly description: "The statement itself. Every member is generated from the community's configuration when the statement is read. `statementDigest` names this exact statement, so an applicant can record which one it was shown.";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["fields", "newCard", "membershipIdentifiers", "adminNotes", "externalCards", "statementDigest"];
+            readonly properties: {
+                readonly fields: {
+                    readonly type: "array";
+                    readonly maxItems: 128;
+                    readonly items: {
+                        readonly $ref: "#/$defs/DisclosedField";
+                    };
+                    readonly description: "Every active field, base and community-defined, in display order. A base field the community has disabled is absent, which is how a reader learns it is not collected.";
+                };
+                readonly newCard: {
+                    readonly $ref: "#/$defs/NewCardDefaults";
+                };
+                readonly membershipIdentifiers: {
+                    readonly $ref: "#/$defs/Audience";
+                    readonly description: "The widest audience a member's membership identifier — the DID they joined with — can reach through the directory: the ceiling of the base field `did`, or `admins` where that field is disabled. `members` or `public` means a member may choose to show it that widely; a new card never shows it beyond `admins` (VTI-DIR-042). Administrators always see it.";
+                };
+                readonly adminNotes: {
+                    readonly type: "boolean";
+                    readonly description: "Whether administrators keep notes about members. Notes are never on a card and never reach another member; a member may ask for the notes about them.";
+                };
+                readonly groups: {
+                    readonly $ref: "#/$defs/GroupDisclosure";
+                };
+                readonly externalCards: {
+                    readonly type: "boolean";
+                    readonly description: "Whether a member may publish a card beyond the community: their `public` values, signed by them, offered through the community's trust registry. Always the member's own choice, and off on a new card. False where the community cannot publish external cards.";
+                };
+                readonly statementDigest: {
+                    readonly $ref: "#/$defs/DigestMultibase";
+                    readonly description: "Digest over the RFC 8785 (JCS) canonicalization of this statement with the `statementDigest` member removed, as a multibase-encoded multihash (SHA-256 and base58btc RECOMMENDED). Changes exactly when what the statement says changes.";
+                };
+                readonly ext: {
+                    readonly $ref: "#/$defs/Ext";
+                };
+            };
+        };
+        readonly GroupDisclosure: {
+            readonly title: "GroupDisclosure";
+            readonly description: "Present when the community has groups. A member of a group holds a credential, issued by the group's own identifier, that evidences their membership, and can present it outside the community — which is why an applicant is told.";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["credentialValidity"];
+            readonly properties: {
+                readonly credentialValidity: {
+                    readonly type: "string";
+                    readonly maxLength: 32;
+                    readonly pattern: "^P(([0-9]+W)?([0-9]+D)?T([0-9]+H([0-9]+M)?([0-9]+S)?|[0-9]+M([0-9]+S)?|[0-9]+S)|[0-9]+W([0-9]+D)?|[0-9]+D)$";
+                    readonly description: "How long each group membership credential is valid for, as an ISO 8601 duration in weeks, days, hours, minutes and seconds (`P30D`). It is renewed while the member stays in the group, and a credential already issued stays valid until it expires even after its holder leaves.";
+                };
+            };
+        };
+        readonly NewCardDefaults: {
+            readonly title: "NewCardDefaults";
+            readonly description: "The discoverability a card has when the community creates it, before its member chooses. A new card is never published beyond the community (VTI-DIR-042), so there is no member for that here: `externalCards` says whether the member may turn it on.";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["listing", "search"];
+            readonly properties: {
+                readonly listing: {
+                    readonly $ref: "#/$defs/Listing";
+                    readonly description: "The listing a new card starts with: the community's `defaultListing` (vtc/directory/fields/list). Every member may always choose `hidden`.";
+                };
+                readonly search: {
+                    readonly type: "string";
+                    readonly enum: readonly ["byName", "exactNickname", "off"];
+                    readonly description: "What a member's search may match, as the card's `discoverability.search`.";
+                };
+                readonly introductions: {
+                    readonly $ref: "#/$defs/Introductions";
+                    readonly description: "From whom a new card accepts introductions. Absent where the community does not deliver introductions.";
+                };
+            };
+        };
+        readonly Introductions: {
+            readonly title: "Introductions";
+            readonly description: "Who may ask the community to introduce them to this member. `anyone`: any active member who can find the entry. `groups`: only members who share a community group with them. `connections`: only members holding an attributed, in-force verified relationship with them. `off`: nobody. A refused introduction is never reported to its sender.";
+            readonly type: "string";
+            readonly enum: readonly ["anyone", "groups", "connections", "off"];
+        };
+        readonly Listing: {
+            readonly title: "Listing";
+            readonly description: "Whether members can find the entry. `listed`: it appears when members browse. `findable`: it does not appear when browsing, but a search that matches it under `search` returns it. `hidden`: no member finds it by browsing or searching; administrators still see it, and members who share a group that shows its members see it in that group's member list.";
+            readonly type: "string";
+            readonly enum: readonly ["listed", "findable", "hidden"];
+        };
+        readonly DisclosedField: {
+            readonly title: "DisclosedField";
+            readonly description: "One active field of the community's directory, as an applicant needs to see it: what it is, who writes its value, the widest audience it may ever reach and the audience a new card gives it. Disabled and retired fields are not listed: no projection shows them.";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["key", "label", "type", "source", "ceiling", "defaultVisibility", "searchable"];
+            readonly properties: {
+                readonly key: {
+                    readonly $ref: "#/$defs/FieldKey";
+                };
+                readonly label: {
+                    readonly $ref: "#/$defs/FieldLabel";
+                };
+                readonly description: {
+                    readonly $ref: "#/$defs/FieldDescription";
+                };
+                readonly type: {
+                    readonly $ref: "#/$defs/FieldType";
+                };
+                readonly source: {
+                    readonly $ref: "#/$defs/FieldSource";
+                    readonly description: "Who writes the value. `admin` and `credential` matter most to an applicant: an `admin` field holds what the community asserts about the member, which the member reads and cannot change.";
+                };
+                readonly ceiling: {
+                    readonly $ref: "#/$defs/Audience";
+                    readonly description: "The widest audience the field may ever reach, whatever the member chooses.";
+                };
+                readonly defaultVisibility: {
+                    readonly $ref: "#/$defs/Audience";
+                    readonly description: "The audience a new card gives the field until its member chooses. Never wider than `ceiling`.";
+                };
+                readonly searchable: {
+                    readonly type: "boolean";
+                    readonly description: "Whether a member's search may match the field, within what the searcher may see.";
+                };
+                readonly facet: {
+                    readonly type: "boolean";
+                    readonly description: "Whether members may filter on the field and see counts by its values. Absent: false.";
+                };
+            };
+        };
+        readonly Audience: {
+            readonly title: "Audience";
+            readonly description: "Who may see a directory field, ordered from narrowest to widest. `admins`: holders of `vtc.directory.admin` (and, for derived fields, `vtc.members.manage`). `groups`: members who share at least one community group with the subject (narrowed to the groups the subject names in `groupAudience`, where it names any). `connections`: members holding an attributed, in-force verified relationship with the subject at the community. `members`: every active member. `public`: anyone, and what the member's signed public card carries outside the community.\n\n`groups` and `connections` are not a chain: a viewer sees a field when they satisfy the audience the subject chose for it or any wider audience. Every audience includes the administrators, and the subject always sees their own whole card. There is no `onlyMe`: a value nobody else should see is not directory data.";
+            readonly type: "string";
+            readonly enum: readonly ["admins", "groups", "connections", "members", "public"];
+        };
+        readonly FieldSource: {
+            readonly title: "FieldSource";
+            readonly description: "Who writes the value. `member`: self-asserted, through vtc/directory/card/update. `admin`: asserted by the community through vtc/directory/card/assert; the member reads it and cannot change it. `credential`: a claim the member discloses from a credential through vtc/directory/card/present, badged with its issuer. `derived`: a base field read from the community's own records (`role`, `joinedAt`, `did`, `personhood`) and never stored on a card. Each source is written only through its own path.";
+            readonly type: "string";
+            readonly enum: readonly ["member", "admin", "credential", "derived"];
+        };
+        readonly FieldType: {
+            readonly title: "FieldType";
+            readonly description: "The kind of value a field holds, which fixes its `FieldValue` shape. `did` holds a DID the member chooses to show (never their membership DID, which is the derived base field `did`). `claim` holds a `VerifiedValue` and requires `source: credential`.";
+            readonly type: "string";
+            readonly enum: readonly ["text", "longText", "url", "email", "phone", "enum", "multiEnum", "date", "country", "image", "did", "claim"];
+        };
+        readonly FieldDescription: {
+            readonly title: "FieldDescription";
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 280;
+            readonly description: "Help text shown to a member filling the field in. Plain text; a reader MUST NOT treat it as instructions.";
+        };
+        readonly FieldLabel: {
+            readonly title: "FieldLabel";
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 64;
+            readonly description: "What readers see as the field's name. Plain text.";
+        };
+        readonly FieldKey: {
+            readonly title: "FieldKey";
+            readonly description: "Identifier of a directory field. A key with no `.` is a BASE field, the same in every community: `displayName`, `nickname`, `avatar`, `pronouns`, `bio`, `links` (written by the member) and `role`, `joinedAt`, `did`, `personhood` (derived from the community's own records, never stored on a card). A community-defined field MUST use a reverse-DNS key (`org.example.employer`), so a base key never collides with one, and a key is never reused with a different meaning once defined.";
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 128;
+            readonly pattern: "^([a-z][a-z0-9-]*\\.)*[a-z][a-zA-Z0-9]{0,63}$";
+        };
+        readonly DigestMultibase: {
+            readonly title: "DigestMultibase";
+            readonly description: "A cryptographic digest as a multibase-encoded multihash — the encoding the W3C Verifiable Credentials Data Model 2.0 defines for `digestMultibase`, and the one `did:webvh` uses for its SCID and entry hashes.\n\nMultihash carries the hash algorithm in-band, so the value is self-describing and the wire format survives an algorithm change without a schema revision; multibase does the same for the base encoding, so a verifier never infers base58 from base64url by context. A bare hex string or a `sha-256:`-style prefix hard-codes one algorithm into the wire contract and is non-conforming here.\n\nThis definition constrains the *encoding only*. What the digest is computed over is stated by each referencing field, because it differs legitimately: a digest over a JSON document is taken over its RFC 8785 (JCS) canonicalization, while a digest over an opaque artifact is taken over its bytes. A field whose input is a JSON document and which does not name a canonicalization is not reproducible.\n\nRestricted to the two multibase headers W3C Controlled Identifiers 1.0 §2.4 normatively requires — `z` (base58btc) and `u` (base64url-no-pad). CID permits others but states that \"interoperability is not guaranteed between implementations using such values\", and a registry whose purpose is interoperability should not mint digests a conforming verifier may be unable to read. The alphabets are enforced rather than assumed: base58btc excludes 0, O, I and l, and an earlier permissive pattern let three published examples carry digests that were not valid base58 at all. base58btc is RECOMMENDED, for consistency with `did:key` and `did:webvh`.";
+            readonly type: "string";
+            readonly minLength: 16;
+            readonly pattern: "^(z[1-9A-HJ-NP-Za-km-z]+|u[A-Za-z0-9_-]+)$";
+            readonly examples: readonly ["zQmbWqxBEKC3P8tqsKc98xmWNzrzDtRLMiMPL8wBuTGsMnR"];
+        };
+        readonly ExtCritical: {
+            readonly title: "ExtCritical";
+            readonly description: "Names the `ext` namespaces a consumer MUST understand or refuse, per SPEC.md §4.5.1.\n\nEvery entry MUST be an immediate key of the sibling `ext` object at the same level; an entry naming an absent namespace is non-conforming and the consumer rejects the document with `malformedRequest`. A consumer that does not recognize a namespace named here MUST NOT process the document as though the namespace were absent, and rejects it with `unsupportedExtension` — the exception to the rule that unrecognized namespaces are ignored.\n\nA producer marks a namespace only where the document's meaning depends on it. Marking one that merely carries a hint or an annotation turns every consumer that has not implemented it into a failure where it would otherwise have interoperated. JSON Schema cannot check either of those rules: that an entry names a present namespace is checkable only against the sibling `ext`, and whether a namespace is load-bearing is not a schema question at all. Both are consumer-side checks.";
+            readonly type: "array";
+            readonly minItems: 1;
+            readonly uniqueItems: true;
+            readonly items: {
+                readonly type: "string";
+                readonly pattern: "^[a-z][a-z0-9-]*(\\.[a-z0-9-]+)+$";
+            };
+            readonly examples: readonly [readonly ["org.openvtc.hidden-vetting"]];
+        };
+        readonly VettingRelationship: {
+            readonly title: "VettingRelationship";
+            readonly type: "string";
+            readonly enum: readonly ["none", "communityColleague", "sameEmployer", "family", "otherPersonal"];
+            readonly description: "The vetter's own declaration of how they relate to the applicant. Declared, not verified: it exists so community policy can cap how much evidence comes from people close to the applicant, and a false declaration is the vetter's attributable act.";
+        };
+        readonly ClaimType: {
+            readonly title: "ClaimType";
+            readonly description: "The vocabulary token naming what a value IS — `name.legal`, `phone.mobile`, `address.postal`, `person.birthDate`. Dotted, most-general segment first, so that a consumer with no knowledge of the specific token can still group by its prefix.\n\nThe token is the maintainer's own; no external vocabulary is primary. External vocabularies (vCard/jCard, OIDC standard claims, schema.org) are mappings applied at PRESENTATION by a renderer, not at rest, so that a query written in any of them can be matched without the store having to live inside any one of them.\n\nThe `x:` prefix is an open extension namespace and is not decoration. The closest prior art — Windows CardSpace's self-issued card — supported exactly fifteen predefined claim types with no extensibility, and that is the specific way it failed the requirement a holder actually has. An `x:` attribute stores, composes, binds and discloses exactly like a known one; it renders generically and matches only an explicit query.";
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 128;
+            readonly pattern: "^(x:)?[a-z][a-zA-Z0-9]*(\\.[a-z][a-zA-Z0-9]*)*$";
+        };
+        readonly VettingDocumentation: {
+            readonly title: "VettingDocumentation";
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 64;
+            readonly pattern: "^[a-z][a-zA-Z0-9]*$";
+            readonly description: "A class of documentation, named in lowerCamelCase. Open rather than enumerated, because what documentation a vetter accepts is each vetter's own choice. Well-known values: `passport`, `nationalId`, `driverLicence`, and `none` — the vetter will attest without a document, which is the `priorAcquaintance` case. Only the class ever travels — never a document number, an image, an issuing authority or an expiry date. `none` states a policy (what a vetter accepts); a record of what was relied on expresses 'no document' as an empty list instead.";
+        };
+        readonly VettingMethod: {
+            readonly title: "VettingMethod";
+            readonly type: "string";
+            readonly enum: readonly ["inPerson", "video", "priorAcquaintance"];
+            readonly description: "How the vetter established that the person they checked is the person controlling the applicant's DID. `inPerson` — both people were physically together. `video` — a live, two-way video call. `priorAcquaintance` — the vetter has known or worked with this person over a period, and attests from that knowledge rather than from a document. A method is a description of what happened, not an assurance level: which methods count, and how many of each, is community policy.";
+        };
+    };
+};
+/** 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 Duration: {
+            readonly title: "Duration";
+            readonly type: "string";
+            readonly maxLength: 32;
+            readonly pattern: "^P(([0-9]+W)?([0-9]+D)?T([0-9]+H([0-9]+M)?([0-9]+S)?|[0-9]+M([0-9]+S)?|[0-9]+S)|[0-9]+W([0-9]+D)?|[0-9]+D)$";
+            readonly description: "An ISO 8601 duration in weeks, days, hours, minutes and seconds only (e.g. `P120D`, `P2W`, `P1DT12H`, `PT15M`). Years and months are refused: their length depends on the calendar, and an age limit that means different things on different days is not a limit.";
+        };
+        readonly Criterion: {
+            readonly title: "Criterion";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["id", "admission", "requirementsDigest"];
+            readonly properties: {
+                readonly id: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 128;
+                };
+                readonly description: {
+                    readonly type: "string";
+                    readonly maxLength: 1024;
+                    readonly description: "Plain-language summary of the criterion, authored by the community and shown to prospective applicants. Informative: where it and `vetting` disagree, `vetting` governs.";
+                };
+                readonly admission: {
+                    readonly type: "string";
+                    readonly enum: readonly ["automatic", "review"];
+                    readonly description: "How the community decides a submission that meets this criterion. `automatic`: it admits the applicant without a person deciding. `review`: it refers the submission to an administrator, who decides.";
+                };
+                readonly presentationDefinition: {
+                    readonly type: "object";
+                    readonly description: "The credentials an applicant must present for this criterion (opaque here). Absent: the criterion requires no credential.";
+                };
+                readonly credentialIssuers: {
+                    readonly type: "string";
+                    readonly enum: readonly ["any", "community", "recognised"];
+                    readonly description: "Whose credentials meet `presentationDefinition`: `community` (this community's own), `recognised` (this community's, or a community it recognises), or `any` (any issuer whose credential verifies). Present exactly when `presentationDefinition` is.";
+                };
+                readonly invitationRequired: {
+                    readonly type: "boolean";
+                    readonly description: "True: the criterion is met only by a submission carrying a valid, unconsumed invitation this community issued to the applicant.";
+                };
+                readonly vetting: {
+                    readonly $ref: "#/$defs/VettingRequirements";
+                };
+                readonly requirementsDigest: {
+                    readonly $ref: "#/$defs/DigestMultibase";
+                    readonly description: "Digest over the RFC 8785 (JCS) canonicalization of this criterion object with the `requirementsDigest` member removed, as a multibase-encoded multihash (SHA-256 and base58btc RECOMMENDED). Names one version of the criterion: an applicant records it when starting an application and echoes it to vetters and at submission.";
+                };
+            };
+            readonly dependentRequired: {
+                readonly presentationDefinition: readonly ["credentialIssuers"];
+                readonly credentialIssuers: readonly ["presentationDefinition"];
+            };
+        };
+        readonly VettingRequirements: {
+            readonly title: "VettingRequirements";
+            readonly type: "object";
+            readonly additionalProperties: true;
+            readonly required: readonly ["version", "statementType", "minStatements", "acceptedMethods", "eligibleVetters"];
+            readonly description: "What identity-vetting evidence a criterion needs, beyond what a presentation-definition can express: distinct eligible vetters, per-method floors, independence caps. Every number is the community's own policy. This schema supplies no defaults — an absent optional member means the community imposes no constraint of that kind, never that some protocol value applies. Deliberately open: a consumer MUST ignore members it does not recognise, so a community publishing a newer shape does not make an older client unable to read the rest. Durations: `maxStatementAge` — a statement older than this at decision time does not count (absent: no limit beyond the statement's own validity); `decisionSla` — how long after submission the community undertakes to decide, including on a referred application; `requirementsGrace` — how long an application started under an earlier `requirementsDigest` is still evaluated under that version.";
+            readonly properties: {
+                readonly version: {
+                    readonly type: "string";
+                    readonly pattern: "^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)$";
+                    readonly description: "Version of this requirements object's shape. `0.1` for the members defined here.";
+                };
+                readonly statementType: {
+                    readonly type: "string";
+                    readonly format: "uri";
+                    readonly minLength: 1;
+                    readonly maxLength: 512;
+                    readonly description: "The predicate IRI a counted vetting statement carries in `credentialSubject.predicate` — `https://registry.trustoverip.org/dtg/vsc/vetted/1`, the DTG VSC registry's identity-vetting predicate, or a predicate in a namespace the community controls — registered as one the community accepts via vtc/endorsement-types/register. A statement under any other predicate does not count.";
+                };
+                readonly minStatements: {
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                    readonly description: "How many counted statements are needed, counting each vetter once however many DIDs they hold.";
+                };
+                readonly minByMethod: {
+                    readonly type: "object";
+                    readonly propertyNames: {
+                        readonly $ref: "#/$defs/VettingMethod";
+                    };
+                    readonly additionalProperties: {
+                        readonly type: "integer";
+                        readonly minimum: 0;
+                    };
+                    readonly description: "Per-method floors within `minStatements` — e.g. `{ \"inPerson\": 1 }`. Every method named MUST also be in `acceptedMethods`. Absent: no method floor.";
+                };
+                readonly acceptedMethods: {
+                    readonly type: "array";
+                    readonly minItems: 1;
+                    readonly uniqueItems: true;
+                    readonly items: {
+                        readonly $ref: "#/$defs/VettingMethod";
+                    };
+                    readonly description: "Methods whose statements count at all.";
+                };
+                readonly acceptedDocumentClasses: {
+                    readonly type: "array";
+                    readonly minItems: 1;
+                    readonly uniqueItems: true;
+                    readonly items: {
+                        readonly $ref: "#/$defs/VettingDocumentation";
+                    };
+                    readonly description: "Documentation a statement must have relied on in order to count. Absent — the expected case — means each vetter decides what documentation they accept, including none for prior acquaintance, and the community counts what they attest.";
+                };
+                readonly requiredClaims: {
+                    readonly type: "array";
+                    readonly uniqueItems: true;
+                    readonly items: {
+                        readonly $ref: "#/$defs/ClaimType";
+                    };
+                    readonly description: "Claim types the applicant's Vetting Card must carry, which the identity commitment is computed over, and which a counted statement must list as verified. Absent: none.";
+                };
+                readonly optionalClaims: {
+                    readonly type: "array";
+                    readonly uniqueItems: true;
+                    readonly items: {
+                        readonly $ref: "#/$defs/ClaimType";
+                    };
+                    readonly description: "Claim types an applicant MAY add to the card and a vetter MAY verify. They never affect whether a statement counts.";
+                };
+                readonly maxStatementAge: {
+                    readonly $ref: "#/$defs/Duration";
+                };
+                readonly eligibleVetters: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly required: readonly ["role"];
+                    readonly properties: {
+                        readonly role: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                            readonly maxLength: 128;
+                            readonly pattern: "^[a-zA-Z][a-zA-Z0-9_-]*$";
+                            readonly description: "The role a statement's issuer must hold, matched as the action `role:<role>` in a Verifiable Authority Credential (`AuthorityCredential`) the community issued to that issuer, whose `authority.scope` is the community's DID (see `vtc/vetting/vetters/grant/0.1`). A statement counts only if its issuer holds such a credential.";
+                        };
+                    };
+                    readonly description: "How a vetter's eligibility is established.";
+                };
+                readonly independence: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly maxByDeclaredRelationship: {
+                            readonly type: "object";
+                            readonly propertyNames: {
+                                readonly $ref: "#/$defs/VettingRelationship";
+                            };
+                            readonly additionalProperties: {
+                                readonly type: "integer";
+                                readonly minimum: 0;
+                            };
+                            readonly description: "The most counted statements that may come from vetters declaring each relationship — e.g. `{ \"family\": 0 }`.";
+                        };
+                        readonly requireConsistentIdentityCommitment: {
+                            readonly type: "boolean";
+                            readonly description: "When true, every counted statement must carry the same identity commitment — all vetters verified the same claimed identity. Absent: false.";
+                        };
+                    };
+                    readonly description: "Caps on how much evidence may come from people close to the applicant. Absent: no caps.";
+                };
+                readonly invitation: {
+                    readonly type: "string";
+                    readonly enum: readonly ["required", "optional", "none"];
+                    readonly description: "Whether an invitation credential must accompany the statements at submission (`required`), may (`optional`), or plays no part (`none`). Absent: the presentation-definition alone governs.";
+                };
+                readonly decisionSla: {
+                    readonly $ref: "#/$defs/Duration";
+                };
+                readonly requirementsGrace: {
+                    readonly $ref: "#/$defs/Duration";
+                };
+                readonly governanceFrameworkUrl: {
+                    readonly type: "string";
+                    readonly format: "uri";
+                    readonly pattern: "^https://";
+                    readonly maxLength: 2048;
+                    readonly description: "Where the community's vetting governance — including the attestation text vetters sign — is published.";
+                };
+                readonly ext: {
+                    readonly description: "Ecosystem-defined extension members per SPEC.md §4.5.1, for vetting parameters this version does not enumerate. A community publishing an admission mode the base members cannot express — the zero-knowledge parameters an applicant proves against, say — puts them under a namespace it controls, rather than waiting for a version that names them.\n\nThis object is already `additionalProperties: true`, so an unknown member here has always validated. That is not the same as reaching a consumer: a generated type names the members this schema declares and drops the rest, so an undeclared member is parsed and discarded, and it is discarded again on the re-serialization `requirementsDigest` is computed over. `ext` is a declared member, so it survives both.";
+                    readonly $ref: "#/$defs/Ext";
+                };
+                readonly extCritical: {
+                    readonly description: "Namespaces of `ext` an applicant MUST understand or refuse, per SPEC.md §4.5.1.\n\nA community marks a namespace here when applying under this criterion without understanding it would mean something other than what the community requires — an applicant that ignored a hidden-vetting namespace, for instance, would submit named statements to a criterion whose whole point was that it does not receive them. An applicant that does not recognize a marked namespace stops rather than downgrading silently.\n\nAbsent, which is the common case, every namespace under `ext` is advisory and ignorable.";
+                    readonly $ref: "#/$defs/ExtCritical";
+                };
+            };
+        };
+        readonly CommunityBranding: {
+            readonly title: "CommunityBranding";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly description: "OPTIONAL. How the community asks to be shown to a prospective applicant: a name, an accent colour and a logo. Presentation only, self-asserted and unverified — `communityDid` identifies the community, never `branding`. Not part of any criterion, so not covered by a `requirementsDigest`. Every member is optional.";
+            readonly properties: {
+                readonly displayName: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 128;
+                    readonly description: "The community's name as it asks to be shown.";
+                };
+                readonly accentColor: {
+                    readonly type: "string";
+                    readonly pattern: "^#[0-9a-fA-F]{6}$";
+                    readonly description: "An sRGB colour as `#rrggbb`, compared case-insensitively. A community SHOULD write it in lower case.";
+                };
+                readonly logoUrl: {
+                    readonly type: "string";
+                    readonly format: "uri";
+                    readonly pattern: "^https://";
+                    readonly maxLength: 2048;
+                    readonly description: "An https URL of the community's logo. Fetched by the client, so an untrusted image from wherever it points.";
+                };
+                readonly ext: {
+                    readonly $ref: "#/$defs/Ext";
+                };
+            };
+        };
+        readonly Response: {
+            readonly $anchor: "response";
+            readonly title: "VTC Join-Requests Manifest — response payload";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["communityDid", "criteria"];
+            readonly properties: {
+                readonly communityDid: {
+                    readonly type: "string";
+                    readonly pattern: "^did:";
+                };
+                readonly criteria: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/$defs/Criterion";
+                    };
+                };
+                readonly requestedAttributes: {
+                    readonly type: "array";
+                    readonly maxItems: 32;
+                    readonly description: "What the community asks an applicant to tell it about themselves, as claim types — never values. Answered in persona terms: the applicant's agent discloses those attributes from the face the applicant chooses, and they arrive on vtc/join-requests/submit as `attributes`. SELF-ASSERTED: a community MUST NOT describe an answer as verified, and MUST NOT make a decision that assumes it is. Outside every criterion, so no `requirementsDigest` covers it. Absent when the community asks nothing.";
+                    readonly items: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly required: readonly ["type"];
+                        readonly properties: {
+                            readonly type: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                                readonly maxLength: 128;
+                                readonly pattern: "^(x:)?[a-z][A-Za-z0-9]*(\\.[a-z][A-Za-z0-9]*)*$";
+                                readonly description: "A claim-type token from the persona claim-type registry (persona/_shared/0.1/CLAIM-TYPES.md) — `name.display`, `address.country` — or an `x:` extension token.";
+                            };
+                            readonly required: {
+                                readonly type: "boolean";
+                                readonly default: true;
+                                readonly description: "False for an attribute the applicant may decline. A submission missing a required one is refused with vtc/join-requests/submit:attributesMissing.";
+                            };
+                            readonly purpose: {
+                                readonly type: "string";
+                                readonly maxLength: 256;
+                                readonly description: "Why the community asks, in words shown to the applicant before they disclose.";
+                            };
+                        };
+                    };
+                };
+                readonly branding: {
+                    readonly $ref: "#/$defs/CommunityBranding";
+                };
+                readonly directoryDisclosure: {
+                    readonly $ref: "#/$defs/DirectoryDisclosure";
+                    readonly description: "Present exactly where the community offers a member directory: the statement, generated from its configuration, of what the directory would disclose about a member and to whom — the same statement vtc/directory/disclosure returns. Outside every criterion, so no `requirementsDigest` covers it; it names itself with its own `statementDigest`.";
+                };
+                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 DirectoryDisclosure: {
+            readonly title: "DirectoryDisclosure";
+            readonly description: "The statement itself. Every member is generated from the community's configuration when the statement is read. `statementDigest` names this exact statement, so an applicant can record which one it was shown.";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["fields", "newCard", "membershipIdentifiers", "adminNotes", "externalCards", "statementDigest"];
+            readonly properties: {
+                readonly fields: {
+                    readonly type: "array";
+                    readonly maxItems: 128;
+                    readonly items: {
+                        readonly $ref: "#/$defs/DisclosedField";
+                    };
+                    readonly description: "Every active field, base and community-defined, in display order. A base field the community has disabled is absent, which is how a reader learns it is not collected.";
+                };
+                readonly newCard: {
+                    readonly $ref: "#/$defs/NewCardDefaults";
+                };
+                readonly membershipIdentifiers: {
+                    readonly $ref: "#/$defs/Audience";
+                    readonly description: "The widest audience a member's membership identifier — the DID they joined with — can reach through the directory: the ceiling of the base field `did`, or `admins` where that field is disabled. `members` or `public` means a member may choose to show it that widely; a new card never shows it beyond `admins` (VTI-DIR-042). Administrators always see it.";
+                };
+                readonly adminNotes: {
+                    readonly type: "boolean";
+                    readonly description: "Whether administrators keep notes about members. Notes are never on a card and never reach another member; a member may ask for the notes about them.";
+                };
+                readonly groups: {
+                    readonly $ref: "#/$defs/GroupDisclosure";
+                };
+                readonly externalCards: {
+                    readonly type: "boolean";
+                    readonly description: "Whether a member may publish a card beyond the community: their `public` values, signed by them, offered through the community's trust registry. Always the member's own choice, and off on a new card. False where the community cannot publish external cards.";
+                };
+                readonly statementDigest: {
+                    readonly $ref: "#/$defs/DigestMultibase";
+                    readonly description: "Digest over the RFC 8785 (JCS) canonicalization of this statement with the `statementDigest` member removed, as a multibase-encoded multihash (SHA-256 and base58btc RECOMMENDED). Changes exactly when what the statement says changes.";
+                };
+                readonly ext: {
+                    readonly $ref: "#/$defs/Ext";
+                };
+            };
+        };
+        readonly GroupDisclosure: {
+            readonly title: "GroupDisclosure";
+            readonly description: "Present when the community has groups. A member of a group holds a credential, issued by the group's own identifier, that evidences their membership, and can present it outside the community — which is why an applicant is told.";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["credentialValidity"];
+            readonly properties: {
+                readonly credentialValidity: {
+                    readonly type: "string";
+                    readonly maxLength: 32;
+                    readonly pattern: "^P(([0-9]+W)?([0-9]+D)?T([0-9]+H([0-9]+M)?([0-9]+S)?|[0-9]+M([0-9]+S)?|[0-9]+S)|[0-9]+W([0-9]+D)?|[0-9]+D)$";
+                    readonly description: "How long each group membership credential is valid for, as an ISO 8601 duration in weeks, days, hours, minutes and seconds (`P30D`). It is renewed while the member stays in the group, and a credential already issued stays valid until it expires even after its holder leaves.";
+                };
+            };
+        };
+        readonly NewCardDefaults: {
+            readonly title: "NewCardDefaults";
+            readonly description: "The discoverability a card has when the community creates it, before its member chooses. A new card is never published beyond the community (VTI-DIR-042), so there is no member for that here: `externalCards` says whether the member may turn it on.";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["listing", "search"];
+            readonly properties: {
+                readonly listing: {
+                    readonly $ref: "#/$defs/Listing";
+                    readonly description: "The listing a new card starts with: the community's `defaultListing` (vtc/directory/fields/list). Every member may always choose `hidden`.";
+                };
+                readonly search: {
+                    readonly type: "string";
+                    readonly enum: readonly ["byName", "exactNickname", "off"];
+                    readonly description: "What a member's search may match, as the card's `discoverability.search`.";
+                };
+                readonly introductions: {
+                    readonly $ref: "#/$defs/Introductions";
+                    readonly description: "From whom a new card accepts introductions. Absent where the community does not deliver introductions.";
+                };
+            };
+        };
+        readonly Introductions: {
+            readonly title: "Introductions";
+            readonly description: "Who may ask the community to introduce them to this member. `anyone`: any active member who can find the entry. `groups`: only members who share a community group with them. `connections`: only members holding an attributed, in-force verified relationship with them. `off`: nobody. A refused introduction is never reported to its sender.";
+            readonly type: "string";
+            readonly enum: readonly ["anyone", "groups", "connections", "off"];
+        };
+        readonly Listing: {
+            readonly title: "Listing";
+            readonly description: "Whether members can find the entry. `listed`: it appears when members browse. `findable`: it does not appear when browsing, but a search that matches it under `search` returns it. `hidden`: no member finds it by browsing or searching; administrators still see it, and members who share a group that shows its members see it in that group's member list.";
+            readonly type: "string";
+            readonly enum: readonly ["listed", "findable", "hidden"];
+        };
+        readonly DisclosedField: {
+            readonly title: "DisclosedField";
+            readonly description: "One active field of the community's directory, as an applicant needs to see it: what it is, who writes its value, the widest audience it may ever reach and the audience a new card gives it. Disabled and retired fields are not listed: no projection shows them.";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["key", "label", "type", "source", "ceiling", "defaultVisibility", "searchable"];
+            readonly properties: {
+                readonly key: {
+                    readonly $ref: "#/$defs/FieldKey";
+                };
+                readonly label: {
+                    readonly $ref: "#/$defs/FieldLabel";
+                };
+                readonly description: {
+                    readonly $ref: "#/$defs/FieldDescription";
+                };
+                readonly type: {
+                    readonly $ref: "#/$defs/FieldType";
+                };
+                readonly source: {
+                    readonly $ref: "#/$defs/FieldSource";
+                    readonly description: "Who writes the value. `admin` and `credential` matter most to an applicant: an `admin` field holds what the community asserts about the member, which the member reads and cannot change.";
+                };
+                readonly ceiling: {
+                    readonly $ref: "#/$defs/Audience";
+                    readonly description: "The widest audience the field may ever reach, whatever the member chooses.";
+                };
+                readonly defaultVisibility: {
+                    readonly $ref: "#/$defs/Audience";
+                    readonly description: "The audience a new card gives the field until its member chooses. Never wider than `ceiling`.";
+                };
+                readonly searchable: {
+                    readonly type: "boolean";
+                    readonly description: "Whether a member's search may match the field, within what the searcher may see.";
+                };
+                readonly facet: {
+                    readonly type: "boolean";
+                    readonly description: "Whether members may filter on the field and see counts by its values. Absent: false.";
+                };
+            };
+        };
+        readonly Audience: {
+            readonly title: "Audience";
+            readonly description: "Who may see a directory field, ordered from narrowest to widest. `admins`: holders of `vtc.directory.admin` (and, for derived fields, `vtc.members.manage`). `groups`: members who share at least one community group with the subject (narrowed to the groups the subject names in `groupAudience`, where it names any). `connections`: members holding an attributed, in-force verified relationship with the subject at the community. `members`: every active member. `public`: anyone, and what the member's signed public card carries outside the community.\n\n`groups` and `connections` are not a chain: a viewer sees a field when they satisfy the audience the subject chose for it or any wider audience. Every audience includes the administrators, and the subject always sees their own whole card. There is no `onlyMe`: a value nobody else should see is not directory data.";
+            readonly type: "string";
+            readonly enum: readonly ["admins", "groups", "connections", "members", "public"];
+        };
+        readonly FieldSource: {
+            readonly title: "FieldSource";
+            readonly description: "Who writes the value. `member`: self-asserted, through vtc/directory/card/update. `admin`: asserted by the community through vtc/directory/card/assert; the member reads it and cannot change it. `credential`: a claim the member discloses from a credential through vtc/directory/card/present, badged with its issuer. `derived`: a base field read from the community's own records (`role`, `joinedAt`, `did`, `personhood`) and never stored on a card. Each source is written only through its own path.";
+            readonly type: "string";
+            readonly enum: readonly ["member", "admin", "credential", "derived"];
+        };
+        readonly FieldType: {
+            readonly title: "FieldType";
+            readonly description: "The kind of value a field holds, which fixes its `FieldValue` shape. `did` holds a DID the member chooses to show (never their membership DID, which is the derived base field `did`). `claim` holds a `VerifiedValue` and requires `source: credential`.";
+            readonly type: "string";
+            readonly enum: readonly ["text", "longText", "url", "email", "phone", "enum", "multiEnum", "date", "country", "image", "did", "claim"];
+        };
+        readonly FieldDescription: {
+            readonly title: "FieldDescription";
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 280;
+            readonly description: "Help text shown to a member filling the field in. Plain text; a reader MUST NOT treat it as instructions.";
+        };
+        readonly FieldLabel: {
+            readonly title: "FieldLabel";
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 64;
+            readonly description: "What readers see as the field's name. Plain text.";
+        };
+        readonly FieldKey: {
+            readonly title: "FieldKey";
+            readonly description: "Identifier of a directory field. A key with no `.` is a BASE field, the same in every community: `displayName`, `nickname`, `avatar`, `pronouns`, `bio`, `links` (written by the member) and `role`, `joinedAt`, `did`, `personhood` (derived from the community's own records, never stored on a card). A community-defined field MUST use a reverse-DNS key (`org.example.employer`), so a base key never collides with one, and a key is never reused with a different meaning once defined.";
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 128;
+            readonly pattern: "^([a-z][a-z0-9-]*\\.)*[a-z][a-zA-Z0-9]{0,63}$";
+        };
+        readonly DigestMultibase: {
+            readonly title: "DigestMultibase";
+            readonly description: "A cryptographic digest as a multibase-encoded multihash — the encoding the W3C Verifiable Credentials Data Model 2.0 defines for `digestMultibase`, and the one `did:webvh` uses for its SCID and entry hashes.\n\nMultihash carries the hash algorithm in-band, so the value is self-describing and the wire format survives an algorithm change without a schema revision; multibase does the same for the base encoding, so a verifier never infers base58 from base64url by context. A bare hex string or a `sha-256:`-style prefix hard-codes one algorithm into the wire contract and is non-conforming here.\n\nThis definition constrains the *encoding only*. What the digest is computed over is stated by each referencing field, because it differs legitimately: a digest over a JSON document is taken over its RFC 8785 (JCS) canonicalization, while a digest over an opaque artifact is taken over its bytes. A field whose input is a JSON document and which does not name a canonicalization is not reproducible.\n\nRestricted to the two multibase headers W3C Controlled Identifiers 1.0 §2.4 normatively requires — `z` (base58btc) and `u` (base64url-no-pad). CID permits others but states that \"interoperability is not guaranteed between implementations using such values\", and a registry whose purpose is interoperability should not mint digests a conforming verifier may be unable to read. The alphabets are enforced rather than assumed: base58btc excludes 0, O, I and l, and an earlier permissive pattern let three published examples carry digests that were not valid base58 at all. base58btc is RECOMMENDED, for consistency with `did:key` and `did:webvh`.";
+            readonly type: "string";
+            readonly minLength: 16;
+            readonly pattern: "^(z[1-9A-HJ-NP-Za-km-z]+|u[A-Za-z0-9_-]+)$";
+            readonly examples: readonly ["zQmbWqxBEKC3P8tqsKc98xmWNzrzDtRLMiMPL8wBuTGsMnR"];
+        };
+        readonly ExtCritical: {
+            readonly title: "ExtCritical";
+            readonly description: "Names the `ext` namespaces a consumer MUST understand or refuse, per SPEC.md §4.5.1.\n\nEvery entry MUST be an immediate key of the sibling `ext` object at the same level; an entry naming an absent namespace is non-conforming and the consumer rejects the document with `malformedRequest`. A consumer that does not recognize a namespace named here MUST NOT process the document as though the namespace were absent, and rejects it with `unsupportedExtension` — the exception to the rule that unrecognized namespaces are ignored.\n\nA producer marks a namespace only where the document's meaning depends on it. Marking one that merely carries a hint or an annotation turns every consumer that has not implemented it into a failure where it would otherwise have interoperated. JSON Schema cannot check either of those rules: that an entry names a present namespace is checkable only against the sibling `ext`, and whether a namespace is load-bearing is not a schema question at all. Both are consumer-side checks.";
+            readonly type: "array";
+            readonly minItems: 1;
+            readonly uniqueItems: true;
+            readonly items: {
+                readonly type: "string";
+                readonly pattern: "^[a-z][a-z0-9-]*(\\.[a-z0-9-]+)+$";
+            };
+            readonly examples: readonly [readonly ["org.openvtc.hidden-vetting"]];
+        };
+        readonly VettingRelationship: {
+            readonly title: "VettingRelationship";
+            readonly type: "string";
+            readonly enum: readonly ["none", "communityColleague", "sameEmployer", "family", "otherPersonal"];
+            readonly description: "The vetter's own declaration of how they relate to the applicant. Declared, not verified: it exists so community policy can cap how much evidence comes from people close to the applicant, and a false declaration is the vetter's attributable act.";
+        };
+        readonly ClaimType: {
+            readonly title: "ClaimType";
+            readonly description: "The vocabulary token naming what a value IS — `name.legal`, `phone.mobile`, `address.postal`, `person.birthDate`. Dotted, most-general segment first, so that a consumer with no knowledge of the specific token can still group by its prefix.\n\nThe token is the maintainer's own; no external vocabulary is primary. External vocabularies (vCard/jCard, OIDC standard claims, schema.org) are mappings applied at PRESENTATION by a renderer, not at rest, so that a query written in any of them can be matched without the store having to live inside any one of them.\n\nThe `x:` prefix is an open extension namespace and is not decoration. The closest prior art — Windows CardSpace's self-issued card — supported exactly fifteen predefined claim types with no extensibility, and that is the specific way it failed the requirement a holder actually has. An `x:` attribute stores, composes, binds and discloses exactly like a known one; it renders generically and matches only an explicit query.";
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 128;
+            readonly pattern: "^(x:)?[a-z][a-zA-Z0-9]*(\\.[a-z][a-zA-Z0-9]*)*$";
+        };
+        readonly VettingDocumentation: {
+            readonly title: "VettingDocumentation";
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 64;
+            readonly pattern: "^[a-z][a-zA-Z0-9]*$";
+            readonly description: "A class of documentation, named in lowerCamelCase. Open rather than enumerated, because what documentation a vetter accepts is each vetter's own choice. Well-known values: `passport`, `nationalId`, `driverLicence`, and `none` — the vetter will attest without a document, which is the `priorAcquaintance` case. Only the class ever travels — never a document number, an image, an issuing authority or an expiry date. `none` states a policy (what a vetter accepts); a record of what was relied on expresses 'no document' as an empty list instead.";
+        };
+        readonly VettingMethod: {
+            readonly title: "VettingMethod";
+            readonly type: "string";
+            readonly enum: readonly ["inPerson", "video", "priorAcquaintance"];
+            readonly description: "How the vetter established that the person they checked is the person controlling the applicant's DID. `inPerson` — both people were physically together. `video` — a live, two-way video call. `priorAcquaintance` — the vetter has known or worked with this person over a period, and attests from that knowledge rather than from a document. A method is a description of what happened, not an assurance level: which methods count, and how many of each, is community policy.";
+        };
+    };
+};
+/**
+ * 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, and
+ * item 2 needs the schema this carries.
+ */
+export declare const SPEC: {
+    readonly typeUri: "https://trusttasks.org/spec/vtc/join-requests/manifest/0.4";
+    readonly isBearer: false;
+    readonly isProofRequired: false;
+    readonly isRecipientRequired: true;
+    readonly isIssuedAtRequired: false;
+    readonly payloadSchema: {
+        readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+        readonly $id: "https://trusttasks.org/spec/vtc/join-requests/manifest/0.4";
+        readonly title: "VTC Join-Requests Manifest — payload";
+        readonly description: "Discover a community's join criteria before applying. The request carries nothing. Version 0.2 adds, per criterion, an optional `vetting` requirements object — how many identity-vetting statements a community needs, by which methods, from whom — and a `requirementsDigest` that names the exact version of the criterion an applicant started under. The response may also carry `branding`, how the community asks to be shown. Version 0.4 adds `directoryDisclosure`: where the community has a member directory, the statement of what it would disclose about a member and to whom, so an applicant reads it before applying.";
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly properties: {
+            readonly ext: {
+                readonly $ref: "#/$defs/Ext";
+            };
+        };
+        readonly $defs: {
+            readonly Duration: {
+                readonly title: "Duration";
+                readonly type: "string";
+                readonly maxLength: 32;
+                readonly pattern: "^P(([0-9]+W)?([0-9]+D)?T([0-9]+H([0-9]+M)?([0-9]+S)?|[0-9]+M([0-9]+S)?|[0-9]+S)|[0-9]+W([0-9]+D)?|[0-9]+D)$";
+                readonly description: "An ISO 8601 duration in weeks, days, hours, minutes and seconds only (e.g. `P120D`, `P2W`, `P1DT12H`, `PT15M`). Years and months are refused: their length depends on the calendar, and an age limit that means different things on different days is not a limit.";
+            };
+            readonly Criterion: {
+                readonly title: "Criterion";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["id", "admission", "requirementsDigest"];
+                readonly properties: {
+                    readonly id: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 128;
+                    };
+                    readonly description: {
+                        readonly type: "string";
+                        readonly maxLength: 1024;
+                        readonly description: "Plain-language summary of the criterion, authored by the community and shown to prospective applicants. Informative: where it and `vetting` disagree, `vetting` governs.";
+                    };
+                    readonly admission: {
+                        readonly type: "string";
+                        readonly enum: readonly ["automatic", "review"];
+                        readonly description: "How the community decides a submission that meets this criterion. `automatic`: it admits the applicant without a person deciding. `review`: it refers the submission to an administrator, who decides.";
+                    };
+                    readonly presentationDefinition: {
+                        readonly type: "object";
+                        readonly description: "The credentials an applicant must present for this criterion (opaque here). Absent: the criterion requires no credential.";
+                    };
+                    readonly credentialIssuers: {
+                        readonly type: "string";
+                        readonly enum: readonly ["any", "community", "recognised"];
+                        readonly description: "Whose credentials meet `presentationDefinition`: `community` (this community's own), `recognised` (this community's, or a community it recognises), or `any` (any issuer whose credential verifies). Present exactly when `presentationDefinition` is.";
+                    };
+                    readonly invitationRequired: {
+                        readonly type: "boolean";
+                        readonly description: "True: the criterion is met only by a submission carrying a valid, unconsumed invitation this community issued to the applicant.";
+                    };
+                    readonly vetting: {
+                        readonly $ref: "#/$defs/VettingRequirements";
+                    };
+                    readonly requirementsDigest: {
+                        readonly $ref: "#/$defs/DigestMultibase";
+                        readonly description: "Digest over the RFC 8785 (JCS) canonicalization of this criterion object with the `requirementsDigest` member removed, as a multibase-encoded multihash (SHA-256 and base58btc RECOMMENDED). Names one version of the criterion: an applicant records it when starting an application and echoes it to vetters and at submission.";
+                    };
+                };
+                readonly dependentRequired: {
+                    readonly presentationDefinition: readonly ["credentialIssuers"];
+                    readonly credentialIssuers: readonly ["presentationDefinition"];
+                };
+            };
+            readonly VettingRequirements: {
+                readonly title: "VettingRequirements";
+                readonly type: "object";
+                readonly additionalProperties: true;
+                readonly required: readonly ["version", "statementType", "minStatements", "acceptedMethods", "eligibleVetters"];
+                readonly description: "What identity-vetting evidence a criterion needs, beyond what a presentation-definition can express: distinct eligible vetters, per-method floors, independence caps. Every number is the community's own policy. This schema supplies no defaults — an absent optional member means the community imposes no constraint of that kind, never that some protocol value applies. Deliberately open: a consumer MUST ignore members it does not recognise, so a community publishing a newer shape does not make an older client unable to read the rest. Durations: `maxStatementAge` — a statement older than this at decision time does not count (absent: no limit beyond the statement's own validity); `decisionSla` — how long after submission the community undertakes to decide, including on a referred application; `requirementsGrace` — how long an application started under an earlier `requirementsDigest` is still evaluated under that version.";
+                readonly properties: {
+                    readonly version: {
+                        readonly type: "string";
+                        readonly pattern: "^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)$";
+                        readonly description: "Version of this requirements object's shape. `0.1` for the members defined here.";
+                    };
+                    readonly statementType: {
+                        readonly type: "string";
+                        readonly format: "uri";
+                        readonly minLength: 1;
+                        readonly maxLength: 512;
+                        readonly description: "The predicate IRI a counted vetting statement carries in `credentialSubject.predicate` — `https://registry.trustoverip.org/dtg/vsc/vetted/1`, the DTG VSC registry's identity-vetting predicate, or a predicate in a namespace the community controls — registered as one the community accepts via vtc/endorsement-types/register. A statement under any other predicate does not count.";
+                    };
+                    readonly minStatements: {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                        readonly description: "How many counted statements are needed, counting each vetter once however many DIDs they hold.";
+                    };
+                    readonly minByMethod: {
+                        readonly type: "object";
+                        readonly propertyNames: {
+                            readonly $ref: "#/$defs/VettingMethod";
+                        };
+                        readonly additionalProperties: {
+                            readonly type: "integer";
+                            readonly minimum: 0;
+                        };
+                        readonly description: "Per-method floors within `minStatements` — e.g. `{ \"inPerson\": 1 }`. Every method named MUST also be in `acceptedMethods`. Absent: no method floor.";
+                    };
+                    readonly acceptedMethods: {
+                        readonly type: "array";
+                        readonly minItems: 1;
+                        readonly uniqueItems: true;
+                        readonly items: {
+                            readonly $ref: "#/$defs/VettingMethod";
+                        };
+                        readonly description: "Methods whose statements count at all.";
+                    };
+                    readonly acceptedDocumentClasses: {
+                        readonly type: "array";
+                        readonly minItems: 1;
+                        readonly uniqueItems: true;
+                        readonly items: {
+                            readonly $ref: "#/$defs/VettingDocumentation";
+                        };
+                        readonly description: "Documentation a statement must have relied on in order to count. Absent — the expected case — means each vetter decides what documentation they accept, including none for prior acquaintance, and the community counts what they attest.";
+                    };
+                    readonly requiredClaims: {
+                        readonly type: "array";
+                        readonly uniqueItems: true;
+                        readonly items: {
+                            readonly $ref: "#/$defs/ClaimType";
+                        };
+                        readonly description: "Claim types the applicant's Vetting Card must carry, which the identity commitment is computed over, and which a counted statement must list as verified. Absent: none.";
+                    };
+                    readonly optionalClaims: {
+                        readonly type: "array";
+                        readonly uniqueItems: true;
+                        readonly items: {
+                            readonly $ref: "#/$defs/ClaimType";
+                        };
+                        readonly description: "Claim types an applicant MAY add to the card and a vetter MAY verify. They never affect whether a statement counts.";
+                    };
+                    readonly maxStatementAge: {
+                        readonly $ref: "#/$defs/Duration";
+                    };
+                    readonly eligibleVetters: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly required: readonly ["role"];
+                        readonly properties: {
+                            readonly role: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                                readonly maxLength: 128;
+                                readonly pattern: "^[a-zA-Z][a-zA-Z0-9_-]*$";
+                                readonly description: "The role a statement's issuer must hold, matched as the action `role:<role>` in a Verifiable Authority Credential (`AuthorityCredential`) the community issued to that issuer, whose `authority.scope` is the community's DID (see `vtc/vetting/vetters/grant/0.1`). A statement counts only if its issuer holds such a credential.";
+                            };
+                        };
+                        readonly description: "How a vetter's eligibility is established.";
+                    };
+                    readonly independence: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly properties: {
+                            readonly maxByDeclaredRelationship: {
+                                readonly type: "object";
+                                readonly propertyNames: {
+                                    readonly $ref: "#/$defs/VettingRelationship";
+                                };
+                                readonly additionalProperties: {
+                                    readonly type: "integer";
+                                    readonly minimum: 0;
+                                };
+                                readonly description: "The most counted statements that may come from vetters declaring each relationship — e.g. `{ \"family\": 0 }`.";
+                            };
+                            readonly requireConsistentIdentityCommitment: {
+                                readonly type: "boolean";
+                                readonly description: "When true, every counted statement must carry the same identity commitment — all vetters verified the same claimed identity. Absent: false.";
+                            };
+                        };
+                        readonly description: "Caps on how much evidence may come from people close to the applicant. Absent: no caps.";
+                    };
+                    readonly invitation: {
+                        readonly type: "string";
+                        readonly enum: readonly ["required", "optional", "none"];
+                        readonly description: "Whether an invitation credential must accompany the statements at submission (`required`), may (`optional`), or plays no part (`none`). Absent: the presentation-definition alone governs.";
+                    };
+                    readonly decisionSla: {
+                        readonly $ref: "#/$defs/Duration";
+                    };
+                    readonly requirementsGrace: {
+                        readonly $ref: "#/$defs/Duration";
+                    };
+                    readonly governanceFrameworkUrl: {
+                        readonly type: "string";
+                        readonly format: "uri";
+                        readonly pattern: "^https://";
+                        readonly maxLength: 2048;
+                        readonly description: "Where the community's vetting governance — including the attestation text vetters sign — is published.";
+                    };
+                    readonly ext: {
+                        readonly description: "Ecosystem-defined extension members per SPEC.md §4.5.1, for vetting parameters this version does not enumerate. A community publishing an admission mode the base members cannot express — the zero-knowledge parameters an applicant proves against, say — puts them under a namespace it controls, rather than waiting for a version that names them.\n\nThis object is already `additionalProperties: true`, so an unknown member here has always validated. That is not the same as reaching a consumer: a generated type names the members this schema declares and drops the rest, so an undeclared member is parsed and discarded, and it is discarded again on the re-serialization `requirementsDigest` is computed over. `ext` is a declared member, so it survives both.";
+                        readonly $ref: "#/$defs/Ext";
+                    };
+                    readonly extCritical: {
+                        readonly description: "Namespaces of `ext` an applicant MUST understand or refuse, per SPEC.md §4.5.1.\n\nA community marks a namespace here when applying under this criterion without understanding it would mean something other than what the community requires — an applicant that ignored a hidden-vetting namespace, for instance, would submit named statements to a criterion whose whole point was that it does not receive them. An applicant that does not recognize a marked namespace stops rather than downgrading silently.\n\nAbsent, which is the common case, every namespace under `ext` is advisory and ignorable.";
+                        readonly $ref: "#/$defs/ExtCritical";
+                    };
+                };
+            };
+            readonly CommunityBranding: {
+                readonly title: "CommunityBranding";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly description: "OPTIONAL. How the community asks to be shown to a prospective applicant: a name, an accent colour and a logo. Presentation only, self-asserted and unverified — `communityDid` identifies the community, never `branding`. Not part of any criterion, so not covered by a `requirementsDigest`. Every member is optional.";
+                readonly properties: {
+                    readonly displayName: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 128;
+                        readonly description: "The community's name as it asks to be shown.";
+                    };
+                    readonly accentColor: {
+                        readonly type: "string";
+                        readonly pattern: "^#[0-9a-fA-F]{6}$";
+                        readonly description: "An sRGB colour as `#rrggbb`, compared case-insensitively. A community SHOULD write it in lower case.";
+                    };
+                    readonly logoUrl: {
+                        readonly type: "string";
+                        readonly format: "uri";
+                        readonly pattern: "^https://";
+                        readonly maxLength: 2048;
+                        readonly description: "An https URL of the community's logo. Fetched by the client, so an untrusted image from wherever it points.";
+                    };
+                    readonly ext: {
+                        readonly $ref: "#/$defs/Ext";
+                    };
+                };
+            };
+            readonly Response: {
+                readonly $anchor: "response";
+                readonly title: "VTC Join-Requests Manifest — response payload";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["communityDid", "criteria"];
+                readonly properties: {
+                    readonly communityDid: {
+                        readonly type: "string";
+                        readonly pattern: "^did:";
+                    };
+                    readonly criteria: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly $ref: "#/$defs/Criterion";
+                        };
+                    };
+                    readonly requestedAttributes: {
+                        readonly type: "array";
+                        readonly maxItems: 32;
+                        readonly description: "What the community asks an applicant to tell it about themselves, as claim types — never values. Answered in persona terms: the applicant's agent discloses those attributes from the face the applicant chooses, and they arrive on vtc/join-requests/submit as `attributes`. SELF-ASSERTED: a community MUST NOT describe an answer as verified, and MUST NOT make a decision that assumes it is. Outside every criterion, so no `requirementsDigest` covers it. Absent when the community asks nothing.";
+                        readonly items: {
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                            readonly required: readonly ["type"];
+                            readonly properties: {
+                                readonly type: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                    readonly maxLength: 128;
+                                    readonly pattern: "^(x:)?[a-z][A-Za-z0-9]*(\\.[a-z][A-Za-z0-9]*)*$";
+                                    readonly description: "A claim-type token from the persona claim-type registry (persona/_shared/0.1/CLAIM-TYPES.md) — `name.display`, `address.country` — or an `x:` extension token.";
+                                };
+                                readonly required: {
+                                    readonly type: "boolean";
+                                    readonly default: true;
+                                    readonly description: "False for an attribute the applicant may decline. A submission missing a required one is refused with vtc/join-requests/submit:attributesMissing.";
+                                };
+                                readonly purpose: {
+                                    readonly type: "string";
+                                    readonly maxLength: 256;
+                                    readonly description: "Why the community asks, in words shown to the applicant before they disclose.";
+                                };
+                            };
+                        };
+                    };
+                    readonly branding: {
+                        readonly $ref: "#/$defs/CommunityBranding";
+                    };
+                    readonly directoryDisclosure: {
+                        readonly $ref: "#/$defs/DirectoryDisclosure";
+                        readonly description: "Present exactly where the community offers a member directory: the statement, generated from its configuration, of what the directory would disclose about a member and to whom — the same statement vtc/directory/disclosure returns. Outside every criterion, so no `requirementsDigest` covers it; it names itself with its own `statementDigest`.";
+                    };
+                    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 DirectoryDisclosure: {
+                readonly title: "DirectoryDisclosure";
+                readonly description: "The statement itself. Every member is generated from the community's configuration when the statement is read. `statementDigest` names this exact statement, so an applicant can record which one it was shown.";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["fields", "newCard", "membershipIdentifiers", "adminNotes", "externalCards", "statementDigest"];
+                readonly properties: {
+                    readonly fields: {
+                        readonly type: "array";
+                        readonly maxItems: 128;
+                        readonly items: {
+                            readonly $ref: "#/$defs/DisclosedField";
+                        };
+                        readonly description: "Every active field, base and community-defined, in display order. A base field the community has disabled is absent, which is how a reader learns it is not collected.";
+                    };
+                    readonly newCard: {
+                        readonly $ref: "#/$defs/NewCardDefaults";
+                    };
+                    readonly membershipIdentifiers: {
+                        readonly $ref: "#/$defs/Audience";
+                        readonly description: "The widest audience a member's membership identifier — the DID they joined with — can reach through the directory: the ceiling of the base field `did`, or `admins` where that field is disabled. `members` or `public` means a member may choose to show it that widely; a new card never shows it beyond `admins` (VTI-DIR-042). Administrators always see it.";
+                    };
+                    readonly adminNotes: {
+                        readonly type: "boolean";
+                        readonly description: "Whether administrators keep notes about members. Notes are never on a card and never reach another member; a member may ask for the notes about them.";
+                    };
+                    readonly groups: {
+                        readonly $ref: "#/$defs/GroupDisclosure";
+                    };
+                    readonly externalCards: {
+                        readonly type: "boolean";
+                        readonly description: "Whether a member may publish a card beyond the community: their `public` values, signed by them, offered through the community's trust registry. Always the member's own choice, and off on a new card. False where the community cannot publish external cards.";
+                    };
+                    readonly statementDigest: {
+                        readonly $ref: "#/$defs/DigestMultibase";
+                        readonly description: "Digest over the RFC 8785 (JCS) canonicalization of this statement with the `statementDigest` member removed, as a multibase-encoded multihash (SHA-256 and base58btc RECOMMENDED). Changes exactly when what the statement says changes.";
+                    };
+                    readonly ext: {
+                        readonly $ref: "#/$defs/Ext";
+                    };
+                };
+            };
+            readonly GroupDisclosure: {
+                readonly title: "GroupDisclosure";
+                readonly description: "Present when the community has groups. A member of a group holds a credential, issued by the group's own identifier, that evidences their membership, and can present it outside the community — which is why an applicant is told.";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["credentialValidity"];
+                readonly properties: {
+                    readonly credentialValidity: {
+                        readonly type: "string";
+                        readonly maxLength: 32;
+                        readonly pattern: "^P(([0-9]+W)?([0-9]+D)?T([0-9]+H([0-9]+M)?([0-9]+S)?|[0-9]+M([0-9]+S)?|[0-9]+S)|[0-9]+W([0-9]+D)?|[0-9]+D)$";
+                        readonly description: "How long each group membership credential is valid for, as an ISO 8601 duration in weeks, days, hours, minutes and seconds (`P30D`). It is renewed while the member stays in the group, and a credential already issued stays valid until it expires even after its holder leaves.";
+                    };
+                };
+            };
+            readonly NewCardDefaults: {
+                readonly title: "NewCardDefaults";
+                readonly description: "The discoverability a card has when the community creates it, before its member chooses. A new card is never published beyond the community (VTI-DIR-042), so there is no member for that here: `externalCards` says whether the member may turn it on.";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["listing", "search"];
+                readonly properties: {
+                    readonly listing: {
+                        readonly $ref: "#/$defs/Listing";
+                        readonly description: "The listing a new card starts with: the community's `defaultListing` (vtc/directory/fields/list). Every member may always choose `hidden`.";
+                    };
+                    readonly search: {
+                        readonly type: "string";
+                        readonly enum: readonly ["byName", "exactNickname", "off"];
+                        readonly description: "What a member's search may match, as the card's `discoverability.search`.";
+                    };
+                    readonly introductions: {
+                        readonly $ref: "#/$defs/Introductions";
+                        readonly description: "From whom a new card accepts introductions. Absent where the community does not deliver introductions.";
+                    };
+                };
+            };
+            readonly Introductions: {
+                readonly title: "Introductions";
+                readonly description: "Who may ask the community to introduce them to this member. `anyone`: any active member who can find the entry. `groups`: only members who share a community group with them. `connections`: only members holding an attributed, in-force verified relationship with them. `off`: nobody. A refused introduction is never reported to its sender.";
+                readonly type: "string";
+                readonly enum: readonly ["anyone", "groups", "connections", "off"];
+            };
+            readonly Listing: {
+                readonly title: "Listing";
+                readonly description: "Whether members can find the entry. `listed`: it appears when members browse. `findable`: it does not appear when browsing, but a search that matches it under `search` returns it. `hidden`: no member finds it by browsing or searching; administrators still see it, and members who share a group that shows its members see it in that group's member list.";
+                readonly type: "string";
+                readonly enum: readonly ["listed", "findable", "hidden"];
+            };
+            readonly DisclosedField: {
+                readonly title: "DisclosedField";
+                readonly description: "One active field of the community's directory, as an applicant needs to see it: what it is, who writes its value, the widest audience it may ever reach and the audience a new card gives it. Disabled and retired fields are not listed: no projection shows them.";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["key", "label", "type", "source", "ceiling", "defaultVisibility", "searchable"];
+                readonly properties: {
+                    readonly key: {
+                        readonly $ref: "#/$defs/FieldKey";
+                    };
+                    readonly label: {
+                        readonly $ref: "#/$defs/FieldLabel";
+                    };
+                    readonly description: {
+                        readonly $ref: "#/$defs/FieldDescription";
+                    };
+                    readonly type: {
+                        readonly $ref: "#/$defs/FieldType";
+                    };
+                    readonly source: {
+                        readonly $ref: "#/$defs/FieldSource";
+                        readonly description: "Who writes the value. `admin` and `credential` matter most to an applicant: an `admin` field holds what the community asserts about the member, which the member reads and cannot change.";
+                    };
+                    readonly ceiling: {
+                        readonly $ref: "#/$defs/Audience";
+                        readonly description: "The widest audience the field may ever reach, whatever the member chooses.";
+                    };
+                    readonly defaultVisibility: {
+                        readonly $ref: "#/$defs/Audience";
+                        readonly description: "The audience a new card gives the field until its member chooses. Never wider than `ceiling`.";
+                    };
+                    readonly searchable: {
+                        readonly type: "boolean";
+                        readonly description: "Whether a member's search may match the field, within what the searcher may see.";
+                    };
+                    readonly facet: {
+                        readonly type: "boolean";
+                        readonly description: "Whether members may filter on the field and see counts by its values. Absent: false.";
+                    };
+                };
+            };
+            readonly Audience: {
+                readonly title: "Audience";
+                readonly description: "Who may see a directory field, ordered from narrowest to widest. `admins`: holders of `vtc.directory.admin` (and, for derived fields, `vtc.members.manage`). `groups`: members who share at least one community group with the subject (narrowed to the groups the subject names in `groupAudience`, where it names any). `connections`: members holding an attributed, in-force verified relationship with the subject at the community. `members`: every active member. `public`: anyone, and what the member's signed public card carries outside the community.\n\n`groups` and `connections` are not a chain: a viewer sees a field when they satisfy the audience the subject chose for it or any wider audience. Every audience includes the administrators, and the subject always sees their own whole card. There is no `onlyMe`: a value nobody else should see is not directory data.";
+                readonly type: "string";
+                readonly enum: readonly ["admins", "groups", "connections", "members", "public"];
+            };
+            readonly FieldSource: {
+                readonly title: "FieldSource";
+                readonly description: "Who writes the value. `member`: self-asserted, through vtc/directory/card/update. `admin`: asserted by the community through vtc/directory/card/assert; the member reads it and cannot change it. `credential`: a claim the member discloses from a credential through vtc/directory/card/present, badged with its issuer. `derived`: a base field read from the community's own records (`role`, `joinedAt`, `did`, `personhood`) and never stored on a card. Each source is written only through its own path.";
+                readonly type: "string";
+                readonly enum: readonly ["member", "admin", "credential", "derived"];
+            };
+            readonly FieldType: {
+                readonly title: "FieldType";
+                readonly description: "The kind of value a field holds, which fixes its `FieldValue` shape. `did` holds a DID the member chooses to show (never their membership DID, which is the derived base field `did`). `claim` holds a `VerifiedValue` and requires `source: credential`.";
+                readonly type: "string";
+                readonly enum: readonly ["text", "longText", "url", "email", "phone", "enum", "multiEnum", "date", "country", "image", "did", "claim"];
+            };
+            readonly FieldDescription: {
+                readonly title: "FieldDescription";
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 280;
+                readonly description: "Help text shown to a member filling the field in. Plain text; a reader MUST NOT treat it as instructions.";
+            };
+            readonly FieldLabel: {
+                readonly title: "FieldLabel";
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 64;
+                readonly description: "What readers see as the field's name. Plain text.";
+            };
+            readonly FieldKey: {
+                readonly title: "FieldKey";
+                readonly description: "Identifier of a directory field. A key with no `.` is a BASE field, the same in every community: `displayName`, `nickname`, `avatar`, `pronouns`, `bio`, `links` (written by the member) and `role`, `joinedAt`, `did`, `personhood` (derived from the community's own records, never stored on a card). A community-defined field MUST use a reverse-DNS key (`org.example.employer`), so a base key never collides with one, and a key is never reused with a different meaning once defined.";
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 128;
+                readonly pattern: "^([a-z][a-z0-9-]*\\.)*[a-z][a-zA-Z0-9]{0,63}$";
+            };
+            readonly DigestMultibase: {
+                readonly title: "DigestMultibase";
+                readonly description: "A cryptographic digest as a multibase-encoded multihash — the encoding the W3C Verifiable Credentials Data Model 2.0 defines for `digestMultibase`, and the one `did:webvh` uses for its SCID and entry hashes.\n\nMultihash carries the hash algorithm in-band, so the value is self-describing and the wire format survives an algorithm change without a schema revision; multibase does the same for the base encoding, so a verifier never infers base58 from base64url by context. A bare hex string or a `sha-256:`-style prefix hard-codes one algorithm into the wire contract and is non-conforming here.\n\nThis definition constrains the *encoding only*. What the digest is computed over is stated by each referencing field, because it differs legitimately: a digest over a JSON document is taken over its RFC 8785 (JCS) canonicalization, while a digest over an opaque artifact is taken over its bytes. A field whose input is a JSON document and which does not name a canonicalization is not reproducible.\n\nRestricted to the two multibase headers W3C Controlled Identifiers 1.0 §2.4 normatively requires — `z` (base58btc) and `u` (base64url-no-pad). CID permits others but states that \"interoperability is not guaranteed between implementations using such values\", and a registry whose purpose is interoperability should not mint digests a conforming verifier may be unable to read. The alphabets are enforced rather than assumed: base58btc excludes 0, O, I and l, and an earlier permissive pattern let three published examples carry digests that were not valid base58 at all. base58btc is RECOMMENDED, for consistency with `did:key` and `did:webvh`.";
+                readonly type: "string";
+                readonly minLength: 16;
+                readonly pattern: "^(z[1-9A-HJ-NP-Za-km-z]+|u[A-Za-z0-9_-]+)$";
+                readonly examples: readonly ["zQmbWqxBEKC3P8tqsKc98xmWNzrzDtRLMiMPL8wBuTGsMnR"];
+            };
+            readonly ExtCritical: {
+                readonly title: "ExtCritical";
+                readonly description: "Names the `ext` namespaces a consumer MUST understand or refuse, per SPEC.md §4.5.1.\n\nEvery entry MUST be an immediate key of the sibling `ext` object at the same level; an entry naming an absent namespace is non-conforming and the consumer rejects the document with `malformedRequest`. A consumer that does not recognize a namespace named here MUST NOT process the document as though the namespace were absent, and rejects it with `unsupportedExtension` — the exception to the rule that unrecognized namespaces are ignored.\n\nA producer marks a namespace only where the document's meaning depends on it. Marking one that merely carries a hint or an annotation turns every consumer that has not implemented it into a failure where it would otherwise have interoperated. JSON Schema cannot check either of those rules: that an entry names a present namespace is checkable only against the sibling `ext`, and whether a namespace is load-bearing is not a schema question at all. Both are consumer-side checks.";
+                readonly type: "array";
+                readonly minItems: 1;
+                readonly uniqueItems: true;
+                readonly items: {
+                    readonly type: "string";
+                    readonly pattern: "^[a-z][a-z0-9-]*(\\.[a-z0-9-]+)+$";
+                };
+                readonly examples: readonly [readonly ["org.openvtc.hidden-vetting"]];
+            };
+            readonly VettingRelationship: {
+                readonly title: "VettingRelationship";
+                readonly type: "string";
+                readonly enum: readonly ["none", "communityColleague", "sameEmployer", "family", "otherPersonal"];
+                readonly description: "The vetter's own declaration of how they relate to the applicant. Declared, not verified: it exists so community policy can cap how much evidence comes from people close to the applicant, and a false declaration is the vetter's attributable act.";
+            };
+            readonly ClaimType: {
+                readonly title: "ClaimType";
+                readonly description: "The vocabulary token naming what a value IS — `name.legal`, `phone.mobile`, `address.postal`, `person.birthDate`. Dotted, most-general segment first, so that a consumer with no knowledge of the specific token can still group by its prefix.\n\nThe token is the maintainer's own; no external vocabulary is primary. External vocabularies (vCard/jCard, OIDC standard claims, schema.org) are mappings applied at PRESENTATION by a renderer, not at rest, so that a query written in any of them can be matched without the store having to live inside any one of them.\n\nThe `x:` prefix is an open extension namespace and is not decoration. The closest prior art — Windows CardSpace's self-issued card — supported exactly fifteen predefined claim types with no extensibility, and that is the specific way it failed the requirement a holder actually has. An `x:` attribute stores, composes, binds and discloses exactly like a known one; it renders generically and matches only an explicit query.";
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 128;
+                readonly pattern: "^(x:)?[a-z][a-zA-Z0-9]*(\\.[a-z][a-zA-Z0-9]*)*$";
+            };
+            readonly VettingDocumentation: {
+                readonly title: "VettingDocumentation";
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 64;
+                readonly pattern: "^[a-z][a-zA-Z0-9]*$";
+                readonly description: "A class of documentation, named in lowerCamelCase. Open rather than enumerated, because what documentation a vetter accepts is each vetter's own choice. Well-known values: `passport`, `nationalId`, `driverLicence`, and `none` — the vetter will attest without a document, which is the `priorAcquaintance` case. Only the class ever travels — never a document number, an image, an issuing authority or an expiry date. `none` states a policy (what a vetter accepts); a record of what was relied on expresses 'no document' as an empty list instead.";
+            };
+            readonly VettingMethod: {
+                readonly title: "VettingMethod";
+                readonly type: "string";
+                readonly enum: readonly ["inPerson", "video", "priorAcquaintance"];
+                readonly description: "How the vetter established that the person they checked is the person controlling the applicant's DID. `inPerson` — both people were physically together. `video` — a live, two-way video call. `priorAcquaintance` — the vetter has known or worked with this person over a period, and attests from that knowledge rather than from a document. A method is a description of what happened, not an assurance level: which methods count, and how many of each, is community policy.";
+            };
+        };
+    };
+};
+/**
+ * SPEC.md §7.2 policy for the success-response variant. `isRecipientRequired`
+ * tracks the *issuer* party's requirement because a response swaps the
+ * parties (§7.3 item 5).
+ */
+export declare const RESPONSE_SPEC: {
+    readonly typeUri: "https://trusttasks.org/spec/vtc/join-requests/manifest/0.4#response";
+    readonly isBearer: false;
+    readonly isProofRequired: false;
+    readonly isRecipientRequired: true;
+    readonly isIssuedAtRequired: false;
+    readonly payloadSchema: {
+        readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+        readonly $ref: "#/$defs/Response";
+        readonly $defs: {
+            readonly Duration: {
+                readonly title: "Duration";
+                readonly type: "string";
+                readonly maxLength: 32;
+                readonly pattern: "^P(([0-9]+W)?([0-9]+D)?T([0-9]+H([0-9]+M)?([0-9]+S)?|[0-9]+M([0-9]+S)?|[0-9]+S)|[0-9]+W([0-9]+D)?|[0-9]+D)$";
+                readonly description: "An ISO 8601 duration in weeks, days, hours, minutes and seconds only (e.g. `P120D`, `P2W`, `P1DT12H`, `PT15M`). Years and months are refused: their length depends on the calendar, and an age limit that means different things on different days is not a limit.";
+            };
+            readonly Criterion: {
+                readonly title: "Criterion";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["id", "admission", "requirementsDigest"];
+                readonly properties: {
+                    readonly id: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 128;
+                    };
+                    readonly description: {
+                        readonly type: "string";
+                        readonly maxLength: 1024;
+                        readonly description: "Plain-language summary of the criterion, authored by the community and shown to prospective applicants. Informative: where it and `vetting` disagree, `vetting` governs.";
+                    };
+                    readonly admission: {
+                        readonly type: "string";
+                        readonly enum: readonly ["automatic", "review"];
+                        readonly description: "How the community decides a submission that meets this criterion. `automatic`: it admits the applicant without a person deciding. `review`: it refers the submission to an administrator, who decides.";
+                    };
+                    readonly presentationDefinition: {
+                        readonly type: "object";
+                        readonly description: "The credentials an applicant must present for this criterion (opaque here). Absent: the criterion requires no credential.";
+                    };
+                    readonly credentialIssuers: {
+                        readonly type: "string";
+                        readonly enum: readonly ["any", "community", "recognised"];
+                        readonly description: "Whose credentials meet `presentationDefinition`: `community` (this community's own), `recognised` (this community's, or a community it recognises), or `any` (any issuer whose credential verifies). Present exactly when `presentationDefinition` is.";
+                    };
+                    readonly invitationRequired: {
+                        readonly type: "boolean";
+                        readonly description: "True: the criterion is met only by a submission carrying a valid, unconsumed invitation this community issued to the applicant.";
+                    };
+                    readonly vetting: {
+                        readonly $ref: "#/$defs/VettingRequirements";
+                    };
+                    readonly requirementsDigest: {
+                        readonly $ref: "#/$defs/DigestMultibase";
+                        readonly description: "Digest over the RFC 8785 (JCS) canonicalization of this criterion object with the `requirementsDigest` member removed, as a multibase-encoded multihash (SHA-256 and base58btc RECOMMENDED). Names one version of the criterion: an applicant records it when starting an application and echoes it to vetters and at submission.";
+                    };
+                };
+                readonly dependentRequired: {
+                    readonly presentationDefinition: readonly ["credentialIssuers"];
+                    readonly credentialIssuers: readonly ["presentationDefinition"];
+                };
+            };
+            readonly VettingRequirements: {
+                readonly title: "VettingRequirements";
+                readonly type: "object";
+                readonly additionalProperties: true;
+                readonly required: readonly ["version", "statementType", "minStatements", "acceptedMethods", "eligibleVetters"];
+                readonly description: "What identity-vetting evidence a criterion needs, beyond what a presentation-definition can express: distinct eligible vetters, per-method floors, independence caps. Every number is the community's own policy. This schema supplies no defaults — an absent optional member means the community imposes no constraint of that kind, never that some protocol value applies. Deliberately open: a consumer MUST ignore members it does not recognise, so a community publishing a newer shape does not make an older client unable to read the rest. Durations: `maxStatementAge` — a statement older than this at decision time does not count (absent: no limit beyond the statement's own validity); `decisionSla` — how long after submission the community undertakes to decide, including on a referred application; `requirementsGrace` — how long an application started under an earlier `requirementsDigest` is still evaluated under that version.";
+                readonly properties: {
+                    readonly version: {
+                        readonly type: "string";
+                        readonly pattern: "^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)$";
+                        readonly description: "Version of this requirements object's shape. `0.1` for the members defined here.";
+                    };
+                    readonly statementType: {
+                        readonly type: "string";
+                        readonly format: "uri";
+                        readonly minLength: 1;
+                        readonly maxLength: 512;
+                        readonly description: "The predicate IRI a counted vetting statement carries in `credentialSubject.predicate` — `https://registry.trustoverip.org/dtg/vsc/vetted/1`, the DTG VSC registry's identity-vetting predicate, or a predicate in a namespace the community controls — registered as one the community accepts via vtc/endorsement-types/register. A statement under any other predicate does not count.";
+                    };
+                    readonly minStatements: {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                        readonly description: "How many counted statements are needed, counting each vetter once however many DIDs they hold.";
+                    };
+                    readonly minByMethod: {
+                        readonly type: "object";
+                        readonly propertyNames: {
+                            readonly $ref: "#/$defs/VettingMethod";
+                        };
+                        readonly additionalProperties: {
+                            readonly type: "integer";
+                            readonly minimum: 0;
+                        };
+                        readonly description: "Per-method floors within `minStatements` — e.g. `{ \"inPerson\": 1 }`. Every method named MUST also be in `acceptedMethods`. Absent: no method floor.";
+                    };
+                    readonly acceptedMethods: {
+                        readonly type: "array";
+                        readonly minItems: 1;
+                        readonly uniqueItems: true;
+                        readonly items: {
+                            readonly $ref: "#/$defs/VettingMethod";
+                        };
+                        readonly description: "Methods whose statements count at all.";
+                    };
+                    readonly acceptedDocumentClasses: {
+                        readonly type: "array";
+                        readonly minItems: 1;
+                        readonly uniqueItems: true;
+                        readonly items: {
+                            readonly $ref: "#/$defs/VettingDocumentation";
+                        };
+                        readonly description: "Documentation a statement must have relied on in order to count. Absent — the expected case — means each vetter decides what documentation they accept, including none for prior acquaintance, and the community counts what they attest.";
+                    };
+                    readonly requiredClaims: {
+                        readonly type: "array";
+                        readonly uniqueItems: true;
+                        readonly items: {
+                            readonly $ref: "#/$defs/ClaimType";
+                        };
+                        readonly description: "Claim types the applicant's Vetting Card must carry, which the identity commitment is computed over, and which a counted statement must list as verified. Absent: none.";
+                    };
+                    readonly optionalClaims: {
+                        readonly type: "array";
+                        readonly uniqueItems: true;
+                        readonly items: {
+                            readonly $ref: "#/$defs/ClaimType";
+                        };
+                        readonly description: "Claim types an applicant MAY add to the card and a vetter MAY verify. They never affect whether a statement counts.";
+                    };
+                    readonly maxStatementAge: {
+                        readonly $ref: "#/$defs/Duration";
+                    };
+                    readonly eligibleVetters: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly required: readonly ["role"];
+                        readonly properties: {
+                            readonly role: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                                readonly maxLength: 128;
+                                readonly pattern: "^[a-zA-Z][a-zA-Z0-9_-]*$";
+                                readonly description: "The role a statement's issuer must hold, matched as the action `role:<role>` in a Verifiable Authority Credential (`AuthorityCredential`) the community issued to that issuer, whose `authority.scope` is the community's DID (see `vtc/vetting/vetters/grant/0.1`). A statement counts only if its issuer holds such a credential.";
+                            };
+                        };
+                        readonly description: "How a vetter's eligibility is established.";
+                    };
+                    readonly independence: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly properties: {
+                            readonly maxByDeclaredRelationship: {
+                                readonly type: "object";
+                                readonly propertyNames: {
+                                    readonly $ref: "#/$defs/VettingRelationship";
+                                };
+                                readonly additionalProperties: {
+                                    readonly type: "integer";
+                                    readonly minimum: 0;
+                                };
+                                readonly description: "The most counted statements that may come from vetters declaring each relationship — e.g. `{ \"family\": 0 }`.";
+                            };
+                            readonly requireConsistentIdentityCommitment: {
+                                readonly type: "boolean";
+                                readonly description: "When true, every counted statement must carry the same identity commitment — all vetters verified the same claimed identity. Absent: false.";
+                            };
+                        };
+                        readonly description: "Caps on how much evidence may come from people close to the applicant. Absent: no caps.";
+                    };
+                    readonly invitation: {
+                        readonly type: "string";
+                        readonly enum: readonly ["required", "optional", "none"];
+                        readonly description: "Whether an invitation credential must accompany the statements at submission (`required`), may (`optional`), or plays no part (`none`). Absent: the presentation-definition alone governs.";
+                    };
+                    readonly decisionSla: {
+                        readonly $ref: "#/$defs/Duration";
+                    };
+                    readonly requirementsGrace: {
+                        readonly $ref: "#/$defs/Duration";
+                    };
+                    readonly governanceFrameworkUrl: {
+                        readonly type: "string";
+                        readonly format: "uri";
+                        readonly pattern: "^https://";
+                        readonly maxLength: 2048;
+                        readonly description: "Where the community's vetting governance — including the attestation text vetters sign — is published.";
+                    };
+                    readonly ext: {
+                        readonly description: "Ecosystem-defined extension members per SPEC.md §4.5.1, for vetting parameters this version does not enumerate. A community publishing an admission mode the base members cannot express — the zero-knowledge parameters an applicant proves against, say — puts them under a namespace it controls, rather than waiting for a version that names them.\n\nThis object is already `additionalProperties: true`, so an unknown member here has always validated. That is not the same as reaching a consumer: a generated type names the members this schema declares and drops the rest, so an undeclared member is parsed and discarded, and it is discarded again on the re-serialization `requirementsDigest` is computed over. `ext` is a declared member, so it survives both.";
+                        readonly $ref: "#/$defs/Ext";
+                    };
+                    readonly extCritical: {
+                        readonly description: "Namespaces of `ext` an applicant MUST understand or refuse, per SPEC.md §4.5.1.\n\nA community marks a namespace here when applying under this criterion without understanding it would mean something other than what the community requires — an applicant that ignored a hidden-vetting namespace, for instance, would submit named statements to a criterion whose whole point was that it does not receive them. An applicant that does not recognize a marked namespace stops rather than downgrading silently.\n\nAbsent, which is the common case, every namespace under `ext` is advisory and ignorable.";
+                        readonly $ref: "#/$defs/ExtCritical";
+                    };
+                };
+            };
+            readonly CommunityBranding: {
+                readonly title: "CommunityBranding";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly description: "OPTIONAL. How the community asks to be shown to a prospective applicant: a name, an accent colour and a logo. Presentation only, self-asserted and unverified — `communityDid` identifies the community, never `branding`. Not part of any criterion, so not covered by a `requirementsDigest`. Every member is optional.";
+                readonly properties: {
+                    readonly displayName: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 128;
+                        readonly description: "The community's name as it asks to be shown.";
+                    };
+                    readonly accentColor: {
+                        readonly type: "string";
+                        readonly pattern: "^#[0-9a-fA-F]{6}$";
+                        readonly description: "An sRGB colour as `#rrggbb`, compared case-insensitively. A community SHOULD write it in lower case.";
+                    };
+                    readonly logoUrl: {
+                        readonly type: "string";
+                        readonly format: "uri";
+                        readonly pattern: "^https://";
+                        readonly maxLength: 2048;
+                        readonly description: "An https URL of the community's logo. Fetched by the client, so an untrusted image from wherever it points.";
+                    };
+                    readonly ext: {
+                        readonly $ref: "#/$defs/Ext";
+                    };
+                };
+            };
+            readonly Response: {
+                readonly $anchor: "response";
+                readonly title: "VTC Join-Requests Manifest — response payload";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["communityDid", "criteria"];
+                readonly properties: {
+                    readonly communityDid: {
+                        readonly type: "string";
+                        readonly pattern: "^did:";
+                    };
+                    readonly criteria: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly $ref: "#/$defs/Criterion";
+                        };
+                    };
+                    readonly requestedAttributes: {
+                        readonly type: "array";
+                        readonly maxItems: 32;
+                        readonly description: "What the community asks an applicant to tell it about themselves, as claim types — never values. Answered in persona terms: the applicant's agent discloses those attributes from the face the applicant chooses, and they arrive on vtc/join-requests/submit as `attributes`. SELF-ASSERTED: a community MUST NOT describe an answer as verified, and MUST NOT make a decision that assumes it is. Outside every criterion, so no `requirementsDigest` covers it. Absent when the community asks nothing.";
+                        readonly items: {
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                            readonly required: readonly ["type"];
+                            readonly properties: {
+                                readonly type: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                    readonly maxLength: 128;
+                                    readonly pattern: "^(x:)?[a-z][A-Za-z0-9]*(\\.[a-z][A-Za-z0-9]*)*$";
+                                    readonly description: "A claim-type token from the persona claim-type registry (persona/_shared/0.1/CLAIM-TYPES.md) — `name.display`, `address.country` — or an `x:` extension token.";
+                                };
+                                readonly required: {
+                                    readonly type: "boolean";
+                                    readonly default: true;
+                                    readonly description: "False for an attribute the applicant may decline. A submission missing a required one is refused with vtc/join-requests/submit:attributesMissing.";
+                                };
+                                readonly purpose: {
+                                    readonly type: "string";
+                                    readonly maxLength: 256;
+                                    readonly description: "Why the community asks, in words shown to the applicant before they disclose.";
+                                };
+                            };
+                        };
+                    };
+                    readonly branding: {
+                        readonly $ref: "#/$defs/CommunityBranding";
+                    };
+                    readonly directoryDisclosure: {
+                        readonly $ref: "#/$defs/DirectoryDisclosure";
+                        readonly description: "Present exactly where the community offers a member directory: the statement, generated from its configuration, of what the directory would disclose about a member and to whom — the same statement vtc/directory/disclosure returns. Outside every criterion, so no `requirementsDigest` covers it; it names itself with its own `statementDigest`.";
+                    };
+                    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 DirectoryDisclosure: {
+                readonly title: "DirectoryDisclosure";
+                readonly description: "The statement itself. Every member is generated from the community's configuration when the statement is read. `statementDigest` names this exact statement, so an applicant can record which one it was shown.";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["fields", "newCard", "membershipIdentifiers", "adminNotes", "externalCards", "statementDigest"];
+                readonly properties: {
+                    readonly fields: {
+                        readonly type: "array";
+                        readonly maxItems: 128;
+                        readonly items: {
+                            readonly $ref: "#/$defs/DisclosedField";
+                        };
+                        readonly description: "Every active field, base and community-defined, in display order. A base field the community has disabled is absent, which is how a reader learns it is not collected.";
+                    };
+                    readonly newCard: {
+                        readonly $ref: "#/$defs/NewCardDefaults";
+                    };
+                    readonly membershipIdentifiers: {
+                        readonly $ref: "#/$defs/Audience";
+                        readonly description: "The widest audience a member's membership identifier — the DID they joined with — can reach through the directory: the ceiling of the base field `did`, or `admins` where that field is disabled. `members` or `public` means a member may choose to show it that widely; a new card never shows it beyond `admins` (VTI-DIR-042). Administrators always see it.";
+                    };
+                    readonly adminNotes: {
+                        readonly type: "boolean";
+                        readonly description: "Whether administrators keep notes about members. Notes are never on a card and never reach another member; a member may ask for the notes about them.";
+                    };
+                    readonly groups: {
+                        readonly $ref: "#/$defs/GroupDisclosure";
+                    };
+                    readonly externalCards: {
+                        readonly type: "boolean";
+                        readonly description: "Whether a member may publish a card beyond the community: their `public` values, signed by them, offered through the community's trust registry. Always the member's own choice, and off on a new card. False where the community cannot publish external cards.";
+                    };
+                    readonly statementDigest: {
+                        readonly $ref: "#/$defs/DigestMultibase";
+                        readonly description: "Digest over the RFC 8785 (JCS) canonicalization of this statement with the `statementDigest` member removed, as a multibase-encoded multihash (SHA-256 and base58btc RECOMMENDED). Changes exactly when what the statement says changes.";
+                    };
+                    readonly ext: {
+                        readonly $ref: "#/$defs/Ext";
+                    };
+                };
+            };
+            readonly GroupDisclosure: {
+                readonly title: "GroupDisclosure";
+                readonly description: "Present when the community has groups. A member of a group holds a credential, issued by the group's own identifier, that evidences their membership, and can present it outside the community — which is why an applicant is told.";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["credentialValidity"];
+                readonly properties: {
+                    readonly credentialValidity: {
+                        readonly type: "string";
+                        readonly maxLength: 32;
+                        readonly pattern: "^P(([0-9]+W)?([0-9]+D)?T([0-9]+H([0-9]+M)?([0-9]+S)?|[0-9]+M([0-9]+S)?|[0-9]+S)|[0-9]+W([0-9]+D)?|[0-9]+D)$";
+                        readonly description: "How long each group membership credential is valid for, as an ISO 8601 duration in weeks, days, hours, minutes and seconds (`P30D`). It is renewed while the member stays in the group, and a credential already issued stays valid until it expires even after its holder leaves.";
+                    };
+                };
+            };
+            readonly NewCardDefaults: {
+                readonly title: "NewCardDefaults";
+                readonly description: "The discoverability a card has when the community creates it, before its member chooses. A new card is never published beyond the community (VTI-DIR-042), so there is no member for that here: `externalCards` says whether the member may turn it on.";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["listing", "search"];
+                readonly properties: {
+                    readonly listing: {
+                        readonly $ref: "#/$defs/Listing";
+                        readonly description: "The listing a new card starts with: the community's `defaultListing` (vtc/directory/fields/list). Every member may always choose `hidden`.";
+                    };
+                    readonly search: {
+                        readonly type: "string";
+                        readonly enum: readonly ["byName", "exactNickname", "off"];
+                        readonly description: "What a member's search may match, as the card's `discoverability.search`.";
+                    };
+                    readonly introductions: {
+                        readonly $ref: "#/$defs/Introductions";
+                        readonly description: "From whom a new card accepts introductions. Absent where the community does not deliver introductions.";
+                    };
+                };
+            };
+            readonly Introductions: {
+                readonly title: "Introductions";
+                readonly description: "Who may ask the community to introduce them to this member. `anyone`: any active member who can find the entry. `groups`: only members who share a community group with them. `connections`: only members holding an attributed, in-force verified relationship with them. `off`: nobody. A refused introduction is never reported to its sender.";
+                readonly type: "string";
+                readonly enum: readonly ["anyone", "groups", "connections", "off"];
+            };
+            readonly Listing: {
+                readonly title: "Listing";
+                readonly description: "Whether members can find the entry. `listed`: it appears when members browse. `findable`: it does not appear when browsing, but a search that matches it under `search` returns it. `hidden`: no member finds it by browsing or searching; administrators still see it, and members who share a group that shows its members see it in that group's member list.";
+                readonly type: "string";
+                readonly enum: readonly ["listed", "findable", "hidden"];
+            };
+            readonly DisclosedField: {
+                readonly title: "DisclosedField";
+                readonly description: "One active field of the community's directory, as an applicant needs to see it: what it is, who writes its value, the widest audience it may ever reach and the audience a new card gives it. Disabled and retired fields are not listed: no projection shows them.";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["key", "label", "type", "source", "ceiling", "defaultVisibility", "searchable"];
+                readonly properties: {
+                    readonly key: {
+                        readonly $ref: "#/$defs/FieldKey";
+                    };
+                    readonly label: {
+                        readonly $ref: "#/$defs/FieldLabel";
+                    };
+                    readonly description: {
+                        readonly $ref: "#/$defs/FieldDescription";
+                    };
+                    readonly type: {
+                        readonly $ref: "#/$defs/FieldType";
+                    };
+                    readonly source: {
+                        readonly $ref: "#/$defs/FieldSource";
+                        readonly description: "Who writes the value. `admin` and `credential` matter most to an applicant: an `admin` field holds what the community asserts about the member, which the member reads and cannot change.";
+                    };
+                    readonly ceiling: {
+                        readonly $ref: "#/$defs/Audience";
+                        readonly description: "The widest audience the field may ever reach, whatever the member chooses.";
+                    };
+                    readonly defaultVisibility: {
+                        readonly $ref: "#/$defs/Audience";
+                        readonly description: "The audience a new card gives the field until its member chooses. Never wider than `ceiling`.";
+                    };
+                    readonly searchable: {
+                        readonly type: "boolean";
+                        readonly description: "Whether a member's search may match the field, within what the searcher may see.";
+                    };
+                    readonly facet: {
+                        readonly type: "boolean";
+                        readonly description: "Whether members may filter on the field and see counts by its values. Absent: false.";
+                    };
+                };
+            };
+            readonly Audience: {
+                readonly title: "Audience";
+                readonly description: "Who may see a directory field, ordered from narrowest to widest. `admins`: holders of `vtc.directory.admin` (and, for derived fields, `vtc.members.manage`). `groups`: members who share at least one community group with the subject (narrowed to the groups the subject names in `groupAudience`, where it names any). `connections`: members holding an attributed, in-force verified relationship with the subject at the community. `members`: every active member. `public`: anyone, and what the member's signed public card carries outside the community.\n\n`groups` and `connections` are not a chain: a viewer sees a field when they satisfy the audience the subject chose for it or any wider audience. Every audience includes the administrators, and the subject always sees their own whole card. There is no `onlyMe`: a value nobody else should see is not directory data.";
+                readonly type: "string";
+                readonly enum: readonly ["admins", "groups", "connections", "members", "public"];
+            };
+            readonly FieldSource: {
+                readonly title: "FieldSource";
+                readonly description: "Who writes the value. `member`: self-asserted, through vtc/directory/card/update. `admin`: asserted by the community through vtc/directory/card/assert; the member reads it and cannot change it. `credential`: a claim the member discloses from a credential through vtc/directory/card/present, badged with its issuer. `derived`: a base field read from the community's own records (`role`, `joinedAt`, `did`, `personhood`) and never stored on a card. Each source is written only through its own path.";
+                readonly type: "string";
+                readonly enum: readonly ["member", "admin", "credential", "derived"];
+            };
+            readonly FieldType: {
+                readonly title: "FieldType";
+                readonly description: "The kind of value a field holds, which fixes its `FieldValue` shape. `did` holds a DID the member chooses to show (never their membership DID, which is the derived base field `did`). `claim` holds a `VerifiedValue` and requires `source: credential`.";
+                readonly type: "string";
+                readonly enum: readonly ["text", "longText", "url", "email", "phone", "enum", "multiEnum", "date", "country", "image", "did", "claim"];
+            };
+            readonly FieldDescription: {
+                readonly title: "FieldDescription";
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 280;
+                readonly description: "Help text shown to a member filling the field in. Plain text; a reader MUST NOT treat it as instructions.";
+            };
+            readonly FieldLabel: {
+                readonly title: "FieldLabel";
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 64;
+                readonly description: "What readers see as the field's name. Plain text.";
+            };
+            readonly FieldKey: {
+                readonly title: "FieldKey";
+                readonly description: "Identifier of a directory field. A key with no `.` is a BASE field, the same in every community: `displayName`, `nickname`, `avatar`, `pronouns`, `bio`, `links` (written by the member) and `role`, `joinedAt`, `did`, `personhood` (derived from the community's own records, never stored on a card). A community-defined field MUST use a reverse-DNS key (`org.example.employer`), so a base key never collides with one, and a key is never reused with a different meaning once defined.";
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 128;
+                readonly pattern: "^([a-z][a-z0-9-]*\\.)*[a-z][a-zA-Z0-9]{0,63}$";
+            };
+            readonly DigestMultibase: {
+                readonly title: "DigestMultibase";
+                readonly description: "A cryptographic digest as a multibase-encoded multihash — the encoding the W3C Verifiable Credentials Data Model 2.0 defines for `digestMultibase`, and the one `did:webvh` uses for its SCID and entry hashes.\n\nMultihash carries the hash algorithm in-band, so the value is self-describing and the wire format survives an algorithm change without a schema revision; multibase does the same for the base encoding, so a verifier never infers base58 from base64url by context. A bare hex string or a `sha-256:`-style prefix hard-codes one algorithm into the wire contract and is non-conforming here.\n\nThis definition constrains the *encoding only*. What the digest is computed over is stated by each referencing field, because it differs legitimately: a digest over a JSON document is taken over its RFC 8785 (JCS) canonicalization, while a digest over an opaque artifact is taken over its bytes. A field whose input is a JSON document and which does not name a canonicalization is not reproducible.\n\nRestricted to the two multibase headers W3C Controlled Identifiers 1.0 §2.4 normatively requires — `z` (base58btc) and `u` (base64url-no-pad). CID permits others but states that \"interoperability is not guaranteed between implementations using such values\", and a registry whose purpose is interoperability should not mint digests a conforming verifier may be unable to read. The alphabets are enforced rather than assumed: base58btc excludes 0, O, I and l, and an earlier permissive pattern let three published examples carry digests that were not valid base58 at all. base58btc is RECOMMENDED, for consistency with `did:key` and `did:webvh`.";
+                readonly type: "string";
+                readonly minLength: 16;
+                readonly pattern: "^(z[1-9A-HJ-NP-Za-km-z]+|u[A-Za-z0-9_-]+)$";
+                readonly examples: readonly ["zQmbWqxBEKC3P8tqsKc98xmWNzrzDtRLMiMPL8wBuTGsMnR"];
+            };
+            readonly ExtCritical: {
+                readonly title: "ExtCritical";
+                readonly description: "Names the `ext` namespaces a consumer MUST understand or refuse, per SPEC.md §4.5.1.\n\nEvery entry MUST be an immediate key of the sibling `ext` object at the same level; an entry naming an absent namespace is non-conforming and the consumer rejects the document with `malformedRequest`. A consumer that does not recognize a namespace named here MUST NOT process the document as though the namespace were absent, and rejects it with `unsupportedExtension` — the exception to the rule that unrecognized namespaces are ignored.\n\nA producer marks a namespace only where the document's meaning depends on it. Marking one that merely carries a hint or an annotation turns every consumer that has not implemented it into a failure where it would otherwise have interoperated. JSON Schema cannot check either of those rules: that an entry names a present namespace is checkable only against the sibling `ext`, and whether a namespace is load-bearing is not a schema question at all. Both are consumer-side checks.";
+                readonly type: "array";
+                readonly minItems: 1;
+                readonly uniqueItems: true;
+                readonly items: {
+                    readonly type: "string";
+                    readonly pattern: "^[a-z][a-z0-9-]*(\\.[a-z0-9-]+)+$";
+                };
+                readonly examples: readonly [readonly ["org.openvtc.hidden-vetting"]];
+            };
+            readonly VettingRelationship: {
+                readonly title: "VettingRelationship";
+                readonly type: "string";
+                readonly enum: readonly ["none", "communityColleague", "sameEmployer", "family", "otherPersonal"];
+                readonly description: "The vetter's own declaration of how they relate to the applicant. Declared, not verified: it exists so community policy can cap how much evidence comes from people close to the applicant, and a false declaration is the vetter's attributable act.";
+            };
+            readonly ClaimType: {
+                readonly title: "ClaimType";
+                readonly description: "The vocabulary token naming what a value IS — `name.legal`, `phone.mobile`, `address.postal`, `person.birthDate`. Dotted, most-general segment first, so that a consumer with no knowledge of the specific token can still group by its prefix.\n\nThe token is the maintainer's own; no external vocabulary is primary. External vocabularies (vCard/jCard, OIDC standard claims, schema.org) are mappings applied at PRESENTATION by a renderer, not at rest, so that a query written in any of them can be matched without the store having to live inside any one of them.\n\nThe `x:` prefix is an open extension namespace and is not decoration. The closest prior art — Windows CardSpace's self-issued card — supported exactly fifteen predefined claim types with no extensibility, and that is the specific way it failed the requirement a holder actually has. An `x:` attribute stores, composes, binds and discloses exactly like a known one; it renders generically and matches only an explicit query.";
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 128;
+                readonly pattern: "^(x:)?[a-z][a-zA-Z0-9]*(\\.[a-z][a-zA-Z0-9]*)*$";
+            };
+            readonly VettingDocumentation: {
+                readonly title: "VettingDocumentation";
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 64;
+                readonly pattern: "^[a-z][a-zA-Z0-9]*$";
+                readonly description: "A class of documentation, named in lowerCamelCase. Open rather than enumerated, because what documentation a vetter accepts is each vetter's own choice. Well-known values: `passport`, `nationalId`, `driverLicence`, and `none` — the vetter will attest without a document, which is the `priorAcquaintance` case. Only the class ever travels — never a document number, an image, an issuing authority or an expiry date. `none` states a policy (what a vetter accepts); a record of what was relied on expresses 'no document' as an empty list instead.";
+            };
+            readonly VettingMethod: {
+                readonly title: "VettingMethod";
+                readonly type: "string";
+                readonly enum: readonly ["inPerson", "video", "priorAcquaintance"];
+                readonly description: "How the vetter established that the person they checked is the person controlling the applicant's DID. `inPerson` — both people were physically together. `video` — a live, two-way video call. `priorAcquaintance` — the vetter has known or worked with this person over a period, and attests from that knowledge rather than from a document. A method is a description of what happened, not an assurance level: which methods count, and how many of each, is community policy.";
+            };
+        };
+    };
+};
+//# sourceMappingURL=payload.d.ts.map