@openvtc/trust-tasks 0.28.7 → 0.28.9

package/dist/_shared/components.d.ts

@@ -357,6 +357,10 @@ export type ApproverDid = string;
  * A human-readable name for where the approver lives — e.g. `Browser plugin — work laptop`. Chosen by the subject (or suggested by an inviter), untrusted, and attributed to its author wherever it is rendered. Absent rather than invented when none was chosen.
  */
 export type ApproverLabel = string;
+/**
+ * What an archived room's members may still do. `readOnly`: their credentials stand and they keep reading what the room holds; the room's host refuses every write, upload and curation from a member. `noAccess`: every credential the room issued before the archival is withdrawn at its host — a room reset — so the host refuses every member's every task; the content is kept intact, and each withdrawn admission is `suspended`, restored when the room is unarchived or made `readOnly`. Neither recalls what a member already read or saved, and on a sealed tier neither removes anyone from the room's group.
+ */
+export type ArchiveAccess = "readOnly" | "noAccess";
 /**
  * The metadata of one attestation: what a Vetting Statement would have said, minus its issuer, as vetting/attestation/0.1 defines it.
  */
@@ -473,6 +477,10 @@ export type ConsumerKind_DeviceV0_1 = Companion_DeviceV0_1 | Service_DeviceV0_1;
  * Discriminator: is this consumer a user-driven Companion or a headless Service?
  */
 export type ConsumerKind_DeviceV0_2 = Companion_DeviceV0_2 | Service_DeviceV0_2;
+/**
+ * The trust context the notification is held in: the one the addressed DID belongs to.
+ */
+export type ContextId = string;
 /**
  * Opaque identifier of one of the maintainer's contexts, compared by the maintainer's own ancestry predicate. Its grammar is the maintainer's.
  */
@@ -564,6 +572,10 @@ export type Did_GitNsV0_1 = string;
  * A bare DID in the W3C DID Core syntax (§3.1): `did:`, a method name of lowercase letters and digits, `:`, and a method-specific id of colon-separated segments drawn from `A-Z a-z 0-9 . - _` and percent-encoded octets, the last segment non-empty. A DID URL is not a DID: no path, query or fragment (`/`, `?`, `#`), so a verification-method id such as `did:key:z6Mk…#z6Mk…` is refused. Compared by exact string equality — no case folding or percent-decoding. A consumer MUST still treat the value as data: the pattern keeps shell metacharacters, whitespace and quotes out of the wire form, but it does not make a DID safe to splice into a command or markup.
  */
 export type Did_GitNsV0_3 = string;
+/**
+ * A DID.
+ */
+export type Did_NotificationsV0_1 = string;
 /**
  * A cryptographic digest as a multibase-encoded multihash — the encoding the W3C Verifiable Credentials Data Model 2.0 defines for `digestMultibase`, and the one `did:webvh` uses for its SCID and entry hashes.
  *
@@ -896,6 +908,10 @@ export type Key_VtaV0_1 = string;
  * The interaction kind: a 1:1 direct message, a multi-party group, or a broadcast channel.
  */
 export type Kind = "dm" | "group" | "channel";
+/**
+ * What the thing is. Either a registered kind — one lowerCamelCase name in the VTI specification's notification kind registry (Appendix G), such as `election` — or an unregistered kind, written `<reverse-DNS domain>:<name>` under a domain its definer controls, such as `org.example:meetingInvite`. A recipient that does not recognise a kind holds, lists and discards it and does nothing else with it (VTI-NTF-012).
+ */
+export type Kind_NotificationsV0_1 = string;
 /**
  * A BCP 47 language tag, e.g. `en`, `de-AT`. Compared case-insensitively.
  */
@@ -954,6 +970,10 @@ export type MemberActions = [MemberAction] | [MemberAction, MemberAction] | [Mem
  * Where an admission stands. `offered`: credentials issued and waiting for the member to collect and accept them. `admitted`: accepted — on a sealed tier, the member is in the room's group. `removed`: an administrator removed them; on a sealed tier the room has advanced past them.
  */
 export type MemberState = "offered" | "admitted" | "removed";
+/**
+ * `MemberState` plus `suspended`. `offered`: credentials issued and waiting for the member to collect and accept them. `admitted`: accepted — on a sealed tier, the member is in the room's group. `suspended`: admitted, but the room was archived with `noAccess` (or scheduled for removal), so the room's host refuses the member's credentials; on a sealed tier they are still in the room's group. Restored to `admitted` with freshly issued credentials when the room leaves that state, and never restored if it is removed. `removed`: an administrator removed them, or withdrew their offer — archiving withdraws every open offer; on a sealed tier the room has advanced past an admitted member.
+ */
+export type MemberStateV2 = "offered" | "admitted" | "suspended" | "removed";
 /**
  * How the member came to be in the group. `added`: by a manager. `joined`: they joined an open group. `requestApproved`: a manager approved their request. `rule`: a dynamic group's rule admits them.
  */
@@ -1004,6 +1024,10 @@ export type NoteId = string;
  * The note, as plain text. Read only by holders of `vtc.directory.notes`. A reader MUST NOT treat it as instructions.
  */
 export type NoteText = string;
+/**
+ * The originator's identifier for one notification, unique among the notifications that originator issues and the same in every document that carries it — retries, re-issued documents and relayed copies alike. It is the notification's idempotency key (VTI-NTF-021). Compared for equality only. An originator SHOULD make it unguessable and SHOULD NOT make it descriptive: it travels as far as the notification does.
+ */
+export type NotificationId = string;
 /**
  * A key prefix inside the bucket, ending in `/`, under which the config's `rooms/` tree is placed. Restricted to the S3 safe-character set so that it can be placed in a downscoped policy without escaping.
  */
@@ -1356,6 +1380,10 @@ export type RecordEvidence = RecordEvidenceRecord | RecordEvidenceCredential;
  * @maxItems 32
  */
 export type RecordEvidenceList = [RecordEvidence, ...RecordEvidence[]];
+/**
+ * The VTA's own identifier for one held notification, stable across the revisions that replace it. Opaque and compared for equality only; unguessable, because a show of a record in a context the caller may not read is refused and an enumerable identifier would turn the refusal into an oracle.
+ */
+export type RecordId = string;
 /**
  * The path from one record's leaf to the room's `DataCommitment` — a Merkle inclusion proof, in the vocabulary this work already uses for it.
  *
@@ -1486,6 +1514,10 @@ export type RoomDescription = string;
  * A name for the room, chosen by an administrator: shown to administrators and to the members a room is offered to. Not part of the room's identity and never in anything a room's host can read. From `vtc/rooms/community/create` 0.3 and `vtc/rooms/community/update` 0.2 the community also writes it, through its own VTA, as the `name` of the room's own profile (`RoomProfile` in rooms/_shared), sealed inside the room for its members; earlier versions keep it out of the room altogether. MUST NOT carry personal data.
  */
 export type RoomLabel = string;
+/**
+ * Where a room the community owns stands in its owner's lifecycle — distinct from `HostedRoom.lifecycle`, which is the host's clock (`live`, `lapsed`, `dormant`, `reclaimable`) and is computed from the room's epoch, never set. `active`: open to change. `archived`: closed to change by an administrator — no admissions, and the room's host accepts no writes from its members; what members may still do is `ArchiveAccess`. Reversible with vtc/rooms/community/unarchive. `removalScheduled`: an administrator removed the room with a grace period; it admits nobody and its content is kept until `purgeAt`, and vtc/rooms/community/removal/cancel returns it to `archived`. `purging`: the grace period ended (or there was none) and the community is deleting the room's content from its host and storage; not reversible. `removed`: the content is gone; the community keeps only this record of the room, for its history.
+ */
+export type RoomState = "active" | "archived" | "removalScheduled" | "purging" | "removed";
 /**
  * A short identifier an administrator files a community-owned room under — `board`, `working-group`, `finance` — so the room list can be filtered. Lower-case letters, digits and hyphens, starting with a letter or digit. Owner-side tracking metadata for holders of `vtc.rooms.manage` only: never shown to members, never sent on the room's host path, and it confers nothing.
  */
@@ -1677,6 +1709,14 @@ export type SiteTarget_VaultV0_2 = WebOrigin_VaultV0_2 | Did_VaultV0_2 | IosApp_
  * Other values are the holder's or the producer's own and carry no meaning a maintainer interprets.
  */
 export type Slot = string;
+/**
+ * The principal's disposition of a held notification: `active`, or `dismissed` by vta/notifications/dismiss. Dismissal is the principal's alone and changes nothing outside the VTA (VTI-NTF-052).
+ */
+export type State = "active" | "dismissed";
+/**
+ * Whether the thing is still open to the audience: `available`, or `withdrawn` — cancelled by its holder, or no longer open to the audience — in which case the recipient keeps the record only to show that it was withdrawn (VTI-NTF-024).
+ */
+export type Status = "available" | "withdrawn";
 /**
  * How the community authenticates to a config's backend. Absent on a `local` config, which needs none.
  *
@@ -6059,6 +6099,54 @@ export interface CommunityRoomV2_VtcV0_3 {
      */
     detailsUpdatedBy?: string;
 }
+/**
+ * What vtc/rooms/community/{get,list}/0.4 and vtc/rooms/community/{archive,unarchive,remove,removal/cancel}/0.1 return: `CommunityRoomV2` plus the room's `status` in its owner's lifecycle and the count of `suspended` admissions. A separate definition, not a change to `CommunityRoomV2`, so that the versions returning that keep the exact shape they published. For a room in state `purging` or `removed`, whose host record a purge deletes, `room` is the host record as it last stood before the purge began — the community keeps that snapshot with the room's record when the purge starts — and its `lifecycle` is what was computed then.
+ */
+export interface CommunityRoomV3 {
+    room: HostedRoom_VtcV0_3;
+    label: RoomLabel;
+    status: RoomStatus;
+    /**
+     * Absent when the room has none.
+     */
+    description?: RoomDescription;
+    /**
+     * Absent or empty when the room has none.
+     */
+    tags?: RoomTags;
+    /**
+     * The storage config receiving the room's new uploads.
+     */
+    storageConfig?: StorageConfigId;
+    /**
+     * Members in state `admitted`.
+     */
+    admitted: number;
+    /**
+     * Offers not yet accepted or withdrawn.
+     */
+    offered: number;
+    /**
+     * Admissions in state `suspended`: withdrawn while the room was archived with `noAccess`, and restored when it leaves that state. Absent when zero.
+     */
+    suspended?: number;
+    /**
+     * When the community's own `admin` authority over the room expires. A room whose owner's authority lapses can no longer advance its epoch, admit or remove; a community SHOULD renew it well before.
+     */
+    ownerAuthorityValidUntil?: string;
+    /**
+     * The administrator who created it.
+     */
+    createdBy?: string;
+    /**
+     * When `label`, `description` or `tags` last changed. Absent until the first change after creation. Distinct from `room.updatedAt`, which is the host record's and moves with the room's epoch and lifecycle.
+     */
+    detailsUpdatedAt?: string;
+    /**
+     * The administrator who made that change. Present exactly when `detailsUpdatedAt` is. The earlier values and who set them are in the community's audit trail, not here.
+     */
+    detailsUpdatedBy?: string;
+}
 /**
  * A community's portable configuration: its profile plus the configuration overrides a maintainer stores for itself. Deliberately excludes per-host layers (environment variables, on-disk config files) — those describe where a maintainer runs, not what the community is, and carrying them would make an import overwrite the target host's own deployment settings.
  *
@@ -7366,6 +7454,32 @@ export interface Disclosure {
      */
     coercionResistance: false;
 }
+/**
+ * The statement a community publishes, and shows a member before they request a ticket, about how one election is run (VTI-VOT-090). Generated from the election's manifest and the community's configuration, never written by hand. Under a `credential` roll it also says whose membership credential counts (`rollCredential`).
+ */
+export interface Disclosure_VotingV0_4 {
+    /**
+     * The ballot box's DID.
+     */
+    ballotBox: string;
+    /**
+     * Who operates the ballot box, as the community names them.
+     */
+    ballotBoxOperator: string;
+    /**
+     * Whether the party operating the community's VTC also operates the ballot box.
+     */
+    sameOperator: boolean;
+    trustees?: Trustees;
+    boardVisibility: BoardVisibility;
+    auditors: string[];
+    revote: Revote;
+    rollCredential?: RollCredentialDisclosure;
+    /**
+     * Always false: a voter can prove how they voted, so the community cannot protect a member against being made to vote a certain way.
+     */
+    coercionResistance: false;
+}
 /**
  * The member's three discoverability decisions, made separately.
  */
@@ -8373,6 +8487,40 @@ export interface GroupMember {
      */
     credentialValidUntil?: string;
 }
+/**
+ * One notification the VTA holds, as a client with standing in its context sees it. `originator` and every entry of `relayedBy` were verified by the VTA when it accepted the notification (VTI-NTF-042); a client that does not take the VTA's word for them reads the document with vta/notifications/show and verifies it itself.
+ */
+export interface HeldNotification {
+    recordId: RecordId;
+    contextId: ContextId;
+    /**
+     * The principal's DID the notification, or the relay that delivered it, was addressed to.
+     */
+    addressee: Did_NotificationsV0_1;
+    /**
+     * The issuer of the notifications/notify document: who said the thing exists.
+     */
+    originator: Did_NotificationsV0_1;
+    /**
+     * The relayers the held revision passed through, in the order they relayed it: the first is the notification's own addressee, the last the relayer that delivered it to `addressee`. Empty for a notification the originator sent to `addressee` directly. The acceptance policy counted the last one (VTI-NTF-031).
+     *
+     * @maxItems 4
+     */
+    relayedBy: [] | [Did_NotificationsV0_1] | [Did_NotificationsV0_1, Did_NotificationsV0_1] | [Did_NotificationsV0_1, Did_NotificationsV0_1, Did_NotificationsV0_1] | [Did_NotificationsV0_1, Did_NotificationsV0_1, Did_NotificationsV0_1, Did_NotificationsV0_1];
+    /**
+     * The notification's members at the revision held.
+     */
+    notification: Notification;
+    state: State;
+    /**
+     * When the VTA accepted the revision held.
+     */
+    receivedAt: string;
+    /**
+     * When the principal dismissed it. Present exactly when `state` is `dismissed`.
+     */
+    dismissedAt?: string;
+}
 /**
  * The applicant's proof that distinct eligible vetters of the community vetted it, as a join submission carries it under `extensions.hiddenVetting`. Built by vta/pcs/prove, verified by the community.
  */
@@ -9290,6 +9438,51 @@ export interface Manifest_VotingV0_3 {
      */
     textReleaseThreshold: number;
 }
+/**
+ * What an election asks and how it is decided (VTI-VOT-010). Its digest (`manifestDigest`) is the SHA-256 multihash of its RFC 8785 (JCS) canonicalization, and every cast is bound to it (VTI-VOT-011).
+ */
+export interface Manifest_VotingV0_4 {
+    electionId: ElectionId;
+    /**
+     * The community's DID.
+     */
+    community: string;
+    title?: string;
+    description?: string;
+    /**
+     * @minItems 1
+     * @maxItems 128
+     */
+    questions: [Question, ...Question[]];
+    secrecy: SecrecyLevel;
+    roll: RollRule_VotingV0_4;
+    registrationOpensAt: string;
+    votingOpensAt: string;
+    votingClosesAt: string;
+    revote: Revote;
+    board: {
+        visibility: BoardVisibility;
+        auditors: string[];
+    };
+    /**
+     * The DID of the voting service that holds the board.
+     */
+    ballotBox: string;
+    trustees?: Trustees;
+    /**
+     * Whether the community treats the result as deciding something; creating a binding election takes another administrator's consent (VTI-VOT-081).
+     */
+    binding: boolean;
+    allowEarlyClose: boolean;
+    /**
+     * Open elections only: whether running totals may be read while voting is open (VTI-VOT-061).
+     */
+    resultsBeforeClose: boolean;
+    /**
+     * Counted ballots required before any text answer is disclosed (VTI-VOT-065). At least 1, and SHOULD be at least 10: a written answer can identify its author by what it says or how it is phrased, and the fewer the ballots released together, the easier that is. Where it is below 10, the disclosure a member is shown before they request a ticket MUST say so, and MUST say that a written answer may identify its author (VTI-VOT-090).
+     */
+    textReleaseThreshold: number;
+}
 /**
  * The mediator's per-account access-control capability set, expressed as named booleans (the transport-agnostic form of the mediator's internal capability flags). On a set request, members omitted are left unchanged; a get/response carries the full realized set.
  */
@@ -9719,6 +9912,46 @@ export interface MonitorFilter {
      */
     failuresOnly?: boolean;
 }
+export interface NetworkMembership {
+    /**
+     * The network's DID.
+     */
+    network: string;
+    /**
+     * Where the network's API is reached: the base its `/.well-known/vtn` profile is served under.
+     */
+    url: string;
+    /**
+     * The network's name, as its profile gives it.
+     */
+    name?: string;
+    /**
+     * `acknowledged`: the community is a member — it signed the acknowledgement of the network's grant. `repudiated`: the community rejected the network's listing of it. `departed`: the community left, by repudiating the grant.
+     */
+    state: "acknowledged" | "repudiated" | "departed";
+    /**
+     * The network's listing credential naming the community, as the community verified it.
+     */
+    listing: {};
+    /**
+     * The network's membership grant (VMC), once the community acknowledged.
+     */
+    grant?: {};
+    /**
+     * The community's acknowledgement (VMC carrying the grant's digest).
+     */
+    acknowledgement?: {};
+    /**
+     * The community's repudiation (VSC) of the listing, or — on departure — of the grant.
+     */
+    repudiation?: {};
+    /**
+     * @maxItems 64
+     */
+    groups: RegisteredGroup[];
+    joinedAt?: string;
+    updatedAt: string;
+}
 /**
  * The discoverability a card has when the community creates it, before its member chooses. A new card is never published beyond the community (VTI-DIR-042), so there is no member for that here: `externalCards` says whether the member may turn it on.
  */
@@ -9736,6 +9969,35 @@ export interface NewCardDefaults {
      */
     introductions?: Introductions;
 }
+/**
+ * The members of one notification, as notifications/notify carries them and as a recipient's agent records them. The originator is the `issuer` of the notifications/notify document and the addressee its `recipient`; neither is repeated here, because the originator's proof covers both.
+ */
+export interface Notification {
+    notificationId: NotificationId;
+    /**
+     * The revision of this notification. A recipient replaces the record it holds with a higher revision and leaves it unchanged for an equal or lower one (VTI-NTF-022). The first revision is 1.
+     */
+    revision: number;
+    kind: Kind_NotificationsV0_1;
+    subject: Subject;
+    /**
+     * The DID whose holders or members the thing concerns — for an election under a credential roll, the DID the roll names (`roll.memberOf`); otherwise the community's own. It says whom the thing is for, not that the recipient is one of them: a recipient may be the audience itself, or a party the audience relayed the notification to.
+     */
+    audience: Did_NotificationsV0_1;
+    status: Status;
+    /**
+     * Whether the addressee may relay this notification to the parties it stands for (notifications/relay). The originator states it explicitly; an addressee MUST NOT relay a notification whose `relayable` is false, or whose kind may not be relayed (VTI-NTF-041).
+     */
+    relayable: boolean;
+    /**
+     * When the thing can first be acted on — for an election, when voting opens. Absent: it can be acted on now.
+     */
+    validFrom?: string;
+    /**
+     * When the thing can no longer be acted on, and the notification lapses — for an election, when voting closes. A recipient discards a notification received after it (VTI-NTF-032). Absent: the kind's definition says when it lapses.
+     */
+    validUntil?: string;
+}
 /**
  * A community's offer of admission to a room it owns, as the member it is addressed to sees it.
  */
@@ -9879,6 +10141,24 @@ export interface PeerDepth {
     bytes: number;
     oldestAgeSeconds?: number;
 }
+/**
+ * A change of state the community began and has not finished, because a step at its VTA did not complete — most often a room reset the host accepted, after which the community's own credentials must be re-issued before it can act on the room again. `RoomStatus.state` stays what it was until the change finishes, but what the room's host enforces may already be the new state's: a pending move to `noAccess` means members' credentials may already be refused. The community finishes it by itself, retrying with backoff, and repeating the request that began it finishes it too; nothing else changes the room until it is finished.
+ */
+export interface PendingChange {
+    /**
+     * The state the change leads to.
+     */
+    state: RoomState;
+    /**
+     * The access it leads to, where `state` has one.
+     */
+    access?: ArchiveAccess;
+    beganAt: string;
+    /**
+     * What stopped the last attempt, for an administrator. Plain text; it names no member and carries no credential.
+     */
+    lastError?: string;
+}
 /**
  * What the author permits the record to be used for — for example, that a learner's record is for instructional personalisation only. OPTIONAL; absent means the author stated no limit beyond the room's own terms.
  *
@@ -10380,6 +10660,24 @@ export interface PublishedEvent {
     groupFloor: number;
     tiers: Tier[];
 }
+/**
+ * How a purge is going. A purge deletes at the room's host and at each storage config holding its files, and some of those are remote; a step that fails is retried with backoff until it succeeds, and nothing is reported removed until every step has.
+ */
+export interface PurgeProgress {
+    /**
+     * Passes made so far; 0 until the first.
+     */
+    attempts: number;
+    lastAttemptAt?: string;
+    /**
+     * When the next pass is due. Absent while one runs.
+     */
+    nextAttemptAt?: string;
+    /**
+     * What stopped the last pass, for an administrator. Present only after a pass failed. Plain text, written by the community; it names no member and carries no credential.
+     */
+    lastError?: string;
+}
 export interface Apns {
     platform: "apns";
     /**
@@ -10873,6 +11171,33 @@ export interface RegisteredCredential {
      */
     lastUsedAt?: string;
 }
+export interface RegisteredGroup {
+    /**
+     * A role the network defines, e.g. `admins`: lowercase letters, digits, `-` and `_`.
+     */
+    role: string;
+    /**
+     * The community's identifier for the group.
+     */
+    groupId: string;
+    /**
+     * The group's own DID, which the registration names as its subject.
+     */
+    groupDid: string;
+    /**
+     * Where the network delivers broadcasts for the group: the community's relay endpoint for it.
+     */
+    endpoint: string;
+    /**
+     * The community's `servesRole` statement (VSC): the group serves `role` in the network.
+     */
+    registration: {};
+    /**
+     * The network's `groupRegistered` statement (VSC), bound to the registration's digest.
+     */
+    acceptance: {};
+    registeredAt: string;
+}
 /**
  * The `ServiceInstance` shape of `did-management/_shared/0.1`, with `lastSeen` renamed `lastSeenAt`; named apart from `service-instance.schema.json`'s `ServiceInstance`, a different shape, so the two do not collide in generated code.
  */
@@ -11312,6 +11637,16 @@ export interface RightRecord_GitNsV0_6 {
      */
     breakGlass?: BreakGlass_GitNsV0_6;
 }
+export interface RoleAssignment {
+    /**
+     * A role the network defines, e.g. `admins`: lowercase letters, digits, `-` and `_`.
+     */
+    role: string;
+    /**
+     * The community group to serve the role.
+     */
+    groupId: string;
+}
 /**
  * A grant set by reference: the capability ceiling of a defined role, conferred as resource grants exactly as a `grants` binding confers its list. It never assigns the role itself — an entry's administrative role and its community role stay direct assignments.
  */
@@ -11477,6 +11812,27 @@ export interface RoleSummary {
      */
     preRotationCommitments?: number;
 }
+/**
+ * Under a `credential` roll, whose membership credential admits a party to a ticket, as a member is shown it before they claim one (VTI-VOT-090): the DID the roll names, what kind of party it is to this community, and its name as the community knows it. Present in a disclosure exactly when the election's roll rule is `credential`.
+ */
+export interface RollCredentialDisclosure {
+    /**
+     * The manifest's `roll.memberOf`.
+     */
+    memberOf: string;
+    /**
+     * `thisCommunity`: the community itself. `communityGroup`: one of the community's own groups, whose membership credentials it authorizes the group to issue (VTI-DIR-083). `memberParty`: a party outside the community that is itself an active member of it — another community, a group of another community, or a network — whose own membership credentials admit their holders (VTI-VOT-026).
+     */
+    memberOfKind: "thisCommunity" | "communityGroup" | "memberParty";
+    /**
+     * The name the community shows for the party `memberOf` names: the group's name, or the member party's name as the community's records hold it. Absent where showing it would disclose more than the group's visibility admits (VTI-DIR-070).
+     */
+    memberOfName?: string;
+    /**
+     * Always true: claiming a ticket shows the community the presenter's membership credential for `memberOf`, so the community learns that the presenter is a member of that party.
+     */
+    presenterDisclosed?: true;
+}
 /**
  * Who may be issued a ticket (VTI-VOT-021): the community's active members, its active members and the parties `listed` names, or only the parties `listed` names.
  */
@@ -11484,6 +11840,17 @@ export interface RollRule {
     rule: "members" | "membersAndListed" | "listed";
     listed?: string[];
 }
+/**
+ * Who may be issued a ticket (VTI-VOT-021): the community's active members (`members`), its active members and the parties `listed` names (`membersAndListed`), only the parties `listed` names (`listed`), or the holders of a membership credential for the one DID `memberOf` names (`credential`), proven by presentation when the holder claims their ticket and never resolved when the election is created (VTI-VOT-025). `memberOf` is present exactly when `rule` is `credential`, and `listed` is never present with it.
+ */
+export interface RollRule_VotingV0_4 {
+    rule: "members" | "membersAndListed" | "listed" | "credential";
+    listed?: string[];
+    /**
+     * The DID whose membership credential admits its holder, under the `credential` rule: this community, one of its groups, or a party that is itself an active member of this community — holding a membership credential this community issued it — such as another community, a group of another community, or a network (VTI-VOT-026). Always a DID, never a group's local identifier or name. A community refuses to create an election naming any other DID (vtc/elections/create:rollUntrusted).
+     */
+    memberOf?: string;
+}
 /**
  * The outcome of a rollback. Distinct from ServiceMutationResult because a rollback can legitimately publish nothing: if the previous state already equals the current one there is no change to write, and `kind: "noOp"` says so with `logEntryVersionId` absent. Treating that as a failure would be wrong — the requested state holds — and treating it as an ordinary success would report a log entry that does not exist.
  */
@@ -11599,6 +11966,25 @@ export interface RoomMember {
     admittedAt?: string;
     removedAt?: string;
 }
+/**
+ * `RoomMember` with `MemberStateV2`, and `suspendedAt`.
+ */
+export interface RoomMemberV2 {
+    member: string;
+    actions: MemberActions;
+    /**
+     * When the member's authority credential expires.
+     */
+    validUntil: string;
+    state: MemberStateV2;
+    offeredAt: string;
+    admittedAt?: string;
+    removedAt?: string;
+    /**
+     * Present exactly when `state` is `suspended`.
+     */
+    suspendedAt?: string;
+}
 /**
  * What vtc/rooms/memberships/list/0.1 returns: one room the community owns, and where the caller's admission to it stands in the community's own record. Unlike `OfferV2` it carries no credentials — those are collected with vtc/rooms/offers/list while an offer is open — and it is listed in every state, for as long as the community keeps the record, not only while an accept can be repeated. `label` and `description` are the room's as they stand when the record is read.
  */
@@ -11634,6 +12020,57 @@ export interface RoomMembership {
      */
     repeatAcceptUntil?: string;
 }
+/**
+ * What vtc/rooms/memberships/list/0.2 returns: `RoomMembership` with `MemberStateV2`, `suspendedAt`, and the room's own state, so that a member can tell a room that is read-only, closed or going away from one they were removed from.
+ */
+export interface RoomMembershipV2 {
+    roomId: string;
+    /**
+     * The room's host: this community.
+     */
+    host: string;
+    label: RoomLabel;
+    /**
+     * Absent when the room has none.
+     */
+    description?: RoomDescription;
+    visibility: Visibility;
+    actions: MemberActions;
+    /**
+     * When the member's authority credential expires.
+     */
+    validUntil: string;
+    state: MemberStateV2;
+    offeredAt: string;
+    /**
+     * When the community recorded the admission. Present when `state` is `admitted`, and kept when it becomes `removed`.
+     */
+    admittedAt?: string;
+    /**
+     * Present exactly when `state` is `removed`.
+     */
+    removedAt?: string;
+    /**
+     * On an `attributed` or `private` room in state `admitted`: until when the community keeps the Welcome, so that a repeated vtc/rooms/offers/accept carrying the same KeyPackage is answered with it. Absent on an `open` room, in any other state, and once the community no longer keeps it. A surface finding the member admitted but the room absent from its key holder's rooms/keys/list finishes the acceptance before this time, and asks an administrator to re-admit the member after it.
+     */
+    repeatAcceptUntil?: string;
+    /**
+     * Present exactly when `state` is `suspended`.
+     */
+    suspendedAt?: string;
+    /**
+     * The room's state in its owner's lifecycle. `purging` is shown to members as `removalScheduled`: to them, the room is going away either way.
+     */
+    roomState: RoomState;
+    /**
+     * Present exactly when `roomState` is `archived` or `removalScheduled`.
+     */
+    roomAccess?: ArchiveAccess;
+    /**
+     * Present when `roomState` is `removalScheduled`: when the room's content is to be deleted.
+     */
+    purgeAt?: string;
+}
 /**
  * What a room says about itself to its own members: a name and, optionally, a description, short tags and an emoji, so that a member's wallet, portal or CLI can show what each room is rather than a DID.
  *
@@ -11681,6 +12118,44 @@ export interface RoomRevocation {
      */
     until?: string;
 }
+/**
+ * A room's state in its owner's lifecycle, and what that state needs to be understood.
+ */
+export interface RoomStatus {
+    state: RoomState;
+    /**
+     * Present exactly when `state` is `archived` or `removalScheduled`; always `noAccess` for `removalScheduled`.
+     */
+    access?: ArchiveAccess;
+    /**
+     * When the room entered `state`. Absent for a room that has been `active` since it was created.
+     */
+    changedAt?: string;
+    /**
+     * The administrator whose act put the room in `state`. Present exactly when `changedAt` is, except for `purging` and `removed` reached when a grace period ended, which no one did at that moment: then the administrator who scheduled the removal. The reason each gave is in the community's audit trail, not here.
+     */
+    changedBy?: string;
+    /**
+     * Present when `state` is `removalScheduled`: when the grace period ends and the purge begins. Kept when `state` is `purging` or `removed`, as when it became due.
+     */
+    purgeAt?: string;
+    /**
+     * Present exactly when `state` is `purging`.
+     */
+    purge?: PurgeProgress;
+    /**
+     * Present exactly when `state` is `removed`: when the last of the room's content was deleted.
+     */
+    removedAt?: string;
+    /**
+     * Admissions still `suspended` that the community is restoring, after the room left `noAccess` — the room re-issues each member's credentials and the member collects them as a renewal. Absent when there are none.
+     */
+    restoring?: number;
+    /**
+     * Present while a change of state is begun and not finished.
+     */
+    pendingChange?: PendingChange;
+}
 /**
  * One change to a role's key set, from preview to completion. The rotation history of a DID is the list of these; the log is the authority for what was published, and this record adds what the log cannot say — which change was which, and (custody projection only) who asked, who approved, and why.
  */
@@ -12646,6 +13121,23 @@ export interface StreamDescriptor {
     expectedSizeBytes: ExpectedSizeBytes;
     expiresAt: ExpiresAt;
 }
+/**
+ * Where the thing is and how to open it. Only these three members: what the thing contains is shown by its holder, to a reader it admits, when the thing is opened with `openWith`.
+ */
+export interface Subject {
+    /**
+     * The DID of the party holding the thing — for an election, the community. The party a recipient sends `openWith` to.
+     */
+    heldBy: Did_NotificationsV0_1;
+    /**
+     * The thing's identifier at `heldBy`, in the form the `openWith` task takes it — for an election, its `electionId`.
+     */
+    id: string;
+    /**
+     * The Type URI of the Trust Task by which a recipient opens the thing at `heldBy` — for an election, `https://trusttasks.org/spec/vtc/elections/show/0.6`. A recipient opens it only at its principal's choice (VTI-NTF-053), and only by a version of that task it and `heldBy` both serve.
+     */
+    openWith: string;
+}
 /**
  * Withdraws a party: every credential naming them as subject or issuer whose `validFrom` is earlier than `revokedAt`.
  */