@openvtc/trust-tasks 0.12.1 → 0.12.2

package/dist/vta/app-state/list/1.0/payload.d.ts

@@ -0,0 +1,778 @@
+/**
+ * Generated by scripts/build-ts-bindings.mjs — DO NOT EDIT BY HAND.
+ * Source: specs/vta/app-state/list/1.0/payload.schema.json
+ */
+/**
+ * Restrict to one namespace. Optional in snapshot mode, where omitting it enumerates every namespace the caller can read in the context. REQUIRED in change-feed mode, because the version counter `sinceVersion` is compared against is maintained per (contextId, namespace) and a watermark spanning namespaces would name no single point in time.
+ */
+export type Namespace = string;
+/**
+ * Scopes one application's records within a context, so several tools can share a context without colliding — `openvtc`, `cnm`, an agent runtime. The maintainer MUST NOT interpret the value; it is an opaque partition name. Namespaces are first-come and unreserved, so an application SHOULD pick a stable, specific one: a future per-namespace ACL would grant on this exact string, which makes renaming a namespace a migration rather than an edit.
+ */
+export type Namespace1 = string;
+/**
+ * Application-chosen identifier for a record within a namespace. Opaque to the maintainer: it MUST NOT be parsed, normalized, or case-folded, and prefix matching in `list` is a byte-prefix comparison over the UTF-8 encoding. Applications SHOULD use `/`-delimited hierarchical keys (`community/acme`, `contact/z6Mk…`) so that `prefix` can address a record family, but the delimiter is a convention between an application and itself — the maintainer attaches no meaning to it.
+ */
+export type Key = string;
+/**
+ * The namespace counter value this record's most recent write took. Supply it as `expectedVersion` on the next write to make that write conditional on nothing having changed in between.
+ */
+export type Version = number;
+/**
+ * The namespace's current counter value. Present whenever `namespace` was supplied. This is what a consumer stores as its next `sinceVersion` — NOT the maximum version among `records`, which is wrong whenever a `prefix` filtered a later change out, and undefined when the page is empty. A paginating consumer MUST NOT advance its stored watermark until it has drained the final page, because the pages of one feed share this value and adopting it early would skip the records still to come.
+ */
+export type Version1 = number;
+/**
+ * Enumerate application-state records in a context. Two modes, distinguished by whether `sinceVersion` is supplied. Without it this is a SNAPSHOT of live records, optionally narrowed by `prefix`. With it this is a CHANGE FEED: every record in the namespace whose version exceeds the watermark, tombstones included, which is what lets an incremental consumer converge. Pagination is opaque-cursor based.
+ */
+export interface VTAApplicationStateListPayload {
+    /**
+     * The VTA context to enumerate; the isolation boundary.
+     */
+    contextId: string;
+    namespace?: Namespace;
+    /**
+     * Restrict to records whose `key` begins with this byte prefix, compared over the UTF-8 encoding. Lets a consumer read one record family — `community/`, `contact/` — without dragging every record in the namespace through the response.
+     */
+    prefix?: string;
+    /**
+     * Watermark. Selects change-feed mode: only records whose `version` is strictly greater are returned, tombstones included. Supply the `highWatermark` from the previous sync, or 0 for a first full pull in change-feed form. Requires `namespace`.
+     */
+    sinceVersion?: number;
+    /**
+     * When true, each returned record carries its `value`. Defaults to false, which returns the metadata view — address, version, timestamps, `valueBytes` — so a prefix scan is cheap. Setting it makes a scan one round trip rather than a scan plus N gets, at the cost of the response carrying every value.
+     */
+    includeValues?: boolean;
+    /**
+     * Snapshot mode only: when true, tombstones still inside the retention window are returned alongside live records. Defaults to false. In change-feed mode tombstones are always returned and this member MUST NOT be set to false — a change feed that omits deletions cannot converge, so asking for one is a contradiction rather than a preference.
+     */
+    includeDeleted?: boolean;
+    /**
+     * Caller's upper bound on records per page. The maintainer applies its own ceiling and MAY return fewer — notably when `includeValues` is set and the values are large.
+     */
+    pageSize?: number;
+    /**
+     * Opaque continuation token from a previous response. Consumers MUST treat it as opaque: never construct, decode, mutate, or infer meaning from one.
+     */
+    cursor?: string;
+    ext?: Ext;
+}
+/**
+ * Ecosystem-defined extension members per SPEC.md §4.5.1.
+ */
+export interface Ext {
+    [k: string]: unknown | undefined;
+}
+/**
+ * Success response to vta/app-state/list. Type https://trusttasks.org/spec/vta/app-state/list/1.0#response.
+ */
+export interface VTAApplicationStateListResponsePayload {
+    /**
+     * Matching records in ascending key order in snapshot mode, and ascending version order in change-feed mode — the latter so that a consumer applying them in order reaches the same state as the maintainer. May be empty.
+     */
+    records: AppStateRecord[];
+    /**
+     * True when more matching records exist beyond this page.
+     */
+    truncated: boolean;
+    /**
+     * Opaque continuation token for the next page. Present only when `truncated` is true.
+     */
+    cursor?: string;
+    highWatermark?: Version1;
+    /**
+     * How long this maintainer retains tombstones before reaping them. Advisory, and present at the maintainer's discretion, so a consumer can schedule its syncs to stay inside the window rather than discovering it has fallen out of it via vta/app-state/list:watermarkTooOld.
+     */
+    tombstoneRetentionSeconds?: number;
+    ext?: Ext1;
+}
+/**
+ * A record as the maintainer holds it. `value` is absent in three distinct situations and a consumer MUST NOT conflate them: the record is a tombstone (`deleted` is true); the caller asked for a metadata-only view (`list` without `includeValues`); or the value genuinely is the JSON literal `null`, in which case `value` is PRESENT and null. This is why `deleted` is required rather than defaulted — a consumer that has to infer deletion from an absent value gets the tombstone case wrong exactly when convergence depends on it.
+ */
+export interface AppStateRecord {
+    /**
+     * The VTA context the record is scoped to; the isolation boundary.
+     */
+    contextId: string;
+    namespace: Namespace1;
+    key: Key;
+    version: Version;
+    /**
+     * The stored JSON, in whatever shape the owning application chose. Any JSON value, including `null`. The maintainer neither validates nor interprets it. Absent when this is a tombstone or a metadata-only view — see this definition's description for why that is not the same as a null value.
+     */
+    value?: {
+        [k: string]: unknown | undefined;
+    };
+    /**
+     * Size of the stored value in bytes, measured as the maintainer measures it for the per-record cap (see `vta/app-state/put`). Present in metadata-only views so a consumer can decide what to fetch without fetching it; absent on a tombstone.
+     */
+    valueBytes?: number;
+    /**
+     * True when this is a tombstone: the record was deleted, and this entry exists so that a consumer syncing incrementally learns of the deletion. Tombstones are reaped after the maintainer's retention window; see `vta/app-state/list`.
+     */
+    deleted: boolean;
+    /**
+     * When the record was first created at this address. MAY be absent on a tombstone whose body has been discarded.
+     */
+    createdAt?: string;
+    /**
+     * When the write that produced this `version` was applied. For a tombstone, when the delete was applied.
+     */
+    updatedAt: string;
+    /**
+     * When the record was deleted. Present only when `deleted` is true; equal to `updatedAt` for a tombstone the maintainer has not since rewritten.
+     */
+    deletedAt?: string;
+}
+/**
+ * Ecosystem-defined extension members per SPEC.md §4.5.1.
+ */
+export interface Ext1 {
+    [k: string]: unknown | undefined;
+}
+/** Trust Task type URI. */
+export declare const TYPE_URI: "https://trusttasks.org/spec/vta/app-state/list/1.0";
+/** Stable alias for this specification's request payload shape. */
+export type Payload = VTAApplicationStateListPayload;
+/** Trust Task response type URI (request type URI + "#response"). */
+export declare const RESPONSE_TYPE_URI: "https://trusttasks.org/spec/vta/app-state/list/1.0#response";
+/** Stable alias for this specification's success-response payload shape. */
+export type Response = VTAApplicationStateListResponsePayload;
+/**
+ * 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/vta/app-state/list/1.0";
+    readonly title: "VTA Application State List — payload";
+    readonly description: "Enumerate application-state records in a context. Two modes, distinguished by whether `sinceVersion` is supplied. Without it this is a SNAPSHOT of live records, optionally narrowed by `prefix`. With it this is a CHANGE FEED: every record in the namespace whose version exceeds the watermark, tombstones included, which is what lets an incremental consumer converge. Pagination is opaque-cursor based.";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["contextId"];
+    readonly properties: {
+        readonly contextId: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly description: "The VTA context to enumerate; the isolation boundary.";
+        };
+        readonly namespace: {
+            readonly $ref: "#/$defs/Namespace";
+            readonly description: "Restrict to one namespace. Optional in snapshot mode, where omitting it enumerates every namespace the caller can read in the context. REQUIRED in change-feed mode, because the version counter `sinceVersion` is compared against is maintained per (contextId, namespace) and a watermark spanning namespaces would name no single point in time.";
+        };
+        readonly prefix: {
+            readonly type: "string";
+            readonly maxLength: 512;
+            readonly description: "Restrict to records whose `key` begins with this byte prefix, compared over the UTF-8 encoding. Lets a consumer read one record family — `community/`, `contact/` — without dragging every record in the namespace through the response.";
+        };
+        readonly sinceVersion: {
+            readonly type: "integer";
+            readonly minimum: 0;
+            readonly description: "Watermark. Selects change-feed mode: only records whose `version` is strictly greater are returned, tombstones included. Supply the `highWatermark` from the previous sync, or 0 for a first full pull in change-feed form. Requires `namespace`.";
+        };
+        readonly includeValues: {
+            readonly type: "boolean";
+            readonly description: "When true, each returned record carries its `value`. Defaults to false, which returns the metadata view — address, version, timestamps, `valueBytes` — so a prefix scan is cheap. Setting it makes a scan one round trip rather than a scan plus N gets, at the cost of the response carrying every value.";
+        };
+        readonly includeDeleted: {
+            readonly type: "boolean";
+            readonly description: "Snapshot mode only: when true, tombstones still inside the retention window are returned alongside live records. Defaults to false. In change-feed mode tombstones are always returned and this member MUST NOT be set to false — a change feed that omits deletions cannot converge, so asking for one is a contradiction rather than a preference.";
+        };
+        readonly pageSize: {
+            readonly type: "integer";
+            readonly minimum: 1;
+            readonly maximum: 1000;
+            readonly description: "Caller's upper bound on records per page. The maintainer applies its own ceiling and MAY return fewer — notably when `includeValues` is set and the values are large.";
+        };
+        readonly cursor: {
+            readonly type: "string";
+            readonly description: "Opaque continuation token from a previous response. Consumers MUST treat it as opaque: never construct, decode, mutate, or infer meaning from one.";
+        };
+        readonly ext: {
+            readonly $ref: "#/$defs/Ext";
+            readonly description: "Ecosystem-defined extension members per SPEC.md §4.5.1.";
+        };
+    };
+    readonly $defs: {
+        readonly Response: {
+            readonly $anchor: "response";
+            readonly title: "VTA Application State List — response payload";
+            readonly description: "Success response to vta/app-state/list. Type https://trusttasks.org/spec/vta/app-state/list/1.0#response.";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["records", "truncated"];
+            readonly properties: {
+                readonly records: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/$defs/AppStateRecord";
+                    };
+                    readonly description: "Matching records in ascending key order in snapshot mode, and ascending version order in change-feed mode — the latter so that a consumer applying them in order reaches the same state as the maintainer. May be empty.";
+                };
+                readonly truncated: {
+                    readonly type: "boolean";
+                    readonly description: "True when more matching records exist beyond this page.";
+                };
+                readonly cursor: {
+                    readonly type: "string";
+                    readonly description: "Opaque continuation token for the next page. Present only when `truncated` is true.";
+                };
+                readonly highWatermark: {
+                    readonly $ref: "#/$defs/Version";
+                    readonly description: "The namespace's current counter value. Present whenever `namespace` was supplied. This is what a consumer stores as its next `sinceVersion` — NOT the maximum version among `records`, which is wrong whenever a `prefix` filtered a later change out, and undefined when the page is empty. A paginating consumer MUST NOT advance its stored watermark until it has drained the final page, because the pages of one feed share this value and adopting it early would skip the records still to come.";
+                };
+                readonly tombstoneRetentionSeconds: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                    readonly description: "How long this maintainer retains tombstones before reaping them. Advisory, and present at the maintainer's discretion, so a consumer can schedule its syncs to stay inside the window rather than discovering it has fallen out of it via vta/app-state/list:watermarkTooOld.";
+                };
+                readonly ext: {
+                    readonly $ref: "#/$defs/Ext";
+                    readonly description: "Ecosystem-defined extension members per SPEC.md §4.5.1.";
+                };
+            };
+        };
+        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 Version: {
+            readonly title: "Version";
+            readonly description: "A value of the namespace's monotonic write counter (see this schema's description). Server-assigned; a producer never chooses one.";
+            readonly type: "integer";
+            readonly minimum: 1;
+        };
+        readonly AppStateRecord: {
+            readonly title: "AppStateRecord";
+            readonly description: "A record as the maintainer holds it. `value` is absent in three distinct situations and a consumer MUST NOT conflate them: the record is a tombstone (`deleted` is true); the caller asked for a metadata-only view (`list` without `includeValues`); or the value genuinely is the JSON literal `null`, in which case `value` is PRESENT and null. This is why `deleted` is required rather than defaulted — a consumer that has to infer deletion from an absent value gets the tombstone case wrong exactly when convergence depends on it.";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["contextId", "namespace", "key", "version", "deleted", "updatedAt"];
+            readonly properties: {
+                readonly contextId: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly description: "The VTA context the record is scoped to; the isolation boundary.";
+                };
+                readonly namespace: {
+                    readonly $ref: "#/$defs/Namespace";
+                };
+                readonly key: {
+                    readonly $ref: "#/$defs/Key";
+                };
+                readonly version: {
+                    readonly $ref: "#/$defs/Version";
+                    readonly description: "The namespace counter value this record's most recent write took. Supply it as `expectedVersion` on the next write to make that write conditional on nothing having changed in between.";
+                };
+                readonly value: {
+                    readonly description: "The stored JSON, in whatever shape the owning application chose. Any JSON value, including `null`. The maintainer neither validates nor interprets it. Absent when this is a tombstone or a metadata-only view — see this definition's description for why that is not the same as a null value.";
+                };
+                readonly valueBytes: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                    readonly description: "Size of the stored value in bytes, measured as the maintainer measures it for the per-record cap (see `vta/app-state/put`). Present in metadata-only views so a consumer can decide what to fetch without fetching it; absent on a tombstone.";
+                };
+                readonly deleted: {
+                    readonly type: "boolean";
+                    readonly description: "True when this is a tombstone: the record was deleted, and this entry exists so that a consumer syncing incrementally learns of the deletion. Tombstones are reaped after the maintainer's retention window; see `vta/app-state/list`.";
+                };
+                readonly createdAt: {
+                    readonly type: "string";
+                    readonly format: "date-time";
+                    readonly description: "When the record was first created at this address. MAY be absent on a tombstone whose body has been discarded.";
+                };
+                readonly updatedAt: {
+                    readonly type: "string";
+                    readonly format: "date-time";
+                    readonly description: "When the write that produced this `version` was applied. For a tombstone, when the delete was applied.";
+                };
+                readonly deletedAt: {
+                    readonly type: "string";
+                    readonly format: "date-time";
+                    readonly description: "When the record was deleted. Present only when `deleted` is true; equal to `updatedAt` for a tombstone the maintainer has not since rewritten.";
+                };
+            };
+        };
+        readonly Key: {
+            readonly title: "Key";
+            readonly description: "Application-chosen identifier for a record within a namespace. Opaque to the maintainer: it MUST NOT be parsed, normalized, or case-folded, and prefix matching in `list` is a byte-prefix comparison over the UTF-8 encoding. Applications SHOULD use `/`-delimited hierarchical keys (`community/acme`, `contact/z6Mk…`) so that `prefix` can address a record family, but the delimiter is a convention between an application and itself — the maintainer attaches no meaning to it.";
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 512;
+            readonly pattern: "^[^\\u0000]+$";
+        };
+        readonly Namespace: {
+            readonly title: "Namespace";
+            readonly description: "Scopes one application's records within a context, so several tools can share a context without colliding — `openvtc`, `cnm`, an agent runtime. The maintainer MUST NOT interpret the value; it is an opaque partition name. Namespaces are first-come and unreserved, so an application SHOULD pick a stable, specific one: a future per-namespace ACL would grant on this exact string, which makes renaming a namespace a migration rather than an edit.";
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 64;
+            readonly pattern: "^[a-z][a-z0-9]*(-[a-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: "VTA Application State List — response payload";
+            readonly description: "Success response to vta/app-state/list. Type https://trusttasks.org/spec/vta/app-state/list/1.0#response.";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["records", "truncated"];
+            readonly properties: {
+                readonly records: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/$defs/AppStateRecord";
+                    };
+                    readonly description: "Matching records in ascending key order in snapshot mode, and ascending version order in change-feed mode — the latter so that a consumer applying them in order reaches the same state as the maintainer. May be empty.";
+                };
+                readonly truncated: {
+                    readonly type: "boolean";
+                    readonly description: "True when more matching records exist beyond this page.";
+                };
+                readonly cursor: {
+                    readonly type: "string";
+                    readonly description: "Opaque continuation token for the next page. Present only when `truncated` is true.";
+                };
+                readonly highWatermark: {
+                    readonly $ref: "#/$defs/Version";
+                    readonly description: "The namespace's current counter value. Present whenever `namespace` was supplied. This is what a consumer stores as its next `sinceVersion` — NOT the maximum version among `records`, which is wrong whenever a `prefix` filtered a later change out, and undefined when the page is empty. A paginating consumer MUST NOT advance its stored watermark until it has drained the final page, because the pages of one feed share this value and adopting it early would skip the records still to come.";
+                };
+                readonly tombstoneRetentionSeconds: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                    readonly description: "How long this maintainer retains tombstones before reaping them. Advisory, and present at the maintainer's discretion, so a consumer can schedule its syncs to stay inside the window rather than discovering it has fallen out of it via vta/app-state/list:watermarkTooOld.";
+                };
+                readonly ext: {
+                    readonly $ref: "#/$defs/Ext";
+                    readonly description: "Ecosystem-defined extension members per SPEC.md §4.5.1.";
+                };
+            };
+        };
+        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 Version: {
+            readonly title: "Version";
+            readonly description: "A value of the namespace's monotonic write counter (see this schema's description). Server-assigned; a producer never chooses one.";
+            readonly type: "integer";
+            readonly minimum: 1;
+        };
+        readonly AppStateRecord: {
+            readonly title: "AppStateRecord";
+            readonly description: "A record as the maintainer holds it. `value` is absent in three distinct situations and a consumer MUST NOT conflate them: the record is a tombstone (`deleted` is true); the caller asked for a metadata-only view (`list` without `includeValues`); or the value genuinely is the JSON literal `null`, in which case `value` is PRESENT and null. This is why `deleted` is required rather than defaulted — a consumer that has to infer deletion from an absent value gets the tombstone case wrong exactly when convergence depends on it.";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["contextId", "namespace", "key", "version", "deleted", "updatedAt"];
+            readonly properties: {
+                readonly contextId: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly description: "The VTA context the record is scoped to; the isolation boundary.";
+                };
+                readonly namespace: {
+                    readonly $ref: "#/$defs/Namespace";
+                };
+                readonly key: {
+                    readonly $ref: "#/$defs/Key";
+                };
+                readonly version: {
+                    readonly $ref: "#/$defs/Version";
+                    readonly description: "The namespace counter value this record's most recent write took. Supply it as `expectedVersion` on the next write to make that write conditional on nothing having changed in between.";
+                };
+                readonly value: {
+                    readonly description: "The stored JSON, in whatever shape the owning application chose. Any JSON value, including `null`. The maintainer neither validates nor interprets it. Absent when this is a tombstone or a metadata-only view — see this definition's description for why that is not the same as a null value.";
+                };
+                readonly valueBytes: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                    readonly description: "Size of the stored value in bytes, measured as the maintainer measures it for the per-record cap (see `vta/app-state/put`). Present in metadata-only views so a consumer can decide what to fetch without fetching it; absent on a tombstone.";
+                };
+                readonly deleted: {
+                    readonly type: "boolean";
+                    readonly description: "True when this is a tombstone: the record was deleted, and this entry exists so that a consumer syncing incrementally learns of the deletion. Tombstones are reaped after the maintainer's retention window; see `vta/app-state/list`.";
+                };
+                readonly createdAt: {
+                    readonly type: "string";
+                    readonly format: "date-time";
+                    readonly description: "When the record was first created at this address. MAY be absent on a tombstone whose body has been discarded.";
+                };
+                readonly updatedAt: {
+                    readonly type: "string";
+                    readonly format: "date-time";
+                    readonly description: "When the write that produced this `version` was applied. For a tombstone, when the delete was applied.";
+                };
+                readonly deletedAt: {
+                    readonly type: "string";
+                    readonly format: "date-time";
+                    readonly description: "When the record was deleted. Present only when `deleted` is true; equal to `updatedAt` for a tombstone the maintainer has not since rewritten.";
+                };
+            };
+        };
+        readonly Key: {
+            readonly title: "Key";
+            readonly description: "Application-chosen identifier for a record within a namespace. Opaque to the maintainer: it MUST NOT be parsed, normalized, or case-folded, and prefix matching in `list` is a byte-prefix comparison over the UTF-8 encoding. Applications SHOULD use `/`-delimited hierarchical keys (`community/acme`, `contact/z6Mk…`) so that `prefix` can address a record family, but the delimiter is a convention between an application and itself — the maintainer attaches no meaning to it.";
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 512;
+            readonly pattern: "^[^\\u0000]+$";
+        };
+        readonly Namespace: {
+            readonly title: "Namespace";
+            readonly description: "Scopes one application's records within a context, so several tools can share a context without colliding — `openvtc`, `cnm`, an agent runtime. The maintainer MUST NOT interpret the value; it is an opaque partition name. Namespaces are first-come and unreserved, so an application SHOULD pick a stable, specific one: a future per-namespace ACL would grant on this exact string, which makes renaming a namespace a migration rather than an edit.";
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 64;
+            readonly pattern: "^[a-z][a-z0-9]*(-[a-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/vta/app-state/list/1.0";
+    readonly isBearer: false;
+    readonly isProofRequired: false;
+    readonly isRecipientRequired: true;
+    readonly payloadSchema: {
+        readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+        readonly $id: "https://trusttasks.org/spec/vta/app-state/list/1.0";
+        readonly title: "VTA Application State List — payload";
+        readonly description: "Enumerate application-state records in a context. Two modes, distinguished by whether `sinceVersion` is supplied. Without it this is a SNAPSHOT of live records, optionally narrowed by `prefix`. With it this is a CHANGE FEED: every record in the namespace whose version exceeds the watermark, tombstones included, which is what lets an incremental consumer converge. Pagination is opaque-cursor based.";
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly required: readonly ["contextId"];
+        readonly properties: {
+            readonly contextId: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly description: "The VTA context to enumerate; the isolation boundary.";
+            };
+            readonly namespace: {
+                readonly $ref: "#/$defs/Namespace";
+                readonly description: "Restrict to one namespace. Optional in snapshot mode, where omitting it enumerates every namespace the caller can read in the context. REQUIRED in change-feed mode, because the version counter `sinceVersion` is compared against is maintained per (contextId, namespace) and a watermark spanning namespaces would name no single point in time.";
+            };
+            readonly prefix: {
+                readonly type: "string";
+                readonly maxLength: 512;
+                readonly description: "Restrict to records whose `key` begins with this byte prefix, compared over the UTF-8 encoding. Lets a consumer read one record family — `community/`, `contact/` — without dragging every record in the namespace through the response.";
+            };
+            readonly sinceVersion: {
+                readonly type: "integer";
+                readonly minimum: 0;
+                readonly description: "Watermark. Selects change-feed mode: only records whose `version` is strictly greater are returned, tombstones included. Supply the `highWatermark` from the previous sync, or 0 for a first full pull in change-feed form. Requires `namespace`.";
+            };
+            readonly includeValues: {
+                readonly type: "boolean";
+                readonly description: "When true, each returned record carries its `value`. Defaults to false, which returns the metadata view — address, version, timestamps, `valueBytes` — so a prefix scan is cheap. Setting it makes a scan one round trip rather than a scan plus N gets, at the cost of the response carrying every value.";
+            };
+            readonly includeDeleted: {
+                readonly type: "boolean";
+                readonly description: "Snapshot mode only: when true, tombstones still inside the retention window are returned alongside live records. Defaults to false. In change-feed mode tombstones are always returned and this member MUST NOT be set to false — a change feed that omits deletions cannot converge, so asking for one is a contradiction rather than a preference.";
+            };
+            readonly pageSize: {
+                readonly type: "integer";
+                readonly minimum: 1;
+                readonly maximum: 1000;
+                readonly description: "Caller's upper bound on records per page. The maintainer applies its own ceiling and MAY return fewer — notably when `includeValues` is set and the values are large.";
+            };
+            readonly cursor: {
+                readonly type: "string";
+                readonly description: "Opaque continuation token from a previous response. Consumers MUST treat it as opaque: never construct, decode, mutate, or infer meaning from one.";
+            };
+            readonly ext: {
+                readonly $ref: "#/$defs/Ext";
+                readonly description: "Ecosystem-defined extension members per SPEC.md §4.5.1.";
+            };
+        };
+        readonly $defs: {
+            readonly Response: {
+                readonly $anchor: "response";
+                readonly title: "VTA Application State List — response payload";
+                readonly description: "Success response to vta/app-state/list. Type https://trusttasks.org/spec/vta/app-state/list/1.0#response.";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["records", "truncated"];
+                readonly properties: {
+                    readonly records: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly $ref: "#/$defs/AppStateRecord";
+                        };
+                        readonly description: "Matching records in ascending key order in snapshot mode, and ascending version order in change-feed mode — the latter so that a consumer applying them in order reaches the same state as the maintainer. May be empty.";
+                    };
+                    readonly truncated: {
+                        readonly type: "boolean";
+                        readonly description: "True when more matching records exist beyond this page.";
+                    };
+                    readonly cursor: {
+                        readonly type: "string";
+                        readonly description: "Opaque continuation token for the next page. Present only when `truncated` is true.";
+                    };
+                    readonly highWatermark: {
+                        readonly $ref: "#/$defs/Version";
+                        readonly description: "The namespace's current counter value. Present whenever `namespace` was supplied. This is what a consumer stores as its next `sinceVersion` — NOT the maximum version among `records`, which is wrong whenever a `prefix` filtered a later change out, and undefined when the page is empty. A paginating consumer MUST NOT advance its stored watermark until it has drained the final page, because the pages of one feed share this value and adopting it early would skip the records still to come.";
+                    };
+                    readonly tombstoneRetentionSeconds: {
+                        readonly type: "integer";
+                        readonly minimum: 0;
+                        readonly description: "How long this maintainer retains tombstones before reaping them. Advisory, and present at the maintainer's discretion, so a consumer can schedule its syncs to stay inside the window rather than discovering it has fallen out of it via vta/app-state/list:watermarkTooOld.";
+                    };
+                    readonly ext: {
+                        readonly $ref: "#/$defs/Ext";
+                        readonly description: "Ecosystem-defined extension members per SPEC.md §4.5.1.";
+                    };
+                };
+            };
+            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 Version: {
+                readonly title: "Version";
+                readonly description: "A value of the namespace's monotonic write counter (see this schema's description). Server-assigned; a producer never chooses one.";
+                readonly type: "integer";
+                readonly minimum: 1;
+            };
+            readonly AppStateRecord: {
+                readonly title: "AppStateRecord";
+                readonly description: "A record as the maintainer holds it. `value` is absent in three distinct situations and a consumer MUST NOT conflate them: the record is a tombstone (`deleted` is true); the caller asked for a metadata-only view (`list` without `includeValues`); or the value genuinely is the JSON literal `null`, in which case `value` is PRESENT and null. This is why `deleted` is required rather than defaulted — a consumer that has to infer deletion from an absent value gets the tombstone case wrong exactly when convergence depends on it.";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["contextId", "namespace", "key", "version", "deleted", "updatedAt"];
+                readonly properties: {
+                    readonly contextId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly description: "The VTA context the record is scoped to; the isolation boundary.";
+                    };
+                    readonly namespace: {
+                        readonly $ref: "#/$defs/Namespace";
+                    };
+                    readonly key: {
+                        readonly $ref: "#/$defs/Key";
+                    };
+                    readonly version: {
+                        readonly $ref: "#/$defs/Version";
+                        readonly description: "The namespace counter value this record's most recent write took. Supply it as `expectedVersion` on the next write to make that write conditional on nothing having changed in between.";
+                    };
+                    readonly value: {
+                        readonly description: "The stored JSON, in whatever shape the owning application chose. Any JSON value, including `null`. The maintainer neither validates nor interprets it. Absent when this is a tombstone or a metadata-only view — see this definition's description for why that is not the same as a null value.";
+                    };
+                    readonly valueBytes: {
+                        readonly type: "integer";
+                        readonly minimum: 0;
+                        readonly description: "Size of the stored value in bytes, measured as the maintainer measures it for the per-record cap (see `vta/app-state/put`). Present in metadata-only views so a consumer can decide what to fetch without fetching it; absent on a tombstone.";
+                    };
+                    readonly deleted: {
+                        readonly type: "boolean";
+                        readonly description: "True when this is a tombstone: the record was deleted, and this entry exists so that a consumer syncing incrementally learns of the deletion. Tombstones are reaped after the maintainer's retention window; see `vta/app-state/list`.";
+                    };
+                    readonly createdAt: {
+                        readonly type: "string";
+                        readonly format: "date-time";
+                        readonly description: "When the record was first created at this address. MAY be absent on a tombstone whose body has been discarded.";
+                    };
+                    readonly updatedAt: {
+                        readonly type: "string";
+                        readonly format: "date-time";
+                        readonly description: "When the write that produced this `version` was applied. For a tombstone, when the delete was applied.";
+                    };
+                    readonly deletedAt: {
+                        readonly type: "string";
+                        readonly format: "date-time";
+                        readonly description: "When the record was deleted. Present only when `deleted` is true; equal to `updatedAt` for a tombstone the maintainer has not since rewritten.";
+                    };
+                };
+            };
+            readonly Key: {
+                readonly title: "Key";
+                readonly description: "Application-chosen identifier for a record within a namespace. Opaque to the maintainer: it MUST NOT be parsed, normalized, or case-folded, and prefix matching in `list` is a byte-prefix comparison over the UTF-8 encoding. Applications SHOULD use `/`-delimited hierarchical keys (`community/acme`, `contact/z6Mk…`) so that `prefix` can address a record family, but the delimiter is a convention between an application and itself — the maintainer attaches no meaning to it.";
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 512;
+                readonly pattern: "^[^\\u0000]+$";
+            };
+            readonly Namespace: {
+                readonly title: "Namespace";
+                readonly description: "Scopes one application's records within a context, so several tools can share a context without colliding — `openvtc`, `cnm`, an agent runtime. The maintainer MUST NOT interpret the value; it is an opaque partition name. Namespaces are first-come and unreserved, so an application SHOULD pick a stable, specific one: a future per-namespace ACL would grant on this exact string, which makes renaming a namespace a migration rather than an edit.";
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 64;
+                readonly pattern: "^[a-z][a-z0-9]*(-[a-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/vta/app-state/list/1.0#response";
+    readonly isBearer: false;
+    readonly isProofRequired: false;
+    readonly isRecipientRequired: true;
+    readonly payloadSchema: {
+        readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+        readonly $ref: "#/$defs/Response";
+        readonly $defs: {
+            readonly Response: {
+                readonly $anchor: "response";
+                readonly title: "VTA Application State List — response payload";
+                readonly description: "Success response to vta/app-state/list. Type https://trusttasks.org/spec/vta/app-state/list/1.0#response.";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["records", "truncated"];
+                readonly properties: {
+                    readonly records: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly $ref: "#/$defs/AppStateRecord";
+                        };
+                        readonly description: "Matching records in ascending key order in snapshot mode, and ascending version order in change-feed mode — the latter so that a consumer applying them in order reaches the same state as the maintainer. May be empty.";
+                    };
+                    readonly truncated: {
+                        readonly type: "boolean";
+                        readonly description: "True when more matching records exist beyond this page.";
+                    };
+                    readonly cursor: {
+                        readonly type: "string";
+                        readonly description: "Opaque continuation token for the next page. Present only when `truncated` is true.";
+                    };
+                    readonly highWatermark: {
+                        readonly $ref: "#/$defs/Version";
+                        readonly description: "The namespace's current counter value. Present whenever `namespace` was supplied. This is what a consumer stores as its next `sinceVersion` — NOT the maximum version among `records`, which is wrong whenever a `prefix` filtered a later change out, and undefined when the page is empty. A paginating consumer MUST NOT advance its stored watermark until it has drained the final page, because the pages of one feed share this value and adopting it early would skip the records still to come.";
+                    };
+                    readonly tombstoneRetentionSeconds: {
+                        readonly type: "integer";
+                        readonly minimum: 0;
+                        readonly description: "How long this maintainer retains tombstones before reaping them. Advisory, and present at the maintainer's discretion, so a consumer can schedule its syncs to stay inside the window rather than discovering it has fallen out of it via vta/app-state/list:watermarkTooOld.";
+                    };
+                    readonly ext: {
+                        readonly $ref: "#/$defs/Ext";
+                        readonly description: "Ecosystem-defined extension members per SPEC.md §4.5.1.";
+                    };
+                };
+            };
+            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 Version: {
+                readonly title: "Version";
+                readonly description: "A value of the namespace's monotonic write counter (see this schema's description). Server-assigned; a producer never chooses one.";
+                readonly type: "integer";
+                readonly minimum: 1;
+            };
+            readonly AppStateRecord: {
+                readonly title: "AppStateRecord";
+                readonly description: "A record as the maintainer holds it. `value` is absent in three distinct situations and a consumer MUST NOT conflate them: the record is a tombstone (`deleted` is true); the caller asked for a metadata-only view (`list` without `includeValues`); or the value genuinely is the JSON literal `null`, in which case `value` is PRESENT and null. This is why `deleted` is required rather than defaulted — a consumer that has to infer deletion from an absent value gets the tombstone case wrong exactly when convergence depends on it.";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["contextId", "namespace", "key", "version", "deleted", "updatedAt"];
+                readonly properties: {
+                    readonly contextId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly description: "The VTA context the record is scoped to; the isolation boundary.";
+                    };
+                    readonly namespace: {
+                        readonly $ref: "#/$defs/Namespace";
+                    };
+                    readonly key: {
+                        readonly $ref: "#/$defs/Key";
+                    };
+                    readonly version: {
+                        readonly $ref: "#/$defs/Version";
+                        readonly description: "The namespace counter value this record's most recent write took. Supply it as `expectedVersion` on the next write to make that write conditional on nothing having changed in between.";
+                    };
+                    readonly value: {
+                        readonly description: "The stored JSON, in whatever shape the owning application chose. Any JSON value, including `null`. The maintainer neither validates nor interprets it. Absent when this is a tombstone or a metadata-only view — see this definition's description for why that is not the same as a null value.";
+                    };
+                    readonly valueBytes: {
+                        readonly type: "integer";
+                        readonly minimum: 0;
+                        readonly description: "Size of the stored value in bytes, measured as the maintainer measures it for the per-record cap (see `vta/app-state/put`). Present in metadata-only views so a consumer can decide what to fetch without fetching it; absent on a tombstone.";
+                    };
+                    readonly deleted: {
+                        readonly type: "boolean";
+                        readonly description: "True when this is a tombstone: the record was deleted, and this entry exists so that a consumer syncing incrementally learns of the deletion. Tombstones are reaped after the maintainer's retention window; see `vta/app-state/list`.";
+                    };
+                    readonly createdAt: {
+                        readonly type: "string";
+                        readonly format: "date-time";
+                        readonly description: "When the record was first created at this address. MAY be absent on a tombstone whose body has been discarded.";
+                    };
+                    readonly updatedAt: {
+                        readonly type: "string";
+                        readonly format: "date-time";
+                        readonly description: "When the write that produced this `version` was applied. For a tombstone, when the delete was applied.";
+                    };
+                    readonly deletedAt: {
+                        readonly type: "string";
+                        readonly format: "date-time";
+                        readonly description: "When the record was deleted. Present only when `deleted` is true; equal to `updatedAt` for a tombstone the maintainer has not since rewritten.";
+                    };
+                };
+            };
+            readonly Key: {
+                readonly title: "Key";
+                readonly description: "Application-chosen identifier for a record within a namespace. Opaque to the maintainer: it MUST NOT be parsed, normalized, or case-folded, and prefix matching in `list` is a byte-prefix comparison over the UTF-8 encoding. Applications SHOULD use `/`-delimited hierarchical keys (`community/acme`, `contact/z6Mk…`) so that `prefix` can address a record family, but the delimiter is a convention between an application and itself — the maintainer attaches no meaning to it.";
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 512;
+                readonly pattern: "^[^\\u0000]+$";
+            };
+            readonly Namespace: {
+                readonly title: "Namespace";
+                readonly description: "Scopes one application's records within a context, so several tools can share a context without colliding — `openvtc`, `cnm`, an agent runtime. The maintainer MUST NOT interpret the value; it is an opaque partition name. Namespaces are first-come and unreserved, so an application SHOULD pick a stable, specific one: a future per-namespace ACL would grant on this exact string, which makes renaming a namespace a migration rather than an edit.";
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 64;
+                readonly pattern: "^[a-z][a-z0-9]*(-[a-z0-9]+)*$";
+            };
+        };
+    };
+};
+//# sourceMappingURL=payload.d.ts.map