@seriousgaming/sdk-tools 0.0.0-stage → 1.0.0-alpha.1

package/dist/host/protocol.d.ts

@@ -0,0 +1,783 @@
+/**
+ * The host ↔ iframe MessagePort protocol (§12), as the host speaks it.
+ *
+ * Platform-facing, exported from
+ * `@seriousgaming/sdk-tools/host`. The guest half of the
+ * same protocol is private to the UI wrappers in
+ * `@seriousgaming/sdk/ui`: game code never sees a wire
+ * message, so the SDK does not export one. Each package therefore holds its
+ * own definition, and `protocol.parity.test.ts` fails to compile the moment
+ * the two disagree, so extending a union here without extending the guest's
+ * (or the reverse) is caught before either ships.
+ */
+import type { ContextDeletePath, EndpointFailure, HostOverlay, Participant, PastStateEntry, PastStateQuery, ThemePreference, TimerState, ValidationRejection } from '@seriousgaming/sdk';
+import type { CrossTeamData, MutationOutcome, OwnTeamJoinLink, PresentationGame, PresentationSession, RunKind, SessionData, SessionHookFailure, SessionMeta, SharedState, TeamConfiguration, TeamInfo, TeamLinks, TeamState, UserInterfaceLocale, UserInterfaceTheme, ViewerRole, WalkthroughLink } from '@seriousgaming/sdk/ui';
+/**
+ * Version of the host↔iframe handshake protocol. Both ends stamp it on the
+ * `ready`/`init` window messages and warn (without blocking) when the peer's
+ * declared version differs, so a host and an SDK build that have drifted apart
+ * surface a diagnostic instead of failing silently. Bump on any
+ * backwards-incompatible change to the handshake or port message contract.
+ *
+ * Version 2 adds `updateTeamState`: a host may deliver an ongoing session-data
+ * change as one team's state rather than the whole session's, and a session
+ * wrapper merges it. `setSessionData` remains the full snapshot on handshake
+ * and on resync, so a host that only ever sends the snapshot is still
+ * conformant.
+ *
+ * Version 3 gives shared state its own channel: `SessionData` carries the
+ * shared store once as `shared`, each team's `context` carries team scope
+ * only, and `updateSharedState` delivers a change to the store as one message
+ * rather than one per team.
+ *
+ * Version 4 gives each concept one name (#634): the context push `setData`
+ * becomes `stateChanged`, carrying `completedTicks` where it carried `tick`;
+ * `updateConfig` becomes `updateSettings`; a settings editor receives
+ * `setSettings` in place of `setResolvedConfiguration`; `extendTick` carries
+ * `byMs`; `pauseTimer` and `resumeTimer` carry a `requestId`; timers are one
+ * `TimerState` in milliseconds; participants and teams share one shape; and
+ * a failed `callEndpoint:response` carries an `EndpointFailure` (`outcome`,
+ * `applied`, `failedStep`) where it carried an `error` string (#636); and
+ * configuration UIs become the `setup` and `scenario_editor` slots, which are
+ * sent no `setConfigurationSurface` (#637). `init` carries the `sessionKey` a
+ * surface namespaces its own storage by, and every theme colour carries a
+ * `contrastText` (#638).
+ * Version 3 never shipped, so version 4 is the version that ships with
+ * manifest version 3, and a host serving an earlier package speaks the
+ * version that package was built for.
+ *
+ * There is deliberately no capability-negotiation list here. The version alone
+ * is the gate, and it can be, because no published package predates the
+ * feature: it ships in the same release as manifest version 2, and a host
+ * serving a version 1 package sends full snapshots to it.
+ */
+export declare const UI_PROTOCOL_VERSION = 4;
+/** Window-level message: iframe → host. Signals the iframe is ready to establish a port. */
+export type IFrameMessage = {
+    type: 'ready';
+    protocolVersion: number;
+};
+/**
+ * Window-level message: host → iframe. Carries port2 as a transfer.
+ *
+ * `sessionKey` is opaque, stable for the run, unique to it, and names nothing
+ * the host would act on: a namespace for the surface's own browser storage,
+ * never an address for the session (§12.2).
+ */
+export type HostWindowMessage = {
+    type: 'init';
+    protocolVersion: number;
+    sessionKey: string;
+};
+/**
+ * Absolute URL prefixes the runtime supplies to UI wrappers so they can build
+ * asset URLs synchronously from an asset reference. Wrappers strip the
+ * `asset:`, `shared:`, or `blob:` scheme from the reference and concatenate the
+ * remainder with the matching prefix. All prefixes MUST end with `/`. The
+ * runtime bakes any active scenario version into `scenarioAssetPrefix` and does
+ * not re-escape the path argument. `assetAuthRedeemUrl` is the absolute URL the
+ * iframe POSTs a token to (with `credentials: 'include'`) to refresh the
+ * asset-domain cookie when the host sends `refreshAssetAuth`.
+ */
+export interface AssetUrls {
+    /** Absolute prefix prepended to a `blob:<id>` reference's id. */
+    blobPrefix: string;
+    /** Absolute prefix prepended to an `asset:<path>` reference's path. */
+    scenarioAssetPrefix: string;
+    /** Absolute prefix prepended to a `shared:<path>` reference's path. */
+    sharedAssetPrefix: string;
+    /** Absolute URL the iframe POSTs to to redeem an asset-auth token. */
+    assetAuthRedeemUrl: string;
+}
+/** Port messages sent from host to game UI iframe */
+export type HostPortMessage = {
+    type: 'ping';
+} | {
+    type: 'stateChanged';
+    payload: Record<string, unknown>;
+    completedTicks: number;
+} | {
+    type: 'setCrossTeamData';
+    payload: CrossTeamData;
+}
+/**
+ * The settings resources this surface declared, resolved and keyed by
+ * identifier (§8). Sent on load and whenever they change, never with a
+ * context write.
+ */
+ | {
+    type: 'setSettings';
+    payload: Record<string, Record<string, unknown>>;
+} | {
+    type: 'setTheme';
+    payload: UserInterfaceTheme;
+} | {
+    type: 'setLocale';
+    payload: UserInterfaceLocale;
+} | {
+    type: 'setParticipant';
+    payload: Participant;
+} | {
+    type: 'setViewerRole';
+    role: ViewerRole;
+}
+/**
+ * Whether this surface belongs to the game being played or to a walkthrough
+ * beside it (§5.7). Sent in the initial batch and never again: the kind is
+ * fixed for a run's lifetime, and the value the engine reads is the same
+ * one delivered here.
+ *
+ * The wrapper's `'session'` default is a fallback for a host predating this
+ * message, not a licence to leave it out (§12.3).
+ */
+ | {
+    type: 'setRunKind';
+    runKind: RunKind;
+} | {
+    type: 'setTimer';
+    payload: TimerState;
+}
+/**
+ * Whether a tick is being processed right now.
+ *
+ * Writes are unaffected: they are queued and applied after the tick, as
+ * they always were (§9.7). This message exists so a participant surface can
+ * say what is happening instead of appearing to have stopped responding —
+ * at a large cohort a lockstep tick takes long enough to notice, and a
+ * participant did not press the button, so they have nothing else to
+ * attribute the pause to.
+ */
+ | {
+    type: 'setRoundProcessing';
+    processing: boolean;
+} | {
+    type: 'setParticipantList';
+    participants: Participant[];
+} | {
+    type: 'setTeamList';
+    payload: TeamInfo[];
+}
+/**
+ * The team whose surface this iframe is rendering (#332). Sent to player
+ * surfaces, for observers as well as participants, since the host always
+ * knows which team it mounted and an observer has no participant to derive
+ * it from. Advisory rather than required: a wrapper that never
+ * receives it falls back to resolving `participant.teamId` against the team
+ * list, so a host predating this message still serves participants.
+ */
+ | {
+    type: 'setOwnTeam';
+    payload: TeamInfo;
+}
+/**
+ * How to join this surface's own team (#493). Sent to every player surface,
+ * observers included, since a kiosk showing a join code is most naturally
+ * opened as an observer and has no participant of its own.
+ *
+ * Not the facilitator's `setTeamLinks`: one team rather than all of them, no
+ * `observeUrl`, and never the session PIN. A join URL alone admits nobody to
+ * a session that requires a PIN.
+ */
+ | {
+    type: 'setOwnTeamJoinLink';
+    payload: OwnTeamJoinLink;
+} | {
+    type: 'setAssetUrls';
+    payload: AssetUrls;
+} | {
+    type: 'refreshAssetAuth';
+    requestId: string;
+    token: string;
+} | {
+    type: 'uploadBlob:response';
+    requestId: string;
+    ok: true;
+    reference: string;
+} | {
+    type: 'uploadBlob:response';
+    requestId: string;
+    ok: false;
+    error: string;
+} | {
+    type: 'callEndpoint:response';
+    requestId: string;
+    ok: true;
+    response: unknown;
+} | ({
+    type: 'callEndpoint:response';
+    requestId: string;
+    ok: false;
+} & EndpointFailure) | {
+    type: 'getPastState:response';
+    requestId: string;
+    ok: true;
+    entries: PastStateEntry[];
+} | {
+    type: 'getPastState:response';
+    requestId: string;
+    ok: false;
+    error: string;
+} | {
+    type: 'getAllTeamsParticipants:response';
+    requestId: string;
+    ok: true;
+    participants: Participant[];
+} | {
+    type: 'getAllTeamsParticipants:response';
+    requestId: string;
+    ok: false;
+    error: string;
+} | {
+    type: 'themePreferenceChanged';
+    preference: ThemePreference;
+} | {
+    type: 'mutation:response';
+    requestId: string;
+    ok: true;
+    /**
+     * The tick the write committed into. The surface compares it
+     * against the tick it was showing when the write was composed: a
+     * higher value means the round advanced first, so the write belongs
+     * to the round after the one the participant was looking at (§9.5).
+     */
+    committedAtTick?: number;
+} | {
+    type: 'mutation:response';
+    requestId: string;
+    ok: false;
+    outcome: MutationOutcome;
+} | {
+    type: 'validationRejected';
+    rejections: ValidationRejection[];
+};
+/** Port messages sent from game UI iframe to host */
+export type IFramePortMessage = {
+    type: 'pong';
+} | {
+    type: 'updateData';
+    requestId?: string;
+    payload: Record<string, unknown>;
+    /** Paths to remove, applied after the patch merges (§9.5). */
+    deletes?: ContextDeletePath[];
+} | {
+    type: 'setThemePreference';
+    preference: ThemePreference;
+} | {
+    type: 'refreshAssetAuth:response';
+    requestId: string;
+    ok: true;
+} | {
+    type: 'refreshAssetAuth:response';
+    requestId: string;
+    ok: false;
+    error: string;
+} | {
+    type: 'callEndpoint';
+    requestId: string;
+    endpointIdentifier: string;
+    request: unknown;
+} | {
+    type: 'getPastState';
+    requestId: string;
+    query: PastStateQuery;
+} | {
+    type: 'getAllTeamsParticipants';
+    requestId: string;
+} | {
+    type: 'requestTick';
+    requestId?: string;
+}
+/**
+ * Rename the team this surface belongs to (#494). Carries no `teamId`: the
+ * host resolves the caller's team itself, so no surface can name another's.
+ */
+ | {
+    type: 'renameOwnTeam';
+    requestId?: string;
+    name: string;
+} | {
+    type: 'uploadBlob';
+    requestId: string;
+    data: ArrayBuffer;
+    name: string;
+    mimeType: string;
+};
+/** Port messages sent from host to session UI iframe */
+export type HostSessionPortMessage = {
+    type: 'ping';
+} | {
+    type: 'setSessionMeta';
+    payload: SessionMeta;
+} | {
+    type: 'setSessionData';
+    payload: SessionData;
+}
+/**
+ * One team's state, as an ongoing update in place of a whole-session
+ * `setSessionData`. Protocol version 2 and later.
+ *
+ * `SessionData` carries every team's context, so at a hundred teams a
+ * facilitator surface receives a hundred contexts every time one
+ * participant types. This delivers the team that changed. The wrapper
+ * merges it into the same `SessionData` the surface already reads, so a
+ * game sees no difference.
+ *
+ * `state.revision` is monotonic per team. A wrapper that receives a
+ * revision more than one ahead of what it holds has missed an update and
+ * asks for a fresh snapshot with `resyncSessionData`, which is what makes
+ * the scheme self-healing rather than dependent on ordered delivery.
+ */
+ | {
+    type: 'updateTeamState';
+    teamId: string;
+    state: TeamState;
+}
+/**
+ * The shared store, as an ongoing update in place of a whole-session
+ * `setSessionData`. Protocol version 3 and later. `state.revision` is
+ * monotonic, and a gap is repaired with `resyncSessionData` exactly as a
+ * per-team one is.
+ */
+ | {
+    type: 'updateSharedState';
+    state: SharedState;
+}
+/**
+ * The settings resources this surface declared, resolved and keyed by
+ * identifier (§8). Sent on load and whenever they change, never with a
+ * context write.
+ */
+ | {
+    type: 'setSettings';
+    payload: Record<string, Record<string, unknown>>;
+} | {
+    type: 'setTheme';
+    payload: UserInterfaceTheme;
+} | {
+    type: 'setLocale';
+    payload: UserInterfaceLocale;
+} | {
+    type: 'setTeamList';
+    payload: TeamInfo[];
+} | {
+    type: 'setTeamConfiguration';
+    payload: TeamConfiguration;
+} | {
+    type: 'setParticipantList';
+    participants: Participant[];
+}
+/**
+ * Facilitator-only. A join URL plus the session PIN is joinable capability,
+ * so it travels on its own message to this surface alone rather than as a
+ * field on TeamInfo, which player surfaces also receive.
+ */
+ | {
+    type: 'setTeamLinks';
+    payload: TeamLinks[];
+}
+/**
+ * Whether this session surface belongs to the game being played or to a
+ * walkthrough beside it (§5.7). Sent in the initial batch and never again.
+ */
+ | {
+    type: 'setRunKind';
+    runKind: RunKind;
+}
+/**
+ * Where to open the walkthrough run (§5.7). Every host offers one, so this
+ * always carries a link. Facilitator-only, and naming no team: a
+ * walkthrough holds one.
+ */
+ | {
+    type: 'setWalkthroughLink';
+    payload: WalkthroughLink;
+}
+/**
+ * Which host-owned overlays (§6.4) this host offers, so a surface renders a
+ * control only for one that exists. Sent in the initial batch and re-sent
+ * whenever the set changes, e.g. when a scenario switch changes whether the
+ * active game declares a facilitator guide.
+ */
+ | {
+    type: 'setAvailableOverlays';
+    overlays: HostOverlay[];
+}
+/**
+ * A hook chain threw. Reported after the fact rather than as a failed
+ * mutation: hooks fire after the change is applied, so the mutation that
+ * triggered them has already committed and settled.
+ */
+ | {
+    type: 'hookFailed';
+    payload: SessionHookFailure;
+} | {
+    type: 'setAssetUrls';
+    payload: AssetUrls;
+} | {
+    type: 'refreshAssetAuth';
+    requestId: string;
+    token: string;
+} | {
+    type: 'uploadBlob:response';
+    requestId: string;
+    ok: true;
+    reference: string;
+} | {
+    type: 'uploadBlob:response';
+    requestId: string;
+    ok: false;
+    error: string;
+} | {
+    type: 'callEndpoint:response';
+    requestId: string;
+    ok: true;
+    response: unknown;
+} | ({
+    type: 'callEndpoint:response';
+    requestId: string;
+    ok: false;
+} & EndpointFailure) | {
+    type: 'getPastState:response';
+    requestId: string;
+    ok: true;
+    entries: PastStateEntry[];
+} | {
+    type: 'getPastState:response';
+    requestId: string;
+    ok: false;
+    error: string;
+} | {
+    type: 'themePreferenceChanged';
+    preference: ThemePreference;
+} | {
+    type: 'mutation:response';
+    requestId: string;
+    ok: true;
+    /**
+     * The tick the write committed into. The surface compares it
+     * against the tick it was showing when the write was composed: a
+     * higher value means the round advanced first, so the write belongs
+     * to the round after the one the participant was looking at (§9.5).
+     */
+    committedAtTick?: number;
+} | {
+    type: 'mutation:response';
+    requestId: string;
+    ok: false;
+    outcome: MutationOutcome;
+} | {
+    type: 'validationRejected';
+    rejections: ValidationRejection[];
+    teamId?: string;
+};
+/** Port messages sent from session UI iframe to host */
+export type IFrameSessionPortMessage = {
+    type: 'pong';
+} | {
+    type: 'updateSessionData';
+    requestId?: string;
+    teamId: string;
+    payload: Record<string, unknown>;
+    /**
+     * Paths to remove from that team's context after the payload merges
+     * (§9.5), each under a team-scope capability the session UI declares
+     * in `writes`.
+     */
+    deletes?: ContextDeletePath[];
+} | {
+    type: 'updateSharedData';
+    requestId?: string;
+    payload: Record<string, unknown>;
+    /**
+     * Paths to remove from the shared store after the payload merges
+     * (§9.5.1), each under a shared capability the session UI declares in
+     * `writes`.
+     */
+    deletes?: ContextDeletePath[];
+}
+/**
+ * Ask the host for a fresh full `setSessionData`. Sent by the wrapper when
+ * a per-team revision arrives out of sequence, meaning an `updateTeamState`
+ * was lost, so the surface repairs itself rather than rendering a team's
+ * state indefinitely stale. Not a mutation: it carries no `requestId` and
+ * settles by the snapshot arriving.
+ */
+ | {
+    type: 'resyncSessionData';
+} | {
+    type: 'setThemePreference';
+    preference: ThemePreference;
+} | {
+    type: 'refreshAssetAuth:response';
+    requestId: string;
+    ok: true;
+} | {
+    type: 'refreshAssetAuth:response';
+    requestId: string;
+    ok: false;
+    error: string;
+} | {
+    type: 'callEndpoint';
+    requestId: string;
+    endpointIdentifier: string;
+    request: unknown;
+} | {
+    type: 'getPastState';
+    requestId: string;
+    query: PastStateQuery;
+} | {
+    type: 'requestTick';
+    requestId?: string;
+    teamId?: string;
+} | {
+    type: 'uploadBlob';
+    requestId: string;
+    data: ArrayBuffer;
+    name: string;
+    mimeType: string;
+} | {
+    type: 'pauseTimer';
+    requestId?: string;
+    teamId?: string;
+} | {
+    type: 'resumeTimer';
+    requestId?: string;
+    teamId?: string;
+}
+/**
+ * Move the deadline of the *currently scheduled* tick, without changing the
+ * interval the tick controller returns for the ticks after it. Positive
+ * `byMs` (milliseconds) buys the room more time; negative brings the
+ * deadline forward, clamped at now rather than firing retroactively.
+ */
+ | {
+    type: 'extendTick';
+    requestId?: string;
+    teamId?: string;
+    byMs: number;
+} | {
+    type: 'resetGame';
+    requestId?: string;
+    teamId?: string;
+} | {
+    type: 'undoTick';
+    requestId?: string;
+    teamId?: string;
+} | {
+    type: 'setWaitingRoom';
+    requestId?: string;
+    open: boolean;
+}
+/**
+ * Throw the walkthrough away and start it again at tick 0 (§5.7). Session-
+ * wide like `setWaitingRoom`, and settling the same way. Denied while
+ * there is no walkthrough yet: opening the link is what creates one.
+ */
+ | {
+    type: 'resetWalkthrough';
+    requestId?: string;
+}
+/**
+ * Ask the host to open one of its own overlays (§6.4). The host renders it;
+ * this delegates the trigger alone. `target` is the overlay's argument — a
+ * guide identifier for `facilitator-guide`, a team id for `print-sheets` —
+ * and omitting it means the whole thing (the first declared guide, every
+ * team). An overlay the host does not offer, or a `target` the active game
+ * does not declare, settles as denied.
+ */
+ | {
+    type: 'openHostOverlay';
+    requestId?: string;
+    overlay: HostOverlay;
+    target?: string;
+} | {
+    type: 'createTeam';
+    requestId?: string;
+    name?: string;
+} | {
+    type: 'renameTeam';
+    requestId?: string;
+    teamId: string;
+    name: string;
+} | {
+    type: 'renameParticipant';
+    requestId?: string;
+    participantId: string;
+    name: string;
+} | {
+    type: 'moveParticipant';
+    requestId?: string;
+    participantId: string;
+    teamId: string;
+} | {
+    type: 'deleteTeam';
+    requestId?: string;
+    teamId: string;
+};
+/** Port messages sent from host to a settings editor iframe (§6.5) */
+export type HostSettingsEditorPortMessage = {
+    type: 'ping';
+}
+/**
+ * The **resolved** values of the settings this editor
+ * `configures`, keyed by settings identifier (§8.3): the same message,
+ * and the same shape, as every other surface's `setSettings`. Resolved
+ * rather than the sparse override layer, which for a fresh session is
+ * `{}` and would seed the form with nothing.
+ */
+ | {
+    type: 'setSettings';
+    payload: Record<string, Record<string, unknown>>;
+} | {
+    type: 'setTheme';
+    payload: UserInterfaceTheme;
+} | {
+    type: 'setLocale';
+    payload: UserInterfaceLocale;
+} | {
+    type: 'setAssetUrls';
+    payload: AssetUrls;
+} | {
+    type: 'refreshAssetAuth';
+    requestId: string;
+    token: string;
+} | {
+    type: 'uploadBlob:response';
+    requestId: string;
+    ok: true;
+    reference: string;
+} | {
+    type: 'uploadBlob:response';
+    requestId: string;
+    ok: false;
+    error: string;
+} | {
+    type: 'callEndpoint:response';
+    requestId: string;
+    ok: true;
+    response: unknown;
+} | ({
+    type: 'callEndpoint:response';
+    requestId: string;
+    ok: false;
+} & EndpointFailure) | {
+    type: 'mutation:response';
+    requestId: string;
+    ok: true;
+    /**
+     * The tick the write committed into. The surface compares it
+     * against the tick it was showing when the write was composed: a
+     * higher value means the round advanced first, so the write belongs
+     * to the round after the one the participant was looking at (§9.5).
+     */
+    committedAtTick?: number;
+} | {
+    type: 'mutation:response';
+    requestId: string;
+    ok: false;
+    outcome: MutationOutcome;
+} | {
+    type: 'themePreferenceChanged';
+    preference: ThemePreference;
+};
+/**
+ * Port messages sent from a settings editor iframe to host. `requestPlay` is
+ * honoured from the `setup` slot only (§6.5).
+ */
+export type IFrameSettingsEditorPortMessage = {
+    type: 'pong';
+} | {
+    type: 'updateSettings';
+    requestId?: string;
+    payload: unknown;
+} | {
+    type: 'requestPlay';
+} | {
+    type: 'setThemePreference';
+    preference: ThemePreference;
+} | {
+    type: 'refreshAssetAuth:response';
+    requestId: string;
+    ok: true;
+} | {
+    type: 'refreshAssetAuth:response';
+    requestId: string;
+    ok: false;
+    error: string;
+} | {
+    type: 'callEndpoint';
+    requestId: string;
+    endpointIdentifier: string;
+    request: unknown;
+} | {
+    type: 'uploadBlob';
+    requestId: string;
+    data: ArrayBuffer;
+    name: string;
+    mimeType: string;
+};
+/**
+ * Port messages sent from host to presentation iframe (§6.15).
+ *
+ * A presentation is read-only and may be shown with no session at all, so its
+ * channel is the session channel with every mutation taken away and one
+ * message in place of the session's several: `setPresentation` carries the
+ * game as the scenario resolves it, and the session, or `null` when there is
+ * none. The host re-sends it whole on every change; a deck changes slowly
+ * enough that deltas would buy nothing.
+ */
+export type HostPresentationPortMessage = {
+    type: 'ping';
+} | {
+    type: 'setPresentation';
+    payload: {
+        game: PresentationGame;
+        session: PresentationSession | null;
+    };
+} | {
+    type: 'setSettings';
+    payload: Record<string, Record<string, unknown>>;
+} | {
+    type: 'setTheme';
+    payload: UserInterfaceTheme;
+} | {
+    type: 'setLocale';
+    payload: UserInterfaceLocale;
+} | {
+    type: 'setAssetUrls';
+    payload: AssetUrls;
+} | {
+    type: 'refreshAssetAuth';
+    requestId: string;
+    token: string;
+} | {
+    type: 'getPastState:response';
+    requestId: string;
+    ok: true;
+    entries: PastStateEntry[];
+} | {
+    type: 'getPastState:response';
+    requestId: string;
+    ok: false;
+    error: string;
+} | {
+    type: 'themePreferenceChanged';
+    preference: ThemePreference;
+};
+/** Port messages sent from presentation iframe to host. Reads only. */
+export type IFramePresentationPortMessage = {
+    type: 'pong';
+} | {
+    type: 'refreshAssetAuth:response';
+    requestId: string;
+    ok: true;
+} | {
+    type: 'refreshAssetAuth:response';
+    requestId: string;
+    ok: false;
+    error: string;
+} | {
+    type: 'getPastState';
+    requestId: string;
+    query: PastStateQuery;
+};