@openvtc/trust-tasks 0.17.5 → 0.17.6

package/dist/persona/claim-types/list/1.0/payload.d.ts

@@ -0,0 +1,772 @@
+/**
+ * Generated by scripts/build-ts-bindings.mjs — DO NOT EDIT BY HAND.
+ * Source: specs/persona/claim-types/list/1.0/payload.schema.json
+ */
+import type { ClaimType, Ext, ReleaseRequirement, Sensitivity } from "../../../../_shared/components.js";
+/**
+ * Serve the claim-type registry this agent resolves against. A client that cannot read the table has to ship a copy of it, and a copy is a re-sync obligation on every change.
+ */
+export interface PersonaClaimTypesListPayload {
+    ext?: Ext;
+}
+/**
+ * Success response to persona/claim-types/list. Type https://trusttasks.org/spec/persona/claim-types/list/1.0#response.
+ */
+export interface PersonaClaimTypesListResponsePayload {
+    /**
+     * Version of the core registry this agent implements — the version of _shared/claim-types.json, not of this task. A client caching the table keys the cache on this.
+     */
+    registryVersion: string;
+    /**
+     * The registered tokens. Both exact tokens and family prefixes appear here, undistinguished: which one an entry is follows from whether a given token equals it or descends from it, and marking them would invite a client to walk only one kind.
+     *
+     * @maxItems 512
+     */
+    entries: {
+        type: ClaimType;
+        sensitivity: Sensitivity;
+        release: ReleaseRequirement;
+        /**
+         * Mask style, independent of sensitivity: any style that is not `none` is masked on screen whatever the sensitivity. Named rather than enumerated inline so a maintainer may serve a style this version does not list; a client that does not recognise a style MUST treat it as `full` rather than as `none`.
+         */
+        mask: string;
+        /**
+         * Marks a type a community may ask for without it being remarkable. The minimum set contains only normal-sensitivity, consent-release types; that is a rule rather than a coincidence.
+         */
+        minimumSet?: boolean;
+        /**
+         * OIDC standard claims this type answers. A recorded mapping, applied at presentation — the token stays the maintainer's own and no external vocabulary is primary.
+         *
+         * @maxItems 16
+         */
+        oidc?: [] | [string] | [string, string] | [string, string, string] | [string, string, string, string] | [string, string, string, string, string] | [string, string, string, string, string, string] | [string, string, string, string, string, string, string] | [string, string, string, string, string, string, string, string] | [string, string, string, string, string, string, string, string, string] | [string, string, string, string, string, string, string, string, string, string] | [string, string, string, string, string, string, string, string, string, string, string] | [string, string, string, string, string, string, string, string, string, string, string, string] | [string, string, string, string, string, string, string, string, string, string, string, string, string] | [string, string, string, string, string, string, string, string, string, string, string, string, string, string] | [
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string
+        ] | [
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string
+        ];
+    }[];
+    /**
+     * The floor: what a token with no entry and no registered prefix resolves to. Served rather than assumed, because a client that hard-codes it cannot be tightened by a maintainer that raises it.
+     */
+    unregistered: {
+        sensitivity: Sensitivity;
+        release: ReleaseRequirement;
+        mask: string;
+    };
+    /**
+     * Each axis ordered MOST PROTECTIVE FIRST. This is what makes rule 3 computable by a client: resolution takes the longest registered prefix and the unregistered floor and keeps whichever is more protective, which requires an ordering the client did not invent.
+     */
+    strictness: {
+        /**
+         * @maxItems 8
+         */
+        sensitivity: [] | [string] | [string, string] | [string, string, string] | [string, string, string, string] | [string, string, string, string, string] | [string, string, string, string, string, string] | [string, string, string, string, string, string, string] | [string, string, string, string, string, string, string, string];
+        /**
+         * @maxItems 8
+         */
+        release: [] | [string] | [string, string] | [string, string, string] | [string, string, string, string] | [string, string, string, string, string] | [string, string, string, string, string, string] | [string, string, string, string, string, string, string] | [string, string, string, string, string, string, string, string];
+        /**
+         * @maxItems 16
+         */
+        mask: [] | [string] | [string, string] | [string, string, string] | [string, string, string, string] | [string, string, string, string, string] | [string, string, string, string, string, string] | [string, string, string, string, string, string, string] | [string, string, string, string, string, string, string, string] | [string, string, string, string, string, string, string, string, string] | [string, string, string, string, string, string, string, string, string, string] | [string, string, string, string, string, string, string, string, string, string, string] | [string, string, string, string, string, string, string, string, string, string, string, string] | [string, string, string, string, string, string, string, string, string, string, string, string, string] | [string, string, string, string, string, string, string, string, string, string, string, string, string, string] | [
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string
+        ] | [
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string
+        ];
+    };
+    ext?: Ext;
+}
+/** Shared definitions this specification references, re-exported under the names it used to declare them with. */
+export type { ClaimType, Ext, ReleaseRequirement, Sensitivity };
+/** Trust Task type URI. */
+export declare const TYPE_URI: "https://trusttasks.org/spec/persona/claim-types/list/1.0";
+/** Stable alias for this specification's request payload shape. */
+export type Payload = PersonaClaimTypesListPayload;
+/** Trust Task response type URI (request type URI + "#response"). */
+export declare const RESPONSE_TYPE_URI: "https://trusttasks.org/spec/persona/claim-types/list/1.0#response";
+/** Stable alias for this specification's success-response payload shape. */
+export type Response = PersonaClaimTypesListResponsePayload;
+/**
+ * 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/persona/claim-types/list/1.0";
+    readonly title: "Persona Claim Types List — payload";
+    readonly description: "Serve the claim-type registry this agent resolves against. A client that cannot read the table has to ship a copy of it, and a copy is a re-sync obligation on every change.";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly properties: {
+        readonly ext: {
+            readonly $ref: "#/$defs/Ext";
+        };
+    };
+    readonly $defs: {
+        readonly Response: {
+            readonly $anchor: "response";
+            readonly title: "Persona Claim Types List — response payload";
+            readonly description: "Success response to persona/claim-types/list. Type https://trusttasks.org/spec/persona/claim-types/list/1.0#response.";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["registryVersion", "entries", "unregistered", "strictness"];
+            readonly properties: {
+                readonly registryVersion: {
+                    readonly type: "string";
+                    readonly maxLength: 32;
+                    readonly description: "Version of the core registry this agent implements — the version of _shared/claim-types.json, not of this task. A client caching the table keys the cache on this.";
+                };
+                readonly entries: {
+                    readonly type: "array";
+                    readonly maxItems: 512;
+                    readonly description: "The registered tokens. Both exact tokens and family prefixes appear here, undistinguished: which one an entry is follows from whether a given token equals it or descends from it, and marking them would invite a client to walk only one kind.";
+                    readonly items: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly required: readonly ["type", "sensitivity", "release", "mask"];
+                        readonly properties: {
+                            readonly type: {
+                                readonly $ref: "#/$defs/ClaimType";
+                            };
+                            readonly sensitivity: {
+                                readonly $ref: "#/$defs/Sensitivity";
+                            };
+                            readonly release: {
+                                readonly $ref: "#/$defs/ReleaseRequirement";
+                            };
+                            readonly mask: {
+                                readonly type: "string";
+                                readonly maxLength: 32;
+                                readonly description: "Mask style, independent of sensitivity: any style that is not `none` is masked on screen whatever the sensitivity. Named rather than enumerated inline so a maintainer may serve a style this version does not list; a client that does not recognise a style MUST treat it as `full` rather than as `none`.";
+                            };
+                            readonly minimumSet: {
+                                readonly type: "boolean";
+                                readonly description: "Marks a type a community may ask for without it being remarkable. The minimum set contains only normal-sensitivity, consent-release types; that is a rule rather than a coincidence.";
+                            };
+                            readonly oidc: {
+                                readonly type: "array";
+                                readonly maxItems: 16;
+                                readonly items: {
+                                    readonly type: "string";
+                                    readonly maxLength: 64;
+                                };
+                                readonly description: "OIDC standard claims this type answers. A recorded mapping, applied at presentation — the token stays the maintainer's own and no external vocabulary is primary.";
+                            };
+                        };
+                    };
+                };
+                readonly unregistered: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly required: readonly ["sensitivity", "release", "mask"];
+                    readonly description: "The floor: what a token with no entry and no registered prefix resolves to. Served rather than assumed, because a client that hard-codes it cannot be tightened by a maintainer that raises it.";
+                    readonly properties: {
+                        readonly sensitivity: {
+                            readonly $ref: "#/$defs/Sensitivity";
+                        };
+                        readonly release: {
+                            readonly $ref: "#/$defs/ReleaseRequirement";
+                        };
+                        readonly mask: {
+                            readonly type: "string";
+                            readonly maxLength: 32;
+                        };
+                    };
+                };
+                readonly strictness: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly required: readonly ["sensitivity", "release", "mask"];
+                    readonly description: "Each axis ordered MOST PROTECTIVE FIRST. This is what makes rule 3 computable by a client: resolution takes the longest registered prefix and the unregistered floor and keeps whichever is more protective, which requires an ordering the client did not invent.";
+                    readonly properties: {
+                        readonly sensitivity: {
+                            readonly type: "array";
+                            readonly maxItems: 8;
+                            readonly items: {
+                                readonly type: "string";
+                                readonly maxLength: 32;
+                            };
+                        };
+                        readonly release: {
+                            readonly type: "array";
+                            readonly maxItems: 8;
+                            readonly items: {
+                                readonly type: "string";
+                                readonly maxLength: 32;
+                            };
+                        };
+                        readonly mask: {
+                            readonly type: "array";
+                            readonly maxItems: 16;
+                            readonly items: {
+                                readonly type: "string";
+                                readonly maxLength: 32;
+                            };
+                        };
+                    };
+                };
+                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 ReleaseRequirement: {
+            readonly title: "ReleaseRequirement";
+            readonly description: "What it takes to let a value LEAVE. Distinct from `Sensitivity`, which governs showing it to the holder.\n\n`consent` is the ordinary gate: `persona/disclosure/preview` renders what would leave and `persona/disclosure/present` releases it, so a human sees it once.\n\n`stepUp` additionally requires a fresh authentication bound to THAT preview — not to the session. Without the binding, \"each time\" degrades into \"once per login\", which is the failure the requirement exists to prevent; the single-use `previewId` the preview already mints is what an implementation binds to. A maintainer MUST refuse `persona/disclosure/present` for a `stepUp` attribute when no such approval accompanies it.\n\nAbsent means *not decided by the holder* and resolves from the claim-type registry, which defaults `payment.*` and `gov.*` to `stepUp`.";
+            readonly type: "string";
+            readonly enum: readonly ["consent", "stepUp"];
+        };
+        readonly Sensitivity: {
+            readonly title: "Sensitivity";
+            readonly description: "How carefully a value is shown TO ITS OWN HOLDER. `high` means a consumer masks it by default, reveals it one attribute at a time on a deliberate act, and — the half that is not cosmetic — omits it from a listing that did not ask for sensitive values.\n\nAbsent means *not decided by the holder*, not `normal`: a consumer resolves it from the claim-type registry (see CLAIM-TYPES.md §4), which is why this member is optional and why an unregistered token resolves conservatively rather than permissively.\n\nDistinct from how linkable the value is. A payment card is highly sensitive and barely linkable — every card number is unique, so knowing one tells a second verifier nothing about the first. Reading either as a proxy for the other produces a consumer that hides the wrong things.";
+            readonly type: "string";
+            readonly enum: readonly ["normal", "high"];
+        };
+        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]*)*$";
+        };
+    };
+};
+/** As {@link PAYLOAD_SCHEMA}, for the success-response variant. */
+export declare const RESPONSE_PAYLOAD_SCHEMA: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $ref: "#/$defs/Response";
+    readonly $defs: {
+        readonly Response: {
+            readonly $anchor: "response";
+            readonly title: "Persona Claim Types List — response payload";
+            readonly description: "Success response to persona/claim-types/list. Type https://trusttasks.org/spec/persona/claim-types/list/1.0#response.";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["registryVersion", "entries", "unregistered", "strictness"];
+            readonly properties: {
+                readonly registryVersion: {
+                    readonly type: "string";
+                    readonly maxLength: 32;
+                    readonly description: "Version of the core registry this agent implements — the version of _shared/claim-types.json, not of this task. A client caching the table keys the cache on this.";
+                };
+                readonly entries: {
+                    readonly type: "array";
+                    readonly maxItems: 512;
+                    readonly description: "The registered tokens. Both exact tokens and family prefixes appear here, undistinguished: which one an entry is follows from whether a given token equals it or descends from it, and marking them would invite a client to walk only one kind.";
+                    readonly items: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly required: readonly ["type", "sensitivity", "release", "mask"];
+                        readonly properties: {
+                            readonly type: {
+                                readonly $ref: "#/$defs/ClaimType";
+                            };
+                            readonly sensitivity: {
+                                readonly $ref: "#/$defs/Sensitivity";
+                            };
+                            readonly release: {
+                                readonly $ref: "#/$defs/ReleaseRequirement";
+                            };
+                            readonly mask: {
+                                readonly type: "string";
+                                readonly maxLength: 32;
+                                readonly description: "Mask style, independent of sensitivity: any style that is not `none` is masked on screen whatever the sensitivity. Named rather than enumerated inline so a maintainer may serve a style this version does not list; a client that does not recognise a style MUST treat it as `full` rather than as `none`.";
+                            };
+                            readonly minimumSet: {
+                                readonly type: "boolean";
+                                readonly description: "Marks a type a community may ask for without it being remarkable. The minimum set contains only normal-sensitivity, consent-release types; that is a rule rather than a coincidence.";
+                            };
+                            readonly oidc: {
+                                readonly type: "array";
+                                readonly maxItems: 16;
+                                readonly items: {
+                                    readonly type: "string";
+                                    readonly maxLength: 64;
+                                };
+                                readonly description: "OIDC standard claims this type answers. A recorded mapping, applied at presentation — the token stays the maintainer's own and no external vocabulary is primary.";
+                            };
+                        };
+                    };
+                };
+                readonly unregistered: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly required: readonly ["sensitivity", "release", "mask"];
+                    readonly description: "The floor: what a token with no entry and no registered prefix resolves to. Served rather than assumed, because a client that hard-codes it cannot be tightened by a maintainer that raises it.";
+                    readonly properties: {
+                        readonly sensitivity: {
+                            readonly $ref: "#/$defs/Sensitivity";
+                        };
+                        readonly release: {
+                            readonly $ref: "#/$defs/ReleaseRequirement";
+                        };
+                        readonly mask: {
+                            readonly type: "string";
+                            readonly maxLength: 32;
+                        };
+                    };
+                };
+                readonly strictness: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly required: readonly ["sensitivity", "release", "mask"];
+                    readonly description: "Each axis ordered MOST PROTECTIVE FIRST. This is what makes rule 3 computable by a client: resolution takes the longest registered prefix and the unregistered floor and keeps whichever is more protective, which requires an ordering the client did not invent.";
+                    readonly properties: {
+                        readonly sensitivity: {
+                            readonly type: "array";
+                            readonly maxItems: 8;
+                            readonly items: {
+                                readonly type: "string";
+                                readonly maxLength: 32;
+                            };
+                        };
+                        readonly release: {
+                            readonly type: "array";
+                            readonly maxItems: 8;
+                            readonly items: {
+                                readonly type: "string";
+                                readonly maxLength: 32;
+                            };
+                        };
+                        readonly mask: {
+                            readonly type: "array";
+                            readonly maxItems: 16;
+                            readonly items: {
+                                readonly type: "string";
+                                readonly maxLength: 32;
+                            };
+                        };
+                    };
+                };
+                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 ReleaseRequirement: {
+            readonly title: "ReleaseRequirement";
+            readonly description: "What it takes to let a value LEAVE. Distinct from `Sensitivity`, which governs showing it to the holder.\n\n`consent` is the ordinary gate: `persona/disclosure/preview` renders what would leave and `persona/disclosure/present` releases it, so a human sees it once.\n\n`stepUp` additionally requires a fresh authentication bound to THAT preview — not to the session. Without the binding, \"each time\" degrades into \"once per login\", which is the failure the requirement exists to prevent; the single-use `previewId` the preview already mints is what an implementation binds to. A maintainer MUST refuse `persona/disclosure/present` for a `stepUp` attribute when no such approval accompanies it.\n\nAbsent means *not decided by the holder* and resolves from the claim-type registry, which defaults `payment.*` and `gov.*` to `stepUp`.";
+            readonly type: "string";
+            readonly enum: readonly ["consent", "stepUp"];
+        };
+        readonly Sensitivity: {
+            readonly title: "Sensitivity";
+            readonly description: "How carefully a value is shown TO ITS OWN HOLDER. `high` means a consumer masks it by default, reveals it one attribute at a time on a deliberate act, and — the half that is not cosmetic — omits it from a listing that did not ask for sensitive values.\n\nAbsent means *not decided by the holder*, not `normal`: a consumer resolves it from the claim-type registry (see CLAIM-TYPES.md §4), which is why this member is optional and why an unregistered token resolves conservatively rather than permissively.\n\nDistinct from how linkable the value is. A payment card is highly sensitive and barely linkable — every card number is unique, so knowing one tells a second verifier nothing about the first. Reading either as a proxy for the other produces a consumer that hides the wrong things.";
+            readonly type: "string";
+            readonly enum: readonly ["normal", "high"];
+        };
+        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]*)*$";
+        };
+    };
+};
+/**
+ * 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/persona/claim-types/list/1.0";
+    readonly isBearer: false;
+    readonly isProofRequired: true;
+    readonly isRecipientRequired: true;
+    readonly isIssuedAtRequired: false;
+    readonly payloadSchema: {
+        readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+        readonly $id: "https://trusttasks.org/spec/persona/claim-types/list/1.0";
+        readonly title: "Persona Claim Types List — payload";
+        readonly description: "Serve the claim-type registry this agent resolves against. A client that cannot read the table has to ship a copy of it, and a copy is a re-sync obligation on every change.";
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly properties: {
+            readonly ext: {
+                readonly $ref: "#/$defs/Ext";
+            };
+        };
+        readonly $defs: {
+            readonly Response: {
+                readonly $anchor: "response";
+                readonly title: "Persona Claim Types List — response payload";
+                readonly description: "Success response to persona/claim-types/list. Type https://trusttasks.org/spec/persona/claim-types/list/1.0#response.";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["registryVersion", "entries", "unregistered", "strictness"];
+                readonly properties: {
+                    readonly registryVersion: {
+                        readonly type: "string";
+                        readonly maxLength: 32;
+                        readonly description: "Version of the core registry this agent implements — the version of _shared/claim-types.json, not of this task. A client caching the table keys the cache on this.";
+                    };
+                    readonly entries: {
+                        readonly type: "array";
+                        readonly maxItems: 512;
+                        readonly description: "The registered tokens. Both exact tokens and family prefixes appear here, undistinguished: which one an entry is follows from whether a given token equals it or descends from it, and marking them would invite a client to walk only one kind.";
+                        readonly items: {
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                            readonly required: readonly ["type", "sensitivity", "release", "mask"];
+                            readonly properties: {
+                                readonly type: {
+                                    readonly $ref: "#/$defs/ClaimType";
+                                };
+                                readonly sensitivity: {
+                                    readonly $ref: "#/$defs/Sensitivity";
+                                };
+                                readonly release: {
+                                    readonly $ref: "#/$defs/ReleaseRequirement";
+                                };
+                                readonly mask: {
+                                    readonly type: "string";
+                                    readonly maxLength: 32;
+                                    readonly description: "Mask style, independent of sensitivity: any style that is not `none` is masked on screen whatever the sensitivity. Named rather than enumerated inline so a maintainer may serve a style this version does not list; a client that does not recognise a style MUST treat it as `full` rather than as `none`.";
+                                };
+                                readonly minimumSet: {
+                                    readonly type: "boolean";
+                                    readonly description: "Marks a type a community may ask for without it being remarkable. The minimum set contains only normal-sensitivity, consent-release types; that is a rule rather than a coincidence.";
+                                };
+                                readonly oidc: {
+                                    readonly type: "array";
+                                    readonly maxItems: 16;
+                                    readonly items: {
+                                        readonly type: "string";
+                                        readonly maxLength: 64;
+                                    };
+                                    readonly description: "OIDC standard claims this type answers. A recorded mapping, applied at presentation — the token stays the maintainer's own and no external vocabulary is primary.";
+                                };
+                            };
+                        };
+                    };
+                    readonly unregistered: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly required: readonly ["sensitivity", "release", "mask"];
+                        readonly description: "The floor: what a token with no entry and no registered prefix resolves to. Served rather than assumed, because a client that hard-codes it cannot be tightened by a maintainer that raises it.";
+                        readonly properties: {
+                            readonly sensitivity: {
+                                readonly $ref: "#/$defs/Sensitivity";
+                            };
+                            readonly release: {
+                                readonly $ref: "#/$defs/ReleaseRequirement";
+                            };
+                            readonly mask: {
+                                readonly type: "string";
+                                readonly maxLength: 32;
+                            };
+                        };
+                    };
+                    readonly strictness: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly required: readonly ["sensitivity", "release", "mask"];
+                        readonly description: "Each axis ordered MOST PROTECTIVE FIRST. This is what makes rule 3 computable by a client: resolution takes the longest registered prefix and the unregistered floor and keeps whichever is more protective, which requires an ordering the client did not invent.";
+                        readonly properties: {
+                            readonly sensitivity: {
+                                readonly type: "array";
+                                readonly maxItems: 8;
+                                readonly items: {
+                                    readonly type: "string";
+                                    readonly maxLength: 32;
+                                };
+                            };
+                            readonly release: {
+                                readonly type: "array";
+                                readonly maxItems: 8;
+                                readonly items: {
+                                    readonly type: "string";
+                                    readonly maxLength: 32;
+                                };
+                            };
+                            readonly mask: {
+                                readonly type: "array";
+                                readonly maxItems: 16;
+                                readonly items: {
+                                    readonly type: "string";
+                                    readonly maxLength: 32;
+                                };
+                            };
+                        };
+                    };
+                    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 ReleaseRequirement: {
+                readonly title: "ReleaseRequirement";
+                readonly description: "What it takes to let a value LEAVE. Distinct from `Sensitivity`, which governs showing it to the holder.\n\n`consent` is the ordinary gate: `persona/disclosure/preview` renders what would leave and `persona/disclosure/present` releases it, so a human sees it once.\n\n`stepUp` additionally requires a fresh authentication bound to THAT preview — not to the session. Without the binding, \"each time\" degrades into \"once per login\", which is the failure the requirement exists to prevent; the single-use `previewId` the preview already mints is what an implementation binds to. A maintainer MUST refuse `persona/disclosure/present` for a `stepUp` attribute when no such approval accompanies it.\n\nAbsent means *not decided by the holder* and resolves from the claim-type registry, which defaults `payment.*` and `gov.*` to `stepUp`.";
+                readonly type: "string";
+                readonly enum: readonly ["consent", "stepUp"];
+            };
+            readonly Sensitivity: {
+                readonly title: "Sensitivity";
+                readonly description: "How carefully a value is shown TO ITS OWN HOLDER. `high` means a consumer masks it by default, reveals it one attribute at a time on a deliberate act, and — the half that is not cosmetic — omits it from a listing that did not ask for sensitive values.\n\nAbsent means *not decided by the holder*, not `normal`: a consumer resolves it from the claim-type registry (see CLAIM-TYPES.md §4), which is why this member is optional and why an unregistered token resolves conservatively rather than permissively.\n\nDistinct from how linkable the value is. A payment card is highly sensitive and barely linkable — every card number is unique, so knowing one tells a second verifier nothing about the first. Reading either as a proxy for the other produces a consumer that hides the wrong things.";
+                readonly type: "string";
+                readonly enum: readonly ["normal", "high"];
+            };
+            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]*)*$";
+            };
+        };
+    };
+};
+/**
+ * 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/persona/claim-types/list/1.0#response";
+    readonly isBearer: false;
+    readonly isProofRequired: true;
+    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 Response: {
+                readonly $anchor: "response";
+                readonly title: "Persona Claim Types List — response payload";
+                readonly description: "Success response to persona/claim-types/list. Type https://trusttasks.org/spec/persona/claim-types/list/1.0#response.";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["registryVersion", "entries", "unregistered", "strictness"];
+                readonly properties: {
+                    readonly registryVersion: {
+                        readonly type: "string";
+                        readonly maxLength: 32;
+                        readonly description: "Version of the core registry this agent implements — the version of _shared/claim-types.json, not of this task. A client caching the table keys the cache on this.";
+                    };
+                    readonly entries: {
+                        readonly type: "array";
+                        readonly maxItems: 512;
+                        readonly description: "The registered tokens. Both exact tokens and family prefixes appear here, undistinguished: which one an entry is follows from whether a given token equals it or descends from it, and marking them would invite a client to walk only one kind.";
+                        readonly items: {
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                            readonly required: readonly ["type", "sensitivity", "release", "mask"];
+                            readonly properties: {
+                                readonly type: {
+                                    readonly $ref: "#/$defs/ClaimType";
+                                };
+                                readonly sensitivity: {
+                                    readonly $ref: "#/$defs/Sensitivity";
+                                };
+                                readonly release: {
+                                    readonly $ref: "#/$defs/ReleaseRequirement";
+                                };
+                                readonly mask: {
+                                    readonly type: "string";
+                                    readonly maxLength: 32;
+                                    readonly description: "Mask style, independent of sensitivity: any style that is not `none` is masked on screen whatever the sensitivity. Named rather than enumerated inline so a maintainer may serve a style this version does not list; a client that does not recognise a style MUST treat it as `full` rather than as `none`.";
+                                };
+                                readonly minimumSet: {
+                                    readonly type: "boolean";
+                                    readonly description: "Marks a type a community may ask for without it being remarkable. The minimum set contains only normal-sensitivity, consent-release types; that is a rule rather than a coincidence.";
+                                };
+                                readonly oidc: {
+                                    readonly type: "array";
+                                    readonly maxItems: 16;
+                                    readonly items: {
+                                        readonly type: "string";
+                                        readonly maxLength: 64;
+                                    };
+                                    readonly description: "OIDC standard claims this type answers. A recorded mapping, applied at presentation — the token stays the maintainer's own and no external vocabulary is primary.";
+                                };
+                            };
+                        };
+                    };
+                    readonly unregistered: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly required: readonly ["sensitivity", "release", "mask"];
+                        readonly description: "The floor: what a token with no entry and no registered prefix resolves to. Served rather than assumed, because a client that hard-codes it cannot be tightened by a maintainer that raises it.";
+                        readonly properties: {
+                            readonly sensitivity: {
+                                readonly $ref: "#/$defs/Sensitivity";
+                            };
+                            readonly release: {
+                                readonly $ref: "#/$defs/ReleaseRequirement";
+                            };
+                            readonly mask: {
+                                readonly type: "string";
+                                readonly maxLength: 32;
+                            };
+                        };
+                    };
+                    readonly strictness: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly required: readonly ["sensitivity", "release", "mask"];
+                        readonly description: "Each axis ordered MOST PROTECTIVE FIRST. This is what makes rule 3 computable by a client: resolution takes the longest registered prefix and the unregistered floor and keeps whichever is more protective, which requires an ordering the client did not invent.";
+                        readonly properties: {
+                            readonly sensitivity: {
+                                readonly type: "array";
+                                readonly maxItems: 8;
+                                readonly items: {
+                                    readonly type: "string";
+                                    readonly maxLength: 32;
+                                };
+                            };
+                            readonly release: {
+                                readonly type: "array";
+                                readonly maxItems: 8;
+                                readonly items: {
+                                    readonly type: "string";
+                                    readonly maxLength: 32;
+                                };
+                            };
+                            readonly mask: {
+                                readonly type: "array";
+                                readonly maxItems: 16;
+                                readonly items: {
+                                    readonly type: "string";
+                                    readonly maxLength: 32;
+                                };
+                            };
+                        };
+                    };
+                    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 ReleaseRequirement: {
+                readonly title: "ReleaseRequirement";
+                readonly description: "What it takes to let a value LEAVE. Distinct from `Sensitivity`, which governs showing it to the holder.\n\n`consent` is the ordinary gate: `persona/disclosure/preview` renders what would leave and `persona/disclosure/present` releases it, so a human sees it once.\n\n`stepUp` additionally requires a fresh authentication bound to THAT preview — not to the session. Without the binding, \"each time\" degrades into \"once per login\", which is the failure the requirement exists to prevent; the single-use `previewId` the preview already mints is what an implementation binds to. A maintainer MUST refuse `persona/disclosure/present` for a `stepUp` attribute when no such approval accompanies it.\n\nAbsent means *not decided by the holder* and resolves from the claim-type registry, which defaults `payment.*` and `gov.*` to `stepUp`.";
+                readonly type: "string";
+                readonly enum: readonly ["consent", "stepUp"];
+            };
+            readonly Sensitivity: {
+                readonly title: "Sensitivity";
+                readonly description: "How carefully a value is shown TO ITS OWN HOLDER. `high` means a consumer masks it by default, reveals it one attribute at a time on a deliberate act, and — the half that is not cosmetic — omits it from a listing that did not ask for sensitive values.\n\nAbsent means *not decided by the holder*, not `normal`: a consumer resolves it from the claim-type registry (see CLAIM-TYPES.md §4), which is why this member is optional and why an unregistered token resolves conservatively rather than permissively.\n\nDistinct from how linkable the value is. A payment card is highly sensitive and barely linkable — every card number is unique, so knowing one tells a second verifier nothing about the first. Reading either as a proxy for the other produces a consumer that hides the wrong things.";
+                readonly type: "string";
+                readonly enum: readonly ["normal", "high"];
+            };
+            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]*)*$";
+            };
+        };
+    };
+};
+//# sourceMappingURL=payload.d.ts.map