diff --git a/apps/protocol/src/errors.ts b/apps/protocol/src/errors.ts index 171520449..09af0461e 100644 --- a/apps/protocol/src/errors.ts +++ b/apps/protocol/src/errors.ts @@ -16,6 +16,8 @@ export const PROTOCOL_APP_ERRORS = { RESOLVE_DOT_NAME_UNSUPPORTED: "resolveDotName is not served by this protocol mode", RESOLVE_OWNER_UNSUPPORTED: "resolveOwner is not served by this protocol mode", + RESOLVE_SEITY_SLOT_UNSUPPORTED: + "resolveSeitySlot is not served by this protocol mode", RESOLVE_EXECUTABLE_MANIFEST_UNSUPPORTED: "resolveExecutableManifest is not served by this protocol mode", RESOLVE_ROOT_MANIFEST_UNSUPPORTED: diff --git a/apps/protocol/src/main.ts b/apps/protocol/src/main.ts index f30934b35..32213a70a 100644 --- a/apps/protocol/src/main.ts +++ b/apps/protocol/src/main.ts @@ -57,6 +57,7 @@ import type { RootManifest, } from "@dotli/resolver/manifest"; import type { ResolveOptions } from "@dotli/resolver/resolve"; +import type { SeitySlot } from "@dotli/resolver/seity-registry"; import { isExecutableKind } from "@dotli/shared/executables"; import { MAX_CONNECTIONS_PER_ORIGIN, @@ -859,6 +860,7 @@ async function initDirectMode(): Promise { resolveExecutableManifest, resolveOwner, resolveRootManifest, + resolveSeitySlot, setResolverAssetHubProvider, setResolverPeopleProvider, waitForPeopleFinalized, @@ -1029,6 +1031,7 @@ async function initDirectMode(): Promise { }, resolveDotName, resolveOwner, + resolveSeitySlot, resolveExecutableManifest, resolveRootManifest, }); @@ -1359,6 +1362,10 @@ interface EngineOptions { label: string, opts?: ResolveOptions, ) => Promise; + resolveSeitySlot?: ( + lookupKey: `0x${string}`, + opts?: ResolveOptions, + ) => Promise; /** * Product-manifest readers. * @@ -1451,6 +1458,25 @@ function createEngine(options: EngineOptions): ProtocolEngine { return; } + case "resolveSeitySlot": { + if (!options.resolveSeitySlot) { + throw new Error(PROTOCOL_APP_ERRORS.RESOLVE_SEITY_SLOT_UNSUPPORTED); + } + const payload = request.payload as ProtocolRequestMap["resolveSeitySlot"]; + assertStr(payload.lookupKey, "lookupKey"); + const slot = await options.resolveSeitySlot( + payload.lookupKey as `0x${string}`, + { syncTimeoutMs }, + ); + respond({ + namespace: "dotli:protocol", + kind: "response", + id: request.id, + ok: true, + result: slot === null ? null : { ...slot, version: slot.version.toString() }, + }); + return; + } case "resolveOwner": { if (!options.resolveOwner) { throw new Error(PROTOCOL_APP_ERRORS.RESOLVE_OWNER_UNSUPPORTED); diff --git a/apps/protocol/src/protocol-shared-worker.ts b/apps/protocol/src/protocol-shared-worker.ts index e0cc29f4c..eaafd974c 100644 --- a/apps/protocol/src/protocol-shared-worker.ts +++ b/apps/protocol/src/protocol-shared-worker.ts @@ -34,6 +34,7 @@ import { resolveExecutableManifest, resolveOwner, resolveRootManifest, + resolveSeitySlot, setResolverAssetHubProvider, setResolverPeopleProvider, waitForAssetHubFinalized, @@ -383,6 +384,21 @@ async function handleRequest( return; } + case "resolveSeitySlot": { + const payload = request.payload as ProtocolRequestMap["resolveSeitySlot"]; + assertString(payload.lookupKey, "lookupKey"); + const slot = await resolveSeitySlot(payload.lookupKey as `0x${string}`, { + syncTimeoutMs, + }); + sendToPort(port, { + namespace: "dotli:protocol", + kind: "response", + id: request.id, + ok: true, + result: slot === null ? null : { ...slot, version: slot.version.toString() }, + }); + return; + } case "resolveOwner": { const payload = request.payload as ProtocolRequestMap["resolveOwner"]; assertString(payload.label, "label"); diff --git a/packages/config/src/network.ts b/packages/config/src/network.ts index a5aacb2d8..26dbc535f 100644 --- a/packages/config/src/network.ts +++ b/packages/config/src/network.ts @@ -63,6 +63,8 @@ export interface ServicesConfig { readonly decimals: number; }; readonly dotns: DotnsContracts; + /** Seity's slot registry on Asset Hub; absent where Seity is not deployed. */ + readonly seity?: { readonly REGISTRY: string }; } const BUILTIN_NETWORK_SERVICES: Record = { @@ -112,6 +114,8 @@ const BUILTIN_NETWORK_SERVICES: Record = { STORAGE_SLOTS: { REGISTRY_RECORDS: 0, CONTENTHASH: 0, TEXT_RECORDS: 1 }, TLD: "paseo", }, + // paritytech/seity registry/deployments/paseo-next-v2/deployment.json + seity: { REGISTRY: "0x90ddece099d26f66d13bb46b9db49dbb2083cb15" }, }, [NetworkName.PREVIEWNET]: { label: "Previewnet", diff --git a/packages/protocol/src/client.ts b/packages/protocol/src/client.ts index 45a660b09..020c067be 100644 --- a/packages/protocol/src/client.ts +++ b/packages/protocol/src/client.ts @@ -680,6 +680,7 @@ async function postRequest( type ResolverRequestMethod = | "resolveDotName" | "resolveOwner" + | "resolveSeitySlot" | "resolveExecutableManifest" | "resolveRootManifest"; @@ -730,6 +731,22 @@ export async function resolveOwnerRemote( string | null; } +/** A Seity registry slot as the protocol returns it; `version` is a decimal string. */ +export interface RemoteSeitySlot { + readonly owner: `0x${string}`; + readonly cidDigest: `0x${string}`; + readonly version: string; +} + +/** Remote proxy for the Seity registry reader (null when the registry is absent). */ +export async function resolveSeitySlotRemote( + lookupKey: `0x${string}`, +): Promise { + return (await postResolverRequest("resolveSeitySlot", { + lookupKey, + })) as RemoteSeitySlot | null; +} + /** * Remote proxy for the executable-manifest reader. * diff --git a/packages/protocol/src/messages.ts b/packages/protocol/src/messages.ts index fda23fa3d..98bb97528 100644 --- a/packages/protocol/src/messages.ts +++ b/packages/protocol/src/messages.ts @@ -18,6 +18,7 @@ export interface ProtocolRequestMap { warmup: Record; resolveDotName: { label: string }; resolveOwner: { label: string }; + resolveSeitySlot: { lookupKey: string }; resolveExecutableManifest: { label: string; kind: "app" | "widget" | "worker"; diff --git a/packages/protocol/src/method-timeouts.ts b/packages/protocol/src/method-timeouts.ts index 465253785..8aa323690 100644 --- a/packages/protocol/src/method-timeouts.ts +++ b/packages/protocol/src/method-timeouts.ts @@ -35,6 +35,7 @@ export const METHOD_TIMEOUTS: Partial> = { chainConnect: 30_000, resolveDotName: 90_000, resolveOwner: 90_000, + resolveSeitySlot: 90_000, resolveExecutableManifest: 30_000, resolveRootManifest: 30_000, }; diff --git a/packages/resolver/src/abi.ts b/packages/resolver/src/abi.ts index 25862cbf0..1202dc518 100644 --- a/packages/resolver/src/abi.ts +++ b/packages/resolver/src/abi.ts @@ -75,6 +75,25 @@ export function computeMappingSlot( ); } +/** + * Compute the slot for `mapping(bytes32 => mapping(bytes32 => T))` at slot N, + * which is also how a pvm-contract-sdk `Mapping<([u8; 32], [u8; 32]), T>` + * lays out (pvm-storage chains tuple keys like Solidity nested mappings): + * keccak256(inner ++ keccak256(outer ++ uint256(N))) + */ +export function computeNestedBytes32MappingSlot( + outerKey: `0x${string}`, + innerKey: `0x${string}`, + slotNumber: number, +): `0x${string}` { + const midSlot = computeMappingSlot(outerKey, slotNumber); + return toHex( + new Uint8Array( + keccak_256(concatBytes(hexToBytes(innerKey), hexToBytes(midSlot))), + ), + ); +} + /** * Compute the data slot for long Solidity `bytes` storage. * diff --git a/packages/resolver/src/resolve.ts b/packages/resolver/src/resolve.ts index 3b41f9050..77509f571 100644 --- a/packages/resolver/src/resolve.ts +++ b/packages/resolver/src/resolve.ts @@ -26,6 +26,7 @@ import { readMappingBytes, readMappingAddress } from "./access-raw-storage"; import type { PhaseCallback, StatusCallback } from "./access-raw-storage"; import { createRawApi, type Api } from "./api"; import { readExecutableManifest, readRootManifest } from "./manifest"; +import { readSeitySlot, type SeitySlot } from "./seity-registry"; import type { ExecutableKind, ExecutableManifest, @@ -429,3 +430,19 @@ export async function resolveOwner( dotns.STORAGE_SLOTS.REGISTRY_RECORDS, ); } + +/** + * Read one Seity registry slot on the active network's Asset Hub. Rejects + * when the network has no Seity registry configured. + */ +export async function resolveSeitySlot( + lookupKey: `0x${string}`, + opts: ResolveOptions = {}, +): Promise { + const registry = getActiveServicesConfig().seity?.REGISTRY; + if (registry === undefined) { + throw new Error("no Seity registry is configured for this network"); + } + const api = await ensureClient(opts); + return readSeitySlot(api, registry, lookupKey); +} diff --git a/packages/resolver/src/seity-registry.test.ts b/packages/resolver/src/seity-registry.test.ts new file mode 100644 index 000000000..698bc3c69 --- /dev/null +++ b/packages/resolver/src/seity-registry.test.ts @@ -0,0 +1,48 @@ +import { describe, expect, it } from "vitest"; +import { hexToBytes } from "@noble/hashes/utils.js"; +import type { Api, ContractStorage } from "./api"; +import { computeNestedBytes32MappingSlot } from "./abi"; +import { readSeitySlot } from "./seity-registry"; + +// The storage seity's registry contract wrote after `anchor(0x01…, 0x02…, +// 0x09…)` from 0xa1…, dumped by its mock host. The same keys are pinned in +// paritytech/seity `registry/lib.rs` (`storage_layout_is_what_raw_readers_compute`). +const DOMAIN = `0x${"01".repeat(32)}` as const; +const LOOKUP = `0x${"02".repeat(32)}` as const; +const DUMP: Record = { + "0x0178a5f3f52848d455b30bd72f348037540dbb9a30ce8884a49afb59d0a67708": `${"00".repeat(12)}${"a1".repeat(20)}`, + "0xf88c0b9de2397b913259aa0787c071c0b839f71070f539761a5e34e4dff53926": "09".repeat(32), + "0x3cb365a0a73e582cda498139ee151defc9301d55b78c813e1fd1149e92817660": `${"00".repeat(31)}01`, +}; + +function fakeApi(dump: Record): Api { + const storage: ContractStorage = { + readSlot: (key) => + Promise.resolve(key in dump ? hexToBytes(dump[key]) : null), + }; + return { + whenReady: () => Promise.resolve(), + withContract: (_address, read) => read(storage), + onStop: () => () => undefined, + destroy: () => undefined, + }; +} + +describe("seity registry", () => { + it("computes the slots the contract writes", () => { + expect(Object.keys(DUMP)).toEqual([0, 1, 2].map((n) => computeNestedBytes32MappingSlot(DOMAIN, LOOKUP, n))); + }); + + it("reads an anchored slot", async () => { + await expect(readSeitySlot(fakeApi(DUMP), "0xregistry", LOOKUP, DOMAIN)).resolves.toEqual({ + owner: `0x${"a1".repeat(20)}`, + cidDigest: `0x${"09".repeat(32)}`, + version: 1n, + }); + }); + + it("reads a never-anchored slot as version 0", async () => { + const slot = await readSeitySlot(fakeApi({}), "0xregistry", LOOKUP, DOMAIN); + expect(slot?.version).toBe(0n); + }); +}); diff --git a/packages/resolver/src/seity-registry.ts b/packages/resolver/src/seity-registry.ts new file mode 100644 index 000000000..150432f62 --- /dev/null +++ b/packages/resolver/src/seity-registry.ts @@ -0,0 +1,61 @@ +// Copyright 2026 Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: AGPL-3.0-only + +// Seity's slot registry, read from raw contract storage. +// +// The registry (paritytech/seity `registry/lib.rs`) keeps three +// `Mapping<(domain, lookupKey), _>` fields: owners (slot 0, right-aligned +// 20 bytes), digests (slot 1, bytes32) and versions (slot 2, uint64). The +// layout is pinned on both sides by the same storage keys (seity's +// `storage_layout_is_what_raw_readers_compute`, and this package's test). pvm-storage lays +// them out as Solidity nested mappings, so the resolver's slot maths applies +// and no runtime call is needed. Version 0 means never anchored; a zero +// digest means revoked. + +import type { Api } from "./api"; +import { computeNestedBytes32MappingSlot, toHex, wordToBigInt } from "./abi"; + +/** blake2b-256("seity:domain:v1"): the registry domain every seity slot uses. */ +export const SEITY_REGISTRY_DOMAIN = + "0x5c9584ba6e565351723d57394780b31b4c2156123e1269c4724ae5f01258bb53" as const; + +const SLOT_OWNERS = 0; +const SLOT_DIGESTS = 1; +const SLOT_VERSIONS = 2; + +export interface SeitySlot { + /** Right-aligned in its word, like an `address` (pinned by seity's registry layout test). */ + readonly owner: `0x${string}`; + readonly cidDigest: `0x${string}`; + readonly version: bigint; +} + +export async function readSeitySlot( + api: Api, + registry: string, + lookupKey: `0x${string}`, + domain: `0x${string}` = SEITY_REGISTRY_DOMAIN, +): Promise { + return api.withContract(registry, async (storage) => { + const slot = (n: number): `0x${string}` => + computeNestedBytes32MappingSlot(domain, lookupKey, n); + const versionWord = await storage.readSlot(slot(SLOT_VERSIONS)); + const version = versionWord === null ? 0n : wordToBigInt(versionWord); + if (version === 0n) { + return { + owner: `0x${"00".repeat(20)}`, + cidDigest: `0x${"00".repeat(32)}`, + version, + }; + } + const [ownerWord, digestWord] = await Promise.all([ + storage.readSlot(slot(SLOT_OWNERS)), + storage.readSlot(slot(SLOT_DIGESTS)), + ]); + return { + owner: toHex((ownerWord ?? new Uint8Array(32)).slice(12)), + cidDigest: toHex(digestWord ?? new Uint8Array(32)), + version, + }; + }); +} diff --git a/packages/ui/src/host-callbacks/Profile.ts b/packages/ui/src/host-callbacks/Profile.ts index b414fa7a5..f4bcdad13 100644 --- a/packages/ui/src/host-callbacks/Profile.ts +++ b/packages/ui/src/host-callbacks/Profile.ts @@ -11,11 +11,19 @@ import type { ProfilePlatform } from "@parity/truapi-host"; import { fromHex } from "@dotli/shared/hex"; -import { showProfileDrawer } from "../profile/drawer"; +import { showProfileDrawer, type LoadedProfile } from "../profile/drawer"; +import { + isContactsReference, + openContactsRecord, + parseContactsReference, + type SeityContactsReference, +} from "../profile/contacts-reference"; +import { decodeProfileRecord } from "../profile/profile-record"; import { openSeityBlob, parseSeityBlobReference, } from "../profile/seity-reference"; +import { resolveSeitySlotRemote } from "@dotli/protocol/client"; import { createPreimageAdapters } from "./Preimage"; /** Bulletin retrieval can wait on bitswap providers attaching. */ @@ -74,14 +82,56 @@ export function presentProfileReference( productId: string, reference: string, ): void { + showProfileDrawer({ productId, loadProfile: profileLoader(reference) }); +} + +/** + * Parse a reference into the loader the drawer runs. Throws for a reference + * this host cannot parse, so no UI appears for it. + * + * - `seity-contacts:v1:…` names a registry slot: read it, fetch and open the + * sealed record, then fetch and open the avatar the record names. + * - A bare `cid#key` names one avatar blob (the #287 path, unchanged). + */ +function profileLoader( + reference: string, +): (signal: AbortSignal) => Promise { + if (isContactsReference(reference)) { + const parsed = parseContactsReference(reference); + return (signal) => loadContactsProfile(parsed, signal); + } const parsed = parseSeityBlobReference(reference); - showProfileDrawer({ - productId, - loadAvatar: async (signal) => - openSeityBlob(await fetchCiphertext(parsed.preimageKey, signal), parsed), + return async (signal) => ({ + avatar: await openSeityBlob( + await fetchCiphertext(parsed.preimageKey, signal), + parsed, + ), }); } +async function loadContactsProfile( + reference: SeityContactsReference, + signal: AbortSignal, +): Promise { + // The light client lives in the protocol worker, so the read goes there. + const slot = await resolveSeitySlotRemote(reference.lookupKey); + // Never anchored, revoked (zero digest) or no registry: nothing to show. + if (slot === null || slot.version === "0" || /^0x0{64}$/.test(slot.cidDigest)) { + return { avatar: null }; + } + const sealed = await fetchCiphertext(slot.cidDigest, signal); + const record = decodeProfileRecord(await openContactsRecord(sealed, reference)); + if (record.avatarReference === undefined) { + return { avatar: null, mood: record.mood }; + } + const avatarRef = parseSeityBlobReference(record.avatarReference); + const avatar = await openSeityBlob( + await fetchCiphertext(avatarRef.preimageKey, signal), + avatarRef, + ); + return { avatar, mood: record.mood }; +} + export function createProfilePlatform(): Required { return { presentProfile(product, request) { diff --git a/packages/ui/src/host-callbacks/SessionStore.ts b/packages/ui/src/host-callbacks/SessionStore.ts index f87e735ff..5e4e993be 100644 --- a/packages/ui/src/host-callbacks/SessionStore.ts +++ b/packages/ui/src/host-callbacks/SessionStore.ts @@ -437,6 +437,10 @@ export function createSessionStoreAdapters(custodyLease?: string): CoreStorage { case "ProductSubtree": case "SsoResponderRequestLedger": case "ProductManifest": + case "ProfileDisclosure": + case "ProfileReferencesReceived": + // Profile references, like the grants above, carry no wallet scope of + // their own, so the generation keeps one identity's from another. return ( hexNoPrefix(new TextEncoder().encode(`${generation}:`)) + encoded ); @@ -593,6 +597,13 @@ function coreLocalStorageKey(key: CoreStorageKey): string { // grant expires without touching the others. case "ProductManifest": return `${CORE_LOCAL_STORAGE_PREFIX}product-manifest:${key.value.productId}`; + // The user's own disclosed profile reference: one per wallet. + case "ProfileDisclosure": + return `${CORE_LOCAL_STORAGE_PREFIX}profile-disclosure`; + // Contacts' references, per chat product like its roster, so clearing + // the product clears them. + case "ProfileReferencesReceived": + return `${CORE_LOCAL_STORAGE_PREFIX}profile-references-received:${key.value.productId}`; case "MainPurseCoinage": case "NativeChatDevice": case "NativeChatFileChunk": @@ -606,7 +617,10 @@ function storesSecretMaterial(key: CoreStorageKey): boolean { key.tag === "AllowanceKeys" || key.tag === "AutoSigningKey" || key.tag === "AutoSigningKeys" || - key.tag === "DeviceEncryptionKey" + key.tag === "DeviceEncryptionKey" || + // Bearer capabilities: whoever reads one can open the profile it names. + key.tag === "ProfileDisclosure" || + key.tag === "ProfileReferencesReceived" ); } diff --git a/packages/ui/src/profile/contacts-reference.ts b/packages/ui/src/profile/contacts-reference.ts new file mode 100644 index 000000000..261920c99 --- /dev/null +++ b/packages/ui/src/profile/contacts-reference.ts @@ -0,0 +1,73 @@ +// Copyright 2026 Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: AGPL-3.0-only + +// Seity contacts references: `"seity-contacts:v1:"`. +// +// Unlike a `cid#key` blob reference, this names a registry slot rather than a +// blob, so it stays the same while the profile behind it changes. Resolving it +// takes one registry read (raw contract storage, no runtime call), one +// preimage fetch of the sealed record, one AES-GCM open, and then the record's +// avatar is an ordinary blob reference fetched the same way. +// +// Format and seal are pinned by Seity's profile-core (`contacts.ts`) and its +// committed vector. The reference is a bearer capability: parsed and used +// here, never logged or handed back to the product. + +import { InvalidProfileReferenceError } from "./seity-reference"; + +export const CONTACTS_REFERENCE_PREFIX = "seity-contacts:v1:"; +const BODY_PATTERN = /^[0-9a-f]{128}$/; +const NONCE_BYTES = 12; + +export interface SeityContactsReference { + /** Registry lookup key, public. */ + readonly lookupKey: `0x${string}`; + /** AES-256-GCM key for the sealed record. */ + readonly seed: Uint8Array; +} + +export function isContactsReference(reference: string): boolean { + return reference.startsWith(CONTACTS_REFERENCE_PREFIX); +} + +export function parseContactsReference( + reference: string, +): SeityContactsReference { + const body = reference.slice(CONTACTS_REFERENCE_PREFIX.length); + if (!isContactsReference(reference) || !BODY_PATTERN.test(body)) { + throw new InvalidProfileReferenceError( + "expected seity-contacts:v1:<32-byte lookup key><32-byte seed>", + ); + } + const seed = new Uint8Array(32); + for (let i = 0; i < 32; i++) { + seed[i] = Number.parseInt(body.slice(64 + i * 2, 66 + i * 2), 16); + } + return { lookupKey: `0x${body.slice(0, 64)}`, seed }; +} + +/** + * Open a sealed record: `nonce(12) ‖ ciphertext ‖ tag`. AES-GCM + * authenticates, so the wrong seed or substituted bytes reject. + */ +export async function openContactsRecord( + sealed: Uint8Array, + reference: Pick, +): Promise { + if (sealed.length <= NONCE_BYTES) { + throw new Error("sealed profile record is truncated"); + } + const key = await crypto.subtle.importKey( + "raw", + reference.seed, + "AES-GCM", + false, + ["decrypt"], + ); + const plaintext = await crypto.subtle.decrypt( + { name: "AES-GCM", iv: sealed.slice(0, NONCE_BYTES) }, + key, + sealed.slice(NONCE_BYTES), + ); + return new Uint8Array(plaintext); +} diff --git a/packages/ui/src/profile/drawer.ts b/packages/ui/src/profile/drawer.ts index 3d9a8cbd1..89e959046 100644 --- a/packages/ui/src/profile/drawer.ts +++ b/packages/ui/src/profile/drawer.ts @@ -9,11 +9,28 @@ // avatar or a failure message. It is not a blocking modal: it asks nothing, // and presenting another profile replaces the one on screen. +import { log } from "@dotli/shared/log"; +import { createMoodRing, INTENSITY, MOOD_PALETTE, type MoodRingHandle } from "./mood-ring"; +import { moodIsCurrent, type Mood } from "./profile-record"; + +/** What a reference opened to. Either half may be missing. */ +export interface LoadedProfile { + readonly avatar: Uint8Array | null; + readonly mood?: Mood; +} + export interface ProfileDrawerOptions { /** Product that asked for the presentation, shown as attribution. */ readonly productId: string; - /** Fetch and decrypt the avatar. Aborted when the drawer closes. */ - readonly loadAvatar: (signal: AbortSignal) => Promise; + /** Fetch and decrypt the profile. Aborted when the drawer closes. */ + readonly loadProfile: (signal: AbortSignal) => Promise; +} + +const AVATAR_PX = 160; + +function moodLine(mood: Mood, nowSecs = Date.now() / 1000): string { + const hoursLeft = Math.max(1, Math.round((mood.setAt + mood.ttlSecs - nowSecs) / 3600)); + return `${MOOD_PALETTE[mood.kind].label} · ${INTENSITY[mood.intensity].label.toLowerCase()} · ${String(hoursLeft)} h left`; } export interface ProfileDrawerHandle { @@ -90,11 +107,17 @@ export function showProfileDrawer( closeBtn.textContent = "×"; header.append(heading, closeBtn); + const portrait = document.createElement("div"); + portrait.className = "profile-drawer-portrait"; const avatar = document.createElement("div"); avatar.className = "profile-drawer-avatar"; const spinner = document.createElement("div"); spinner.className = "spinner"; avatar.appendChild(spinner); + portrait.appendChild(avatar); + + const moodText = document.createElement("p"); + moodText.className = "profile-drawer-mood"; const status = document.createElement("p"); status.className = "profile-drawer-status"; @@ -105,12 +128,13 @@ export function showProfileDrawer( attribution.className = "profile-drawer-attribution"; attribution.textContent = `Shown by ${options.productId}. Seity profile content is self-described; dot.li does not verify it.`; - drawer.append(header, avatar, status, attribution); + drawer.append(header, portrait, moodText, status, attribution); backdrop.appendChild(drawer); document.body.appendChild(backdrop); const aborter = new AbortController(); let objectUrl: string | null = null; + let ring: MoodRingHandle | null = null; let closed = false; const onKeyDown = (event: KeyboardEvent): void => { @@ -129,6 +153,7 @@ export function showProfileDrawer( aborter.abort(); document.removeEventListener("keydown", onKeyDown); backdrop.remove(); + ring?.stop(); if (objectUrl !== null) { URL.revokeObjectURL(objectUrl); objectUrl = null; @@ -158,11 +183,27 @@ export function showProfileDrawer( status.classList.add("profile-drawer-status-error"); }; - options.loadAvatar(aborter.signal).then( - (bytes) => { + options.loadProfile(aborter.signal).then( + ({ avatar: bytes, mood }) => { if (closed) { return; } + const currentMood = mood !== undefined && moodIsCurrent(mood) ? mood : undefined; + if (currentMood !== undefined) { + ring = createMoodRing(currentMood, AVATAR_PX); + portrait.prepend(ring.element); + moodText.textContent = moodLine(currentMood); + } + if (bytes === null) { + if (currentMood === undefined) { + fail("This person is not sharing a profile right now."); + } else { + avatar.replaceChildren(); + avatar.classList.add("profile-drawer-avatar-empty"); + status.textContent = ""; + } + return; + } const type = rasterImageType(bytes); if (type === null) { fail("The profile image is not a supported format."); @@ -181,6 +222,11 @@ export function showProfileDrawer( if (closed) { return; } + // Name and message only: no error on this path carries the reference. + log.warn( + "[profile] drawer load failed:", + error instanceof Error ? `${error.name}: ${error.message}` : String(error), + ); fail(failureMessage(error)); }, ); diff --git a/packages/ui/src/profile/mood-ring.ts b/packages/ui/src/profile/mood-ring.ts new file mode 100644 index 000000000..4f1701656 --- /dev/null +++ b/packages/ui/src/profile/mood-ring.ts @@ -0,0 +1,206 @@ +// Copyright 2026 Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: AGPL-3.0-only + +// The mood ring drawn around a profile avatar. +// +// One WebGL program, a few numbers per mood: three colours, a tempo and a +// turbulence, scaled by intensity and faded by age. Ported from Seity's mood +// ring mockup; the palette is the standard six moods by three intensities. +// Without WebGL it falls back to a static conic gradient, and under +// prefers-reduced-motion it draws one still frame. + +import type { Mood, MoodIntensity, MoodKind } from "./profile-record"; + +interface Palette { + readonly label: string; + readonly a: string; + readonly b: string; + readonly c: string; + readonly speed: number; + readonly turb: number; +} + +export const MOOD_PALETTE: Record = { + calm: { label: "Calm", a: "#2dd4bf", b: "#38bdf8", c: "#0e7490", speed: 0.25, turb: 0.3 }, + focused: { label: "Focused", a: "#8b5cf6", b: "#c4b5fd", c: "#4338ca", speed: 0.4, turb: 0.15 }, + hyped: { label: "Hyped", a: "#e6007a", b: "#ff8a3d", c: "#ffd166", speed: 1.3, turb: 0.9 }, + social: { label: "Social", a: "#fbbf24", b: "#fde68a", c: "#ea580c", speed: 0.8, turb: 0.5 }, + "low-key": { label: "Low-key", a: "#b48ead", b: "#6b4d78", c: "#3b2a4a", speed: 0.2, turb: 0.2 }, + away: { label: "Away", a: "#8c8f98", b: "#dadbe0", c: "#404249", speed: 0.08, turb: 0.05 }, +}; + +export const INTENSITY: Record = { + soft: { label: "Soft", k: 0.55 }, + steady: { label: "Steady", k: 1 }, + loud: { label: "Loud", k: 1.8 }, +}; + +const VS = `attribute vec2 a_pos;varying vec2 v_uv; +void main(){v_uv=a_pos;gl_Position=vec4(a_pos,0.0,1.0);}`; + +const FS = `precision highp float;varying vec2 v_uv; +uniform float u_time,u_speed,u_turb,u_age,u_inner,u_width,u_half,u_bright,u_halo;uniform vec3 u_a,u_b,u_c; +float hash(vec2 p){p=fract(p*vec2(123.34,456.21));p+=dot(p,p+45.32);return fract(p.x*p.y);} +float noise(vec2 p){vec2 i=floor(p),f=fract(p);f=f*f*(3.0-2.0*f);float a=hash(i),b=hash(i+vec2(1,0)),c=hash(i+vec2(0,1)),d=hash(i+vec2(1,1));return mix(mix(a,b,f.x),mix(c,d,f.x),f.y);} +float fbm(vec2 p){float v=0.0,a=0.5;for(int i=0;i<4;i++){v+=a*noise(p);p*=2.03;a*=0.5;}return v;} +vec3 ramp(float x){float f=x*3.0;if(f<1.0)return mix(u_a,u_b,f);if(f<2.0)return mix(u_b,u_c,f-1.0);return mix(u_c,u_a,f-2.0);} +void main(){ + float r=length(v_uv);float ang=atan(v_uv.y,v_uv.x);float t=u_time*u_speed; + vec2 onCircle=vec2(cos(ang),sin(ang)); + float n=fbm(onCircle*(1.6+u_turb*1.4)+vec2(t*0.45,-t*0.3)); + float n2=fbm(onCircle*3.0-vec2(t*0.2,t*0.35)+7.0); + float w=u_width*(0.78+0.44*n)*mix(1.0,0.72,u_age); + float aa=1.5/u_half; + float r0=u_inner,r1=u_inner+w; + float band=smoothstep(r0-aa,r0+aa,r)*(1.0-smoothstep(r1-aa,r1+aa,r)); + float flow=fract(ang/6.2831853+t*0.12+(n2-0.5)*u_turb*0.6); + vec3 col=ramp(flow)*u_bright; + float d=max(0.0,r-r1);float outside=smoothstep(r1-aa,r1+aa,r); + float glow=outside*exp(-d*d*u_half*u_half*(0.05/max(u_halo,0.3)))*(0.14+0.2*u_halo+0.15*n); + float fade=mix(1.0,0.38,u_age); + float alpha=clamp(band+glow*(1.0-band),0.0,1.0)*fade*smoothstep(u_inner-2.0*aa,u_inner,r); + gl_FragColor=vec4(col*alpha,alpha); +}`; + +function rgb(hex: string): [number, number, number] { + return [ + Number.parseInt(hex.slice(1, 3), 16) / 255, + Number.parseInt(hex.slice(3, 5), 16) / 255, + Number.parseInt(hex.slice(5, 7), 16) / 255, + ]; +} + +/** How far through its life the mood is, 0 (just set) to 1 (about to lapse). */ +export function moodAge(mood: Mood, nowSecs = Date.now() / 1000): number { + if (mood.ttlSecs <= 0) { + return 0; + } + return Math.min(1, Math.max(0, (nowSecs - mood.setAt) / mood.ttlSecs)); +} + +export interface MoodRingHandle { + readonly element: HTMLElement; + stop(): void; +} + +/** + * A ring layer sized to wrap an avatar of `avatarPx`. Place the returned + * element centred over the avatar; it paints nothing over the avatar itself. + */ +export function createMoodRing(mood: Mood, avatarPx: number): MoodRingHandle { + const palette = MOOD_PALETTE[mood.kind]; + const k = INTENSITY[mood.intensity].k; + const age = moodAge(mood); + const size = Math.round(avatarPx * 1.5); + + const element = document.createElement("div"); + element.className = "profile-mood-ring"; + element.style.width = `${String(size)}px`; + element.style.height = `${String(size)}px`; + element.setAttribute("aria-hidden", "true"); + + const fallback = (): MoodRingHandle => { + element.classList.add("profile-mood-ring-static"); + element.style.setProperty("--ring-a", palette.a); + element.style.setProperty("--ring-b", palette.b); + element.style.setProperty("--ring-c", palette.c); + element.style.opacity = String(1 - 0.62 * age); + return { element, stop: () => undefined }; + }; + + const canvas = document.createElement("canvas"); + const gl = canvas.getContext("webgl", { alpha: true, premultipliedAlpha: true, antialias: true }); + if (gl === null) { + return fallback(); + } + const compile = (type: number, source: string): WebGLShader | null => { + const shader = gl.createShader(type); + if (shader === null) { + return null; + } + gl.shaderSource(shader, source); + gl.compileShader(shader); + return shader; + }; + const vs = compile(gl.VERTEX_SHADER, VS); + const fs = compile(gl.FRAGMENT_SHADER, FS); + const program = gl.createProgram(); + if (vs === null || fs === null) { + return fallback(); + } + gl.attachShader(program, vs); + gl.attachShader(program, fs); + gl.linkProgram(program); + if (!(gl.getProgramParameter(program, gl.LINK_STATUS) as boolean)) { + return fallback(); + } + gl.useProgram(program); + + const dpr = Math.min(2, window.devicePixelRatio || 1); + canvas.width = Math.round(size * dpr); + canvas.height = Math.round(size * dpr); + element.appendChild(canvas); + + const buffer = gl.createBuffer(); + gl.bindBuffer(gl.ARRAY_BUFFER, buffer); + gl.bufferData( + gl.ARRAY_BUFFER, + new Float32Array([-1, -1, 1, -1, -1, 1, -1, 1, 1, -1, 1, 1]), + gl.STATIC_DRAW, + ); + const position = gl.getAttribLocation(program, "a_pos"); + gl.enableVertexAttribArray(position); + gl.vertexAttribPointer(position, 2, gl.FLOAT, false, 0, 0); + gl.enable(gl.BLEND); + gl.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA); + gl.viewport(0, 0, canvas.width, canvas.height); + + const u = (name: string): WebGLUniformLocation | null => + gl.getUniformLocation(program, name); + const half = (size / 2) * dpr; + const widthPx = Math.max(3, Math.min(6, avatarPx * 0.05)) * (0.7 + 0.32 * k) * dpr; + gl.uniform1f(u("u_half"), half); + gl.uniform1f(u("u_inner"), ((avatarPx / 2 + 3) * dpr) / half); + gl.uniform1f(u("u_width"), widthPx / half); + gl.uniform1f(u("u_speed"), palette.speed * k); + gl.uniform1f(u("u_turb"), Math.min(1, palette.turb * k)); + gl.uniform1f(u("u_bright"), 0.62 + 0.36 * k); + gl.uniform1f(u("u_halo"), k); + gl.uniform1f(u("u_age"), age); + gl.uniform3f(u("u_a"), ...rgb(palette.a)); + gl.uniform3f(u("u_b"), ...rgb(palette.b)); + gl.uniform3f(u("u_c"), ...rgb(palette.c)); + const timeUniform = u("u_time"); + + const draw = (ms: number): void => { + gl.uniform1f(timeUniform, ms / 1000); + gl.clearColor(0, 0, 0, 0); + gl.clear(gl.COLOR_BUFFER_BIT); + gl.drawArrays(gl.TRIANGLES, 0, 6); + }; + + const still = window.matchMedia("(prefers-reduced-motion: reduce)").matches; + let frame = 0; + let stopped = false; + const loop = (ms: number): void => { + if (stopped) { + return; + } + draw(ms); + frame = requestAnimationFrame(loop); + }; + if (still) { + draw(0); + } else { + frame = requestAnimationFrame(loop); + } + + return { + element, + stop(): void { + stopped = true; + cancelAnimationFrame(frame); + gl.getExtension("WEBGL_lose_context")?.loseContext(); + }, + }; +} diff --git a/packages/ui/src/profile/profile-record.ts b/packages/ui/src/profile/profile-record.ts new file mode 100644 index 000000000..19308c50c --- /dev/null +++ b/packages/ui/src/profile/profile-record.ts @@ -0,0 +1,148 @@ +// Copyright 2026 Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: AGPL-3.0-only + +// The profile record a Seity contacts reference opens. +// +// A SCALE `Vec<{ kind: String, payload: Vec }>`, pinned by Seity's +// profile-core (`profile-record.ts`) and its committed vector. Kinds this host +// draws: `avatar` (a UTF-8 `cid#key` blob reference, read by +// seity-reference.ts) and `mood`. Unknown kinds are skipped, so the record can +// grow without this host changing. + +export const MOOD_KINDS = [ + "calm", + "focused", + "hyped", + "social", + "low-key", + "away", +] as const; +export const MOOD_INTENSITIES = ["soft", "steady", "loud"] as const; +export type MoodKind = (typeof MOOD_KINDS)[number]; +export type MoodIntensity = (typeof MOOD_INTENSITIES)[number]; + +export interface Mood { + readonly kind: MoodKind; + readonly intensity: MoodIntensity; + /** Unix seconds. */ + readonly setAt: number; + readonly ttlSecs: number; +} + +export interface ProfileRecord { + readonly avatarReference?: string; + readonly mood?: Mood; +} + +const MAX_RECORD_BYTES = 8 * 1024; + +class Reader { + private offset = 0; + private readonly bytes: Uint8Array; + constructor(bytes: Uint8Array) { + this.bytes = bytes; + } + + private take(n: number): Uint8Array { + if (this.offset + n > this.bytes.length) { + throw new Error("profile record is truncated"); + } + const out = this.bytes.subarray(this.offset, this.offset + n); + this.offset += n; + return out; + } + + u8(): number { + return this.take(1)[0]; + } + + u32(): number { + const b = this.take(4); + return ( + (b[0] | (b[1] << 8) | (b[2] << 16) | (b[3] << 24)) >>> 0 + ); + } + + u64(): number { + const lo = this.u32(); + const hi = this.u32(); + return hi * 2 ** 32 + lo; + } + + compact(): number { + const first = this.u8(); + switch (first & 3) { + case 0: + return first >> 2; + case 1: + return ((first | (this.u8() << 8)) >>> 2) & 0x3fff; + case 2: { + const rest = this.take(3); + return ( + ((first | (rest[0] << 8) | (rest[1] << 16) | (rest[2] << 24)) >>> 2) >>> 0 + ); + } + default: + throw new Error("profile record uses a big-integer length"); + } + } + + bytesField(): Uint8Array { + return this.take(this.compact()); + } + + done(): boolean { + return this.offset === this.bytes.length; + } +} + +/** Undefined for a payload this build cannot read, so a newer palette degrades to "no mood". */ +function decodeMood(payload: Uint8Array): Mood | undefined { + if (payload.length !== 14) { + return undefined; + } + const reader = new Reader(payload); + const kind = MOOD_KINDS.at(reader.u8()); + const intensity = MOOD_INTENSITIES.at(reader.u8()); + const setAt = reader.u64(); + const ttlSecs = reader.u32(); + if (kind === undefined || intensity === undefined) { + return undefined; + } + return { kind, intensity, setAt, ttlSecs }; +} + +export function decodeProfileRecord(bytes: Uint8Array): ProfileRecord { + if (bytes.length > MAX_RECORD_BYTES) { + throw new Error("profile record is too large"); + } + const reader = new Reader(bytes); + const text = new TextDecoder("utf-8", { fatal: true }); + const lenient = new TextDecoder("utf-8"); + const count = reader.compact(); + let avatarReference: string | undefined; + let mood: Mood | undefined; + for (let i = 0; i < count; i++) { + const kind = text.decode(reader.bytesField()); + const payload = reader.bytesField(); + // One unreadable signal degrades the drawer; it never sinks the read. A + // malformed avatar reference is refused later by its own parser. + if (kind === "avatar" && avatarReference === undefined) { + avatarReference = lenient.decode(payload); + } else if (kind === "mood" && mood === undefined) { + mood = decodeMood(payload); + } + } + if (!reader.done()) { + throw new Error("profile record has trailing bytes"); + } + return { avatarReference, mood }; +} + +/** True while the mood still counts, on this host's clock. */ +export function moodIsCurrent( + mood: Mood, + nowSecs: number = Math.floor(Date.now() / 1000), +): boolean { + return nowSecs < mood.setAt + mood.ttlSecs; +} diff --git a/packages/ui/src/styles/profile-drawer.css b/packages/ui/src/styles/profile-drawer.css index ea59ca724..fe1826e85 100644 --- a/packages/ui/src/styles/profile-drawer.css +++ b/packages/ui/src/styles/profile-drawer.css @@ -99,3 +99,39 @@ text-align: center; line-height: 1.4; } +.profile-drawer-portrait { + position: relative; + display: flex; + align-items: center; + justify-content: center; + width: 240px; + height: 240px; +} +.profile-mood-ring { + position: absolute; + inset: 0; + margin: auto; + pointer-events: none; +} +.profile-mood-ring canvas { + width: 100%; + height: 100%; +} +/* No WebGL: a still ring from the same three colours. */ +.profile-mood-ring-static { + border-radius: 50%; + background: conic-gradient( + var(--ring-a), + var(--ring-b), + var(--ring-c), + var(--ring-a) + ); + -webkit-mask: radial-gradient(circle, transparent 54%, #000 55%, #000 60%, transparent 61%); + mask: radial-gradient(circle, transparent 54%, #000 55%, #000 60%, transparent 61%); +} +.profile-drawer-mood { + min-height: 1.2em; + font-size: 0.85rem; + color: #ddd; + text-align: center; +} diff --git a/packages/ui/src/styles/themes.css b/packages/ui/src/styles/themes.css index d40cecdc9..8757f697b 100644 --- a/packages/ui/src/styles/themes.css +++ b/packages/ui/src/styles/themes.css @@ -808,3 +808,6 @@ [data-theme="light"] .profile-drawer-attribution { color: #777; } +[data-theme="light"] .profile-drawer-mood { + color: #333; +} diff --git a/packages/ui/tests/fixtures/seity-contacts-v1.json b/packages/ui/tests/fixtures/seity-contacts-v1.json new file mode 100644 index 000000000..3379d64bb --- /dev/null +++ b/packages/ui/tests/fixtures/seity-contacts-v1.json @@ -0,0 +1,21 @@ +{ + "reference": "seity-contacts:v1:be1954b54b4a001d6f466d7f8780d7aaa30bc7b5c23ff2cca32606a1466421f76d5e940494d34b965a5f714441dd2943dcac6dbbfd4cd9c38fbbd8a7177e82ac", + "registry": { + "lookupKey": "0xbe1954b54b4a001d6f466d7f8780d7aaa30bc7b5c23ff2cca32606a1466421f7", + "cidDigest": "0x43edd9991161b5f16b50447098569e4f570e79a631b954351880526de70986db", + "version": 1 + }, + "blobs": { + "0x43edd9991161b5f16b50447098569e4f570e79a631b954351880526de70986db": "ba5da44344adbc6a7e4f48480cad82fcc78d3b4fc1e929d2ceeda81d959769130e8c765ddbef6da50d58a80071de41813bdda4fa43c6bad6dfca2c7dec9554cacb8df8aa40e741d3d91e4f84fcd15d837deb34cbb994cebd9a9d4b7a40d48b1bb044f2eece8f30d633a1ddf1ee3148a4ac46321e71917ca8c08933384fcb2af1b29b39308e873503b72898b908f50d5fd6b0dd278eedb6b8e6cb851a01d1d016f5391da868fa6bf1cdbee2651012f83347fdfe8603fc2f5662e8eb10c77c4ee7c503659d1b2f5a04454421b9e749613691", + "0x074f73f4cd0fc5ca1f8bef7c2ba6384f6c20695827465726c13f46db50dd498f": "4ce11c7109089210221721c72c30ceb700cbeb7b0ac06cec466d379d4b75f0cc5a7c7f009154e8e3e1923b541655e730f2e90267cfa23dc7a349dc0e8a3e6e449d530b924a71fd7a53fa9dca400c119ec436" + }, + "expect": { + "avatarPlaintext": "89504e470d0a1a0a0000000d49484452000000010000000108060000001f15c4890000000d49444154789c6360000002000154a24f5d0000000049454e44ae426082", + "mood": { + "kind": "hyped", + "intensity": "loud", + "setAt": 1790000000, + "ttlSecs": 86400 + } + } +} diff --git a/packages/ui/tests/profile-contacts.test.ts b/packages/ui/tests/profile-contacts.test.ts new file mode 100644 index 000000000..4f8528972 --- /dev/null +++ b/packages/ui/tests/profile-contacts.test.ts @@ -0,0 +1,118 @@ +import { readFileSync } from "node:fs"; +import { join } from "node:path"; +import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; +import type { ProductContext } from "@parity/truapi-host"; +import { fromHex } from "@dotli/shared/hex"; +import { hashToCid } from "@dotli/content/preimage"; +import { createProfilePlatform } from "@dotli/ui/host-callbacks/Profile"; +import { parseContactsReference } from "@dotli/ui/profile/contacts-reference"; +import { InvalidProfileReferenceError } from "@dotli/ui/profile/seity-reference"; + +// Produced by Seity's profile-core (`test/vectors/contacts-v1.json`): the +// reference a contact's host is handed, the registry slot it names, the two +// blobs it fetches (sealed record, re-sealed avatar), and what it must draw. +const VECTOR = JSON.parse( + // happy-dom replaces import.meta.url, so resolve from the package root vitest runs in. + readFileSync(join(process.cwd(), "tests/fixtures/seity-contacts-v1.json"), "utf8"), +) as { + reference: string; + registry: { lookupKey: `0x${string}`; cidDigest: `0x${string}`; version: number }; + blobs: Record; + expect: { avatarPlaintext: string; mood: { kind: string; intensity: string; setAt: number; ttlSecs: number } }; +}; + +const mocks = vi.hoisted(() => ({ + bitswapGet: vi.fn(async (_cid: string): Promise => new Uint8Array()), + resolveSeitySlotRemote: vi.fn(), +})); + +vi.mock("@dotli/content/bitswap", () => ({ bitswapGet: mocks.bitswapGet })); +vi.mock("@dotli/content/ipfs", () => ({ fetchFromIpfs: vi.fn() })); +vi.mock("@dotli/config/mode", () => ({ getBackend: () => "smoldot-direct" })); +vi.mock("@dotli/protocol/client", () => ({ resolveSeitySlotRemote: mocks.resolveSeitySlotRemote })); + +const product: ProductContext = { productId: "egui-chat.dot", executionKind: "App" }; +const BLOBS_BY_CID = new Map( + Object.entries(VECTOR.blobs).map(([digest, hex]) => [hashToCid(digest).toString(), fromHex(hex)]), +); + +function drawer(): HTMLElement | null { + return document.querySelector(".profile-drawer"); +} + +/** Two preimage polls (record, then avatar), each after the poller's first delay. */ +async function settle(): Promise { + for (let i = 0; i < 10; i++) { + await vi.advanceTimersByTimeAsync(1_000); + if (drawer()?.querySelector(".profile-drawer-status")?.textContent !== "Loading profile…") { + return; + } + } + throw new Error("the drawer never finished loading"); +} + +describe("Seity contacts references", () => { + beforeEach(() => { + vi.useFakeTimers(); + // An hour after the vector's mood was set, so it is still current. + vi.setSystemTime((VECTOR.expect.mood.setAt + 3600) * 1000); + mocks.bitswapGet.mockReset(); + mocks.bitswapGet.mockImplementation(async (cid: string) => { + const bytes = BLOBS_BY_CID.get(cid); + if (bytes === undefined) throw new Error(`no blob for ${cid}`); + return bytes; + }); + mocks.resolveSeitySlotRemote.mockReset(); + mocks.resolveSeitySlotRemote.mockImplementation(async (lookupKey: string) => + lookupKey === VECTOR.registry.lookupKey + ? { owner: `0x${"aa".repeat(20)}`, cidDigest: VECTOR.registry.cidDigest, version: "1" } + : { owner: `0x${"00".repeat(20)}`, cidDigest: `0x${"00".repeat(32)}`, version: "0" }, + ); + }); + + afterEach(() => { + drawer()?.closest(".profile-drawer-backdrop")?.remove(); + vi.useRealTimers(); + }); + + it("parses the reference profile-core writes", () => { + expect(parseContactsReference(VECTOR.reference).lookupKey).toBe(VECTOR.registry.lookupKey); + }); + + it("resolves the slot, opens the record and draws the avatar with its mood", async () => { + await createProfilePlatform().presentProfile(product, { reference: VECTOR.reference }); + await settle(); + + expect(mocks.resolveSeitySlotRemote).toHaveBeenCalledWith(VECTOR.registry.lookupKey); + expect(drawer()?.querySelector("img")?.getAttribute("src")).toMatch(/^blob:/); + expect(drawer()?.querySelector(".profile-drawer-mood")?.textContent).toBe("Hyped · loud · 23 h left"); + expect(drawer()?.querySelector(".profile-mood-ring")).not.toBeNull(); + }); + + it("hides a lapsed mood but still draws the avatar", async () => { + vi.setSystemTime((VECTOR.expect.mood.setAt + VECTOR.expect.mood.ttlSecs + 1) * 1000); + await createProfilePlatform().presentProfile(product, { reference: VECTOR.reference }); + await settle(); + + expect(drawer()?.querySelector("img")).not.toBeNull(); + expect(drawer()?.querySelector(".profile-mood-ring")).toBeNull(); + }); + + it("says nothing is shared for a slot that was never anchored or was revoked", async () => { + const other = `seity-contacts:v1:${"ab".repeat(32)}${"cd".repeat(32)}`; + await createProfilePlatform().presentProfile(product, { reference: other }); + await settle(); + + expect(drawer()?.querySelector(".profile-drawer-status")?.textContent).toBe( + "This person is not sharing a profile right now.", + ); + }); + + it("rejects a malformed contacts reference without opening UI or echoing the seed", async () => { + const bad = VECTOR.reference.slice(0, -2); + const call = createProfilePlatform().presentProfile(product, { reference: bad }); + await expect(call).rejects.toBeInstanceOf(InvalidProfileReferenceError); + await expect(call).rejects.not.toThrow(bad.slice(-64)); + expect(drawer()).toBeNull(); + }); +}); diff --git a/vendor/truapi-host.lock.json b/vendor/truapi-host.lock.json index 23d7486c5..f1be72b55 100644 --- a/vendor/truapi-host.lock.json +++ b/vendor/truapi-host.lock.json @@ -1,23 +1,23 @@ { "schemaVersion": 1, "upstreamRepository": "https://github.com/paritytech/host-rust-core", - "upstreamBranch": "feat/chat-seity-profile", - "upstreamRevision": "95614da751510d755357beddc384b31415178b49", - "pullRequest": "https://github.com/paritytech/host-rust-core/pull/1001", + "upstreamBranch": "cbh/seity-contacts", + "upstreamRevision": "298cf4286c07cf0c5dc40116d3e957cc1caf5d1b", + "pullRequest": "https://github.com/paritytech/host-rust-core/pull/1009", "packages": { "vendor/truapi": { "name": "@parity/truapi", "version": "0.20.0", - "sourceArchiveSha256": "d516efe89663764208c1f5a1bdc41a7d7433099c811f5f53f2a7836a0ba2a5e5", - "clientSha256": "d6d26d2466fba35dada64966ca793444c2cf0164cd24c907ac406b6e9d1d1650" + "sourceArchiveSha256": "98deff7ba70bfa6da0cce7162e40be58fb441efef1fcb541c5962b385fe3ac46", + "clientSha256": "3a50070e3098050f572524f832fbb723a2abf74fa03f09c8d17da0e7a0d48735" }, "vendor/truapi-host": { "name": "@parity/truapi-host", "version": "0.20.0", - "sourceArchiveSha256": "009be482119b7a2631216481a5842ab74c97c77fac5d5ede25df241ffec1e9ba", + "sourceArchiveSha256": "9b4155a24e536004248f45a62fc7389d36f656a98aa9c5472fcd1b41e920dc27", "dependencyOverride": "@parity/truapi=file:../truapi", - "wasmSha256": "78ee2f41f699ba2bea5774f48c0eb95a9513850033b3beb78f12f6cdc19a89f3" + "wasmSha256": "c5d27836e517a7ca0b413933e51b55de98ff1fecd48c53de5ec87530f6518beb" } }, - "wasmUpstreamRevision": "95614da751510d755357beddc384b31415178b49" + "wasmUpstreamRevision": "298cf4286c07cf0c5dc40116d3e957cc1caf5d1b" } diff --git a/vendor/truapi-host/dist/generated/host-callbacks.d.ts b/vendor/truapi-host/dist/generated/host-callbacks.d.ts index 96afe960f..f04f27c4e 100644 --- a/vendor/truapi-host/dist/generated/host-callbacks.d.ts +++ b/vendor/truapi-host/dist/generated/host-callbacks.d.ts @@ -278,6 +278,26 @@ export type CoreStorageKey = rootPublicKey: Uint8Array; genesisHash: Uint8Array; }; +} +/** + * The profile reference the user disclosed to their chat contacts, with + * the product that disclosed it. Wallet-owned: one per user, whichever + * product wrote it. The reference is a bearer capability. + */ + | { + tag: "ProfileDisclosure"; + value?: undefined; +} +/** + * Profile references this product's chat contacts disclosed, newest per + * contact. Product-indexed, like the roster they belong to, so clearing + * the product clears them. The references are bearer capabilities. + */ + | { + tag: "ProfileReferencesReceived"; + value: { + productId: string; + }; }; /** * Review shown before a product creates a ring-VRF proof (RFC 0004). diff --git a/vendor/truapi-host/dist/generated/host-callbacks.js b/vendor/truapi-host/dist/generated/host-callbacks.js index 3397fc3a3..76d93a40b 100644 --- a/vendor/truapi-host/dist/generated/host-callbacks.js +++ b/vendor/truapi-host/dist/generated/host-callbacks.js @@ -30,7 +30,7 @@ export const ChatAuthorityReview = S.lazy(() => S.Struct({ productId: S.str })); * Storage is host-local; `storage.md` records the current status quo: * */ -export const CoreStorageKey = S.lazy(() => S.TaggedUnion({ AuthSession: S._void, PairingDeviceIdentity: S._void, PermissionAuthorization: S.Struct({ productId: S.str, request: PermissionAuthorizationRequest }), AllowanceKeys: S.Struct({ sessionId: S.str }), LastProcessedPairingStatement: S._void, AutoSigningKey: S.Struct({ productId: S.str }), AutoSigningKeys: S._void, RingVrfRegistry: S.Struct({ rootPublicKey: S.Bytes(32) }), StatementRenewalTargets: S._void, DeviceEncryptionKey: S._void, ProductSubtree: S.Struct({ sessionId: S.str, productId: S.str }), SsoResponderRequestLedger: S.Struct({ rootPublicKey: S.Bytes(32), peerStatementAccountId: S.Bytes(32), peerEncryptionPublicKey: S.Bytes(32) }), ProductManifest: S.Struct({ productId: S.str }), MainPurseCoinage: S.Struct({ rootPublicKey: S.Bytes(32), genesisHash: S.Bytes(32) }), NativeChatDevice: S.Struct({ rootPublicKey: S.Bytes(32), genesisHash: S.Bytes(32), productId: S.str }), NativeChatFileChunk: S.Struct({ rootPublicKey: S.Bytes(32), genesisHash: S.Bytes(32), productId: S.str, attachmentId: S.Bytes(32), chunkIndex: S.u32 }), NativeChatProducts: S.Struct({ rootPublicKey: S.Bytes(32), genesisHash: S.Bytes(32) }) })); +export const CoreStorageKey = S.lazy(() => S.TaggedUnion({ AuthSession: S._void, PairingDeviceIdentity: S._void, PermissionAuthorization: S.Struct({ productId: S.str, request: PermissionAuthorizationRequest }), AllowanceKeys: S.Struct({ sessionId: S.str }), LastProcessedPairingStatement: S._void, AutoSigningKey: S.Struct({ productId: S.str }), AutoSigningKeys: S._void, RingVrfRegistry: S.Struct({ rootPublicKey: S.Bytes(32) }), StatementRenewalTargets: S._void, DeviceEncryptionKey: S._void, ProductSubtree: S.Struct({ sessionId: S.str, productId: S.str }), SsoResponderRequestLedger: S.Struct({ rootPublicKey: S.Bytes(32), peerStatementAccountId: S.Bytes(32), peerEncryptionPublicKey: S.Bytes(32) }), ProductManifest: S.Struct({ productId: S.str }), MainPurseCoinage: S.Struct({ rootPublicKey: S.Bytes(32), genesisHash: S.Bytes(32) }), NativeChatDevice: S.Struct({ rootPublicKey: S.Bytes(32), genesisHash: S.Bytes(32), productId: S.str }), NativeChatFileChunk: S.Struct({ rootPublicKey: S.Bytes(32), genesisHash: S.Bytes(32), productId: S.str, attachmentId: S.Bytes(32), chunkIndex: S.u32 }), NativeChatProducts: S.Struct({ rootPublicKey: S.Bytes(32), genesisHash: S.Bytes(32) }), ProfileDisclosure: S._void, ProfileReferencesReceived: S.Struct({ productId: S.str }) })); /** * Review shown before a product creates a ring-VRF proof (RFC 0004). */ diff --git a/vendor/truapi-host/dist/testing/create-mock-client.cjs b/vendor/truapi-host/dist/testing/create-mock-client.cjs index c599fee7d..67927fbeb 100644 --- a/vendor/truapi-host/dist/testing/create-mock-client.cjs +++ b/vendor/truapi-host/dist/testing/create-mock-client.cjs @@ -557,7 +557,7 @@ var init_host_callbacks = __esm({ AccountAliasReview = S.lazy(() => S.Struct({ callingProductId: S.str, context: import_truapi3.ProductProofContext, ringLocation: import_truapi3.RingLocation })); AuthState = S.lazy(() => S.TaggedUnion({ Disconnected: S._void, Pairing: S.Struct({ deeplink: S.str }), Connected: SessionUiInfo, LoginFailed: S.Struct({ kind: LoginFailureKind, reason: S.str }), Authenticating: S._void })); ChatAuthorityReview = S.lazy(() => S.Struct({ productId: S.str })); - CoreStorageKey = S.lazy(() => S.TaggedUnion({ AuthSession: S._void, PairingDeviceIdentity: S._void, PermissionAuthorization: S.Struct({ productId: S.str, request: PermissionAuthorizationRequest }), AllowanceKeys: S.Struct({ sessionId: S.str }), LastProcessedPairingStatement: S._void, AutoSigningKey: S.Struct({ productId: S.str }), AutoSigningKeys: S._void, RingVrfRegistry: S.Struct({ rootPublicKey: S.Bytes(32) }), StatementRenewalTargets: S._void, DeviceEncryptionKey: S._void, ProductSubtree: S.Struct({ sessionId: S.str, productId: S.str }), SsoResponderRequestLedger: S.Struct({ rootPublicKey: S.Bytes(32), peerStatementAccountId: S.Bytes(32), peerEncryptionPublicKey: S.Bytes(32) }), ProductManifest: S.Struct({ productId: S.str }), MainPurseCoinage: S.Struct({ rootPublicKey: S.Bytes(32), genesisHash: S.Bytes(32) }), NativeChatDevice: S.Struct({ rootPublicKey: S.Bytes(32), genesisHash: S.Bytes(32), productId: S.str }), NativeChatFileChunk: S.Struct({ rootPublicKey: S.Bytes(32), genesisHash: S.Bytes(32), productId: S.str, attachmentId: S.Bytes(32), chunkIndex: S.u32 }), NativeChatProducts: S.Struct({ rootPublicKey: S.Bytes(32), genesisHash: S.Bytes(32) }) })); + CoreStorageKey = S.lazy(() => S.TaggedUnion({ AuthSession: S._void, PairingDeviceIdentity: S._void, PermissionAuthorization: S.Struct({ productId: S.str, request: PermissionAuthorizationRequest }), AllowanceKeys: S.Struct({ sessionId: S.str }), LastProcessedPairingStatement: S._void, AutoSigningKey: S.Struct({ productId: S.str }), AutoSigningKeys: S._void, RingVrfRegistry: S.Struct({ rootPublicKey: S.Bytes(32) }), StatementRenewalTargets: S._void, DeviceEncryptionKey: S._void, ProductSubtree: S.Struct({ sessionId: S.str, productId: S.str }), SsoResponderRequestLedger: S.Struct({ rootPublicKey: S.Bytes(32), peerStatementAccountId: S.Bytes(32), peerEncryptionPublicKey: S.Bytes(32) }), ProductManifest: S.Struct({ productId: S.str }), MainPurseCoinage: S.Struct({ rootPublicKey: S.Bytes(32), genesisHash: S.Bytes(32) }), NativeChatDevice: S.Struct({ rootPublicKey: S.Bytes(32), genesisHash: S.Bytes(32), productId: S.str }), NativeChatFileChunk: S.Struct({ rootPublicKey: S.Bytes(32), genesisHash: S.Bytes(32), productId: S.str, attachmentId: S.Bytes(32), chunkIndex: S.u32 }), NativeChatProducts: S.Struct({ rootPublicKey: S.Bytes(32), genesisHash: S.Bytes(32) }), ProfileDisclosure: S._void, ProfileReferencesReceived: S.Struct({ productId: S.str }) })); CreateProofReview = S.lazy(() => S.Struct({ callingProductId: S.str, context: import_truapi3.ProductProofContext, ringLocation: import_truapi3.RingLocation, message: S.Bytes() })); CreateTransactionReview = S.lazy(() => S.TaggedUnion({ Product: import_truapi3.ProductAccountTxPayload, LegacyAccount: import_truapi3.LegacyAccountTxPayload })); DevicePermissionStatus = S.lazy(() => S.Status("Granted", "Denied", "NotDetermined", "NotApplicable")); diff --git a/vendor/truapi-host/dist/testing/host-page.cjs b/vendor/truapi-host/dist/testing/host-page.cjs index e6724686a..fb4a8c525 100644 --- a/vendor/truapi-host/dist/testing/host-page.cjs +++ b/vendor/truapi-host/dist/testing/host-page.cjs @@ -54,7 +54,7 @@ var init_host_callbacks = __esm({ AccountAliasReview = S.lazy(() => S.Struct({ callingProductId: S.str, context: import_truapi.ProductProofContext, ringLocation: import_truapi.RingLocation })); AuthState = S.lazy(() => S.TaggedUnion({ Disconnected: S._void, Pairing: S.Struct({ deeplink: S.str }), Connected: SessionUiInfo, LoginFailed: S.Struct({ kind: LoginFailureKind, reason: S.str }), Authenticating: S._void })); ChatAuthorityReview = S.lazy(() => S.Struct({ productId: S.str })); - CoreStorageKey = S.lazy(() => S.TaggedUnion({ AuthSession: S._void, PairingDeviceIdentity: S._void, PermissionAuthorization: S.Struct({ productId: S.str, request: PermissionAuthorizationRequest }), AllowanceKeys: S.Struct({ sessionId: S.str }), LastProcessedPairingStatement: S._void, AutoSigningKey: S.Struct({ productId: S.str }), AutoSigningKeys: S._void, RingVrfRegistry: S.Struct({ rootPublicKey: S.Bytes(32) }), StatementRenewalTargets: S._void, DeviceEncryptionKey: S._void, ProductSubtree: S.Struct({ sessionId: S.str, productId: S.str }), SsoResponderRequestLedger: S.Struct({ rootPublicKey: S.Bytes(32), peerStatementAccountId: S.Bytes(32), peerEncryptionPublicKey: S.Bytes(32) }), ProductManifest: S.Struct({ productId: S.str }), MainPurseCoinage: S.Struct({ rootPublicKey: S.Bytes(32), genesisHash: S.Bytes(32) }), NativeChatDevice: S.Struct({ rootPublicKey: S.Bytes(32), genesisHash: S.Bytes(32), productId: S.str }), NativeChatFileChunk: S.Struct({ rootPublicKey: S.Bytes(32), genesisHash: S.Bytes(32), productId: S.str, attachmentId: S.Bytes(32), chunkIndex: S.u32 }), NativeChatProducts: S.Struct({ rootPublicKey: S.Bytes(32), genesisHash: S.Bytes(32) }) })); + CoreStorageKey = S.lazy(() => S.TaggedUnion({ AuthSession: S._void, PairingDeviceIdentity: S._void, PermissionAuthorization: S.Struct({ productId: S.str, request: PermissionAuthorizationRequest }), AllowanceKeys: S.Struct({ sessionId: S.str }), LastProcessedPairingStatement: S._void, AutoSigningKey: S.Struct({ productId: S.str }), AutoSigningKeys: S._void, RingVrfRegistry: S.Struct({ rootPublicKey: S.Bytes(32) }), StatementRenewalTargets: S._void, DeviceEncryptionKey: S._void, ProductSubtree: S.Struct({ sessionId: S.str, productId: S.str }), SsoResponderRequestLedger: S.Struct({ rootPublicKey: S.Bytes(32), peerStatementAccountId: S.Bytes(32), peerEncryptionPublicKey: S.Bytes(32) }), ProductManifest: S.Struct({ productId: S.str }), MainPurseCoinage: S.Struct({ rootPublicKey: S.Bytes(32), genesisHash: S.Bytes(32) }), NativeChatDevice: S.Struct({ rootPublicKey: S.Bytes(32), genesisHash: S.Bytes(32), productId: S.str }), NativeChatFileChunk: S.Struct({ rootPublicKey: S.Bytes(32), genesisHash: S.Bytes(32), productId: S.str, attachmentId: S.Bytes(32), chunkIndex: S.u32 }), NativeChatProducts: S.Struct({ rootPublicKey: S.Bytes(32), genesisHash: S.Bytes(32) }), ProfileDisclosure: S._void, ProfileReferencesReceived: S.Struct({ productId: S.str }) })); CreateProofReview = S.lazy(() => S.Struct({ callingProductId: S.str, context: import_truapi.ProductProofContext, ringLocation: import_truapi.RingLocation, message: S.Bytes() })); CreateTransactionReview = S.lazy(() => S.TaggedUnion({ Product: import_truapi.ProductAccountTxPayload, LegacyAccount: import_truapi.LegacyAccountTxPayload })); DevicePermissionStatus = S.lazy(() => S.Status("Granted", "Denied", "NotDetermined", "NotApplicable")); diff --git a/vendor/truapi-host/dist/wasm/web/package.json b/vendor/truapi-host/dist/wasm/web/package.json index 75949a975..ab2b27bf8 100644 --- a/vendor/truapi-host/dist/wasm/web/package.json +++ b/vendor/truapi-host/dist/wasm/web/package.json @@ -7,12 +7,11 @@ "files": [ "truapi_server_bg.wasm", "truapi_server.js", - "truapi_server.d.ts", - "LICENSE-AGPL-3.0" + "truapi_server.d.ts" ], "main": "truapi_server.js", "types": "truapi_server.d.ts", "sideEffects": [ "./snippets/*" ] -} +} \ No newline at end of file diff --git a/vendor/truapi-host/dist/wasm/web/truapi_server.d.ts b/vendor/truapi-host/dist/wasm/web/truapi_server.d.ts index 65e74651b..e2ec9ccd6 100644 --- a/vendor/truapi-host/dist/wasm/web/truapi_server.d.ts +++ b/vendor/truapi-host/dist/wasm/web/truapi_server.d.ts @@ -413,12 +413,12 @@ export interface InitOutput { readonly wasmsigninghostruntime_sessionChatIdentityKey: (a: number, b: number) => void; readonly wasmsigninghostruntime_setPermissionAuthorizationStatus: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number; readonly wireSchemaHash: (a: number) => void; - readonly __wasm_bindgen_func_elem_24307: (a: number, b: number, c: number, d: number) => void; - readonly __wasm_bindgen_func_elem_24309: (a: number, b: number, c: number, d: number) => void; - readonly __wasm_bindgen_func_elem_7876: (a: number, b: number, c: number) => void; - readonly __wasm_bindgen_func_elem_7877: (a: number, b: number, c: number) => void; - readonly __wasm_bindgen_func_elem_17380: (a: number, b: number) => void; - readonly __wasm_bindgen_func_elem_7878: (a: number, b: number) => void; + readonly __wasm_bindgen_func_elem_24438: (a: number, b: number, c: number, d: number) => void; + readonly __wasm_bindgen_func_elem_24443: (a: number, b: number, c: number, d: number) => void; + readonly __wasm_bindgen_func_elem_5022: (a: number, b: number, c: number) => void; + readonly __wasm_bindgen_func_elem_5019: (a: number, b: number, c: number) => void; + readonly __wasm_bindgen_func_elem_5021: (a: number, b: number) => void; + readonly __wasm_bindgen_func_elem_17551: (a: number, b: number) => void; readonly __wbindgen_export: (a: number, b: number) => number; readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number; readonly __wbindgen_export3: (a: number) => void; diff --git a/vendor/truapi-host/dist/wasm/web/truapi_server.js b/vendor/truapi-host/dist/wasm/web/truapi_server.js index 09dab3581..7a30f697f 100644 --- a/vendor/truapi-host/dist/wasm/web/truapi_server.js +++ b/vendor/truapi-host/dist/wasm/web/truapi_server.js @@ -1146,7 +1146,7 @@ function __wbg_get_imports() { const a = state0.a; state0.a = 0; try { - return __wasm_bindgen_func_elem_24309(a, state0.b, arg0, arg1); + return __wasm_bindgen_func_elem_24443(a, state0.b, arg0, arg1); } finally { state0.a = a; } @@ -1261,28 +1261,28 @@ function __wbg_get_imports() { console.warn(getObject(arg0)); }, __wbindgen_cast_0000000000000001: function(arg0, arg1) { - // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 2793, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`. - const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_24307); + // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 21, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`. + const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_5022); return addHeapObject(ret); }, __wbindgen_cast_0000000000000002: function(arg0, arg1) { - // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 87, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`. - const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_7876); + // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 2816, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`. + const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_24438); return addHeapObject(ret); }, __wbindgen_cast_0000000000000003: function(arg0, arg1) { - // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 2383, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`. - const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_17380); + // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 20, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: false }) -> Externref`. + const ret = makeClosure(arg0, arg1, __wasm_bindgen_func_elem_5019); return addHeapObject(ret); }, __wbindgen_cast_0000000000000004: function(arg0, arg1) { - // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 88, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: false }) -> Externref`. - const ret = makeClosure(arg0, arg1, __wasm_bindgen_func_elem_7877); + // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 22, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`. + const ret = makeClosure(arg0, arg1, __wasm_bindgen_func_elem_5021); return addHeapObject(ret); }, __wbindgen_cast_0000000000000005: function(arg0, arg1) { - // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 89, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`. - const ret = makeClosure(arg0, arg1, __wasm_bindgen_func_elem_7878); + // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 2411, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`. + const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_17551); return addHeapObject(ret); }, __wbindgen_cast_0000000000000006: function(arg0) { @@ -1326,22 +1326,22 @@ function __wbg_get_imports() { }; } -function __wasm_bindgen_func_elem_17380(arg0, arg1) { - wasm.__wasm_bindgen_func_elem_17380(arg0, arg1); +function __wasm_bindgen_func_elem_5021(arg0, arg1) { + wasm.__wasm_bindgen_func_elem_5021(arg0, arg1); } -function __wasm_bindgen_func_elem_7878(arg0, arg1) { - wasm.__wasm_bindgen_func_elem_7878(arg0, arg1); +function __wasm_bindgen_func_elem_17551(arg0, arg1) { + wasm.__wasm_bindgen_func_elem_17551(arg0, arg1); } -function __wasm_bindgen_func_elem_7876(arg0, arg1, arg2) { - wasm.__wasm_bindgen_func_elem_7876(arg0, arg1, addHeapObject(arg2)); +function __wasm_bindgen_func_elem_5022(arg0, arg1, arg2) { + wasm.__wasm_bindgen_func_elem_5022(arg0, arg1, addHeapObject(arg2)); } -function __wasm_bindgen_func_elem_7877(arg0, arg1) { +function __wasm_bindgen_func_elem_5019(arg0, arg1) { try { const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); - wasm.__wasm_bindgen_func_elem_7877(retptr, arg0, arg1); + wasm.__wasm_bindgen_func_elem_5019(retptr, arg0, arg1); var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true); var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true); if (r1) { @@ -1352,10 +1352,10 @@ function __wasm_bindgen_func_elem_7877(arg0, arg1) { } } -function __wasm_bindgen_func_elem_24307(arg0, arg1, arg2) { +function __wasm_bindgen_func_elem_24438(arg0, arg1, arg2) { try { const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); - wasm.__wasm_bindgen_func_elem_24307(retptr, arg0, arg1, addHeapObject(arg2)); + wasm.__wasm_bindgen_func_elem_24438(retptr, arg0, arg1, addHeapObject(arg2)); var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true); var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true); if (r1) { @@ -1366,8 +1366,8 @@ function __wasm_bindgen_func_elem_24307(arg0, arg1, arg2) { } } -function __wasm_bindgen_func_elem_24309(arg0, arg1, arg2, arg3) { - wasm.__wasm_bindgen_func_elem_24309(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3)); +function __wasm_bindgen_func_elem_24443(arg0, arg1, arg2, arg3) { + wasm.__wasm_bindgen_func_elem_24443(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3)); } const WasmPairingHostRuntimeFinalization = (typeof FinalizationRegistry === 'undefined') diff --git a/vendor/truapi-host/dist/wasm/web/truapi_server_bg.wasm b/vendor/truapi-host/dist/wasm/web/truapi_server_bg.wasm index 36553467e..bb853378b 100644 Binary files a/vendor/truapi-host/dist/wasm/web/truapi_server_bg.wasm and b/vendor/truapi-host/dist/wasm/web/truapi_server_bg.wasm differ diff --git a/vendor/truapi-host/dist/wasm/web/truapi_server_bg.wasm.br b/vendor/truapi-host/dist/wasm/web/truapi_server_bg.wasm.br index 72f922710..fb0eb5502 100644 Binary files a/vendor/truapi-host/dist/wasm/web/truapi_server_bg.wasm.br and b/vendor/truapi-host/dist/wasm/web/truapi_server_bg.wasm.br differ diff --git a/vendor/truapi-host/dist/wasm/web/truapi_server_bg.wasm.d.ts b/vendor/truapi-host/dist/wasm/web/truapi_server_bg.wasm.d.ts index a365e6b18..b3ec2e643 100644 --- a/vendor/truapi-host/dist/wasm/web/truapi_server_bg.wasm.d.ts +++ b/vendor/truapi-host/dist/wasm/web/truapi_server_bg.wasm.d.ts @@ -59,12 +59,12 @@ export const wasmsigninghostruntime_releaseWorker: (a: number, b: number, c: num export const wasmsigninghostruntime_sessionChatIdentityKey: (a: number, b: number) => void; export const wasmsigninghostruntime_setPermissionAuthorizationStatus: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number; export const wireSchemaHash: (a: number) => void; -export const __wasm_bindgen_func_elem_24307: (a: number, b: number, c: number, d: number) => void; -export const __wasm_bindgen_func_elem_24309: (a: number, b: number, c: number, d: number) => void; -export const __wasm_bindgen_func_elem_7876: (a: number, b: number, c: number) => void; -export const __wasm_bindgen_func_elem_7877: (a: number, b: number, c: number) => void; -export const __wasm_bindgen_func_elem_17380: (a: number, b: number) => void; -export const __wasm_bindgen_func_elem_7878: (a: number, b: number) => void; +export const __wasm_bindgen_func_elem_24438: (a: number, b: number, c: number, d: number) => void; +export const __wasm_bindgen_func_elem_24443: (a: number, b: number, c: number, d: number) => void; +export const __wasm_bindgen_func_elem_5022: (a: number, b: number, c: number) => void; +export const __wasm_bindgen_func_elem_5019: (a: number, b: number, c: number) => void; +export const __wasm_bindgen_func_elem_5021: (a: number, b: number) => void; +export const __wasm_bindgen_func_elem_17551: (a: number, b: number) => void; export const __wbindgen_export: (a: number, b: number) => number; export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number; export const __wbindgen_export3: (a: number) => void; diff --git a/vendor/truapi-host/dist/wasm/web/truapi_server_bg.wasm.gz b/vendor/truapi-host/dist/wasm/web/truapi_server_bg.wasm.gz index e7db80fb7..c009a52c8 100644 Binary files a/vendor/truapi-host/dist/wasm/web/truapi_server_bg.wasm.gz and b/vendor/truapi-host/dist/wasm/web/truapi_server_bg.wasm.gz differ diff --git a/vendor/truapi/dist/explorer/codegen/types.js b/vendor/truapi/dist/explorer/codegen/types.js index afad37c39..b5d0a677c 100644 --- a/vendor/truapi/dist/explorer/codegen/types.js +++ b/vendor/truapi/dist/explorer/codegen/types.js @@ -3761,6 +3761,77 @@ export const types = [ }, ], }, + { + id: "host-profile-disclose-error", + name: "HostProfileDiscloseError", + category: "profile", + definition: 'export type HostProfileDiscloseError =\n | { tag: "InvalidReference"; value?: undefined }\n | { tag: "Unknown"; value: { reason: string } }\n;', + description: "Profile disclosure failure.", + variants: [ + { + name: "InvalidReference", + type: '{ tag: "InvalidReference"; value?: undefined }', + description: "The reference is empty, too long, or not printable ASCII.", + }, + { + name: "Unknown", + type: '{ tag: "Unknown"; value: { reason: string } }', + description: "Catch-all.", + }, + ], + }, + { + id: "host-profile-disclose-request", + name: "HostProfileDiscloseRequest", + category: "profile", + definition: "export interface HostProfileDiscloseRequest {\n reference: string;\n}", + description: "Request to give the user's chat contacts a profile reference.\n\nThe reference is a bearer capability for everyone the host relays it to.\nThe host stores it as the user's own and never parses it.", + fields: [ + { + name: "reference", + type: "string", + description: "Opaque profile reference, e.g. a Seity contacts reference.", + }, + ], + }, + { + id: "host-profile-present-contact-error", + name: "HostProfilePresentContactError", + category: "profile", + definition: 'export type HostProfilePresentContactError =\n | { tag: "NotShared"; value?: undefined }\n | { tag: "InvalidReference"; value?: undefined }\n | { tag: "Unknown"; value: { reason: string } }\n;', + description: "Contact profile presentation failure.", + variants: [ + { + name: "NotShared", + type: '{ tag: "NotShared"; value?: undefined }', + description: "This contact has not shared a profile with the user.", + }, + { + name: "InvalidReference", + type: '{ tag: "InvalidReference"; value?: undefined }', + description: "The host holds a reference it cannot parse.", + }, + { + name: "Unknown", + type: '{ tag: "Unknown"; value: { reason: string } }', + description: "Catch-all.", + }, + ], + }, + { + id: "host-profile-present-contact-request", + name: "HostProfilePresentContactRequest", + category: "profile", + definition: "export interface HostProfilePresentContactRequest {\n peerIdentity: HexString;\n}", + description: "Request to show a chat contact's profile in host-owned UI.\n\nThe product names the contact, never a reference: the host looks up the\nreference that contact's host sent, so the product cannot read, keep or\nsubstitute it.", + fields: [ + { + name: "peer_identity", + type: "HexString", + description: "The contact's authenticated root identity, as the chat API names it.", + }, + ], + }, { id: "host-profile-present-error", name: "HostProfilePresentError", @@ -3794,6 +3865,25 @@ export const types = [ }, ], }, + { + id: "host-profile-retract-error", + name: "HostProfileRetractError", + category: "profile", + definition: 'export type HostProfileRetractError =\n | { tag: "NotDiscloser"; value?: undefined }\n | { tag: "Unknown"; value: { reason: string } }\n;', + description: "Profile retraction failure.", + variants: [ + { + name: "NotDiscloser", + type: '{ tag: "NotDiscloser"; value?: undefined }', + description: "Another product disclosed the reference the host holds.", + }, + { + name: "Unknown", + type: '{ tag: "Unknown"; value: { reason: string } }', + description: "Catch-all.", + }, + ], + }, { id: "host-push-notification-cancel-request", name: "HostPushNotificationCancelRequest", diff --git a/vendor/truapi/dist/generated/client.d.ts b/vendor/truapi/dist/generated/client.d.ts index b1d51c0ee..f02ac337c 100644 --- a/vendor/truapi/dist/generated/client.d.ts +++ b/vendor/truapi/dist/generated/client.d.ts @@ -8,7 +8,7 @@ export { ResultAsync, SubscriptionError }; export type { CallOptions, HostInitiatedSubscriptionHandler, ObservableLike, Observer, Result, Subscription, TrUApiTransport }; export declare const TRUAPI_VERSION: 2; export declare const TRUAPI_CODEC_VERSION: 3; -export declare const TRUAPI_WIRE_SCHEMA_HASH: "c8972ad11436a788"; +export declare const TRUAPI_WIRE_SCHEMA_HASH: "5e0d5318926dc17f"; /** Account lookup, aliasing, and proof generation. */ export declare class AccountClient { #private; @@ -323,6 +323,28 @@ export declare class ProfileClient { * returned; a reference this host cannot parse is `InvalidReference`. */ present(request: T.HostProfilePresentRequest, options?: CallOptions): ResultAsync>; + /** + * Give the user's chat contacts this reference to their profile. + * + * The host stores it as the user's own and relays it to each contact, + * replacing whatever it sent before; the product never learns who they + * are. App executions only. A reference this core cannot screen is + * `InvalidReference`. + */ + disclose(request: T.HostProfileDiscloseRequest, options?: CallOptions): ResultAsync>; + /** + * Withdraw the reference this product disclosed. Contacts are told to + * drop what they hold. A product that did not disclose it is refused. + */ + retract(options?: CallOptions): ResultAsync>; + /** + * Show a chat contact's profile in host-owned UI. + * + * The product names the contact; the host looks up the reference that + * contact shared and presents it as `present` would. The reference never + * reaches the product. A contact who shared nothing is `NotShared`. + */ + presentContact(request: T.HostProfilePresentContactRequest, options?: CallOptions): ResultAsync>; } /** Product-rendered bodies and the actions triggered inside them. */ export declare class RendererClient { diff --git a/vendor/truapi/dist/generated/client.js b/vendor/truapi/dist/generated/client.js index 60dd6a355..07fddeae7 100644 --- a/vendor/truapi/dist/generated/client.js +++ b/vendor/truapi/dist/generated/client.js @@ -7,7 +7,7 @@ import * as W from './wire-table.js'; export { ResultAsync, SubscriptionError }; export const TRUAPI_VERSION = 2; export const TRUAPI_CODEC_VERSION = 3; -export const TRUAPI_WIRE_SCHEMA_HASH = "c8972ad11436a788"; +export const TRUAPI_WIRE_SCHEMA_HASH = "5e0d5318926dc17f"; function toSubscriptionError(error) { if (error instanceof SubscriptionError) return error; @@ -1020,6 +1020,58 @@ export class ProfileClient { }, }); } + /** + * Give the user's chat contacts this reference to their profile. + * + * The host stores it as the user's own and relays it to each contact, + * replacing whatever it sent before; the product never learns who they + * are. App executions only. A reference this core cannot screen is + * `InvalidReference`. + */ + disclose(request, options) { + return this.#transport.request({ + ids: W.PROFILE_DISCLOSE, + payload: T.VersionedHostProfileDiscloseRequest.enc({ tag: "V1", value: request }), + signal: options?.signal, + decodeResponse: (payload) => { + const result = S.Result(T.VersionedHostProfileDiscloseResponse, S.CallError(T.VersionedHostProfileDiscloseError)).dec(payload); + return result.success ? { success: true, value: result.value.value } : result; + }, + }); + } + /** + * Withdraw the reference this product disclosed. Contacts are told to + * drop what they hold. A product that did not disclose it is refused. + */ + retract(options) { + return this.#transport.request({ + ids: W.PROFILE_RETRACT, + payload: T.VersionedHostProfileRetractRequest.enc({ tag: "V1", value: undefined }), + signal: options?.signal, + decodeResponse: (payload) => { + const result = S.Result(T.VersionedHostProfileRetractResponse, S.CallError(T.VersionedHostProfileRetractError)).dec(payload); + return result.success ? { success: true, value: result.value.value } : result; + }, + }); + } + /** + * Show a chat contact's profile in host-owned UI. + * + * The product names the contact; the host looks up the reference that + * contact shared and presents it as `present` would. The reference never + * reaches the product. A contact who shared nothing is `NotShared`. + */ + presentContact(request, options) { + return this.#transport.request({ + ids: W.PROFILE_PRESENT_CONTACT, + payload: T.VersionedHostProfilePresentContactRequest.enc({ tag: "V1", value: request }), + signal: options?.signal, + decodeResponse: (payload) => { + const result = S.Result(T.VersionedHostProfilePresentContactResponse, S.CallError(T.VersionedHostProfilePresentContactError)).dec(payload); + return result.success ? { success: true, value: result.value.value } : result; + }, + }); + } } /** Product-rendered bodies and the actions triggered inside them. */ export class RendererClient { diff --git a/vendor/truapi/dist/generated/internal-client.d.ts b/vendor/truapi/dist/generated/internal-client.d.ts index 3f47031fa..e95747b26 100644 --- a/vendor/truapi/dist/generated/internal-client.d.ts +++ b/vendor/truapi/dist/generated/internal-client.d.ts @@ -7,7 +7,7 @@ export { ResultAsync, SubscriptionError }; export type { CallOptions, HostInitiatedSubscriptionHandler, ObservableLike, Observer, Result, Subscription, TrUApiTransport }; export declare const TRUAPI_VERSION: 2; export declare const TRUAPI_CODEC_VERSION: 3; -export declare const TRUAPI_WIRE_SCHEMA_HASH: "c8972ad11436a788"; +export declare const TRUAPI_WIRE_SCHEMA_HASH: "5e0d5318926dc17f"; /** Permission request methods. */ declare class PermissionsClient { #private; diff --git a/vendor/truapi/dist/generated/internal-client.js b/vendor/truapi/dist/generated/internal-client.js index 2889d158f..aa85a3fe4 100644 --- a/vendor/truapi/dist/generated/internal-client.js +++ b/vendor/truapi/dist/generated/internal-client.js @@ -7,7 +7,7 @@ import * as W from './wire-table.js'; export { ResultAsync, SubscriptionError }; export const TRUAPI_VERSION = 2; export const TRUAPI_CODEC_VERSION = 3; -export const TRUAPI_WIRE_SCHEMA_HASH = "c8972ad11436a788"; +export const TRUAPI_WIRE_SCHEMA_HASH = "5e0d5318926dc17f"; /** Permission request methods. */ class PermissionsClient { #transport; diff --git a/vendor/truapi/dist/generated/types.d.ts b/vendor/truapi/dist/generated/types.d.ts index 8cd14b12a..73756fedb 100644 --- a/vendor/truapi/dist/generated/types.d.ts +++ b/vendor/truapi/dist/generated/types.d.ts @@ -1897,6 +1897,54 @@ export type VersionedHostProductDeviceChatResponse = value: HostProductDeviceChatResponse; }; export declare const VersionedHostProductDeviceChatResponse: S.Codec; +/** Versioned envelope for [`HostProfileDiscloseError`]. */ +export type VersionedHostProfileDiscloseError = +/** Version 1 payload. */ +{ + tag: "V1"; + value: HostProfileDiscloseError; +}; +export declare const VersionedHostProfileDiscloseError: S.Codec; +/** Versioned envelope for [`HostProfileDiscloseRequest`]. */ +export type VersionedHostProfileDiscloseRequest = +/** Version 1 payload. */ +{ + tag: "V1"; + value: HostProfileDiscloseRequest; +}; +export declare const VersionedHostProfileDiscloseRequest: S.Codec; +/** Versioned envelope for [`HostProfileDiscloseResponse`]. */ +export type VersionedHostProfileDiscloseResponse = +/** Version 1 (no payload). */ +{ + tag: "V1"; + value?: undefined; +}; +export declare const VersionedHostProfileDiscloseResponse: S.Codec; +/** Versioned envelope for [`HostProfilePresentContactError`]. */ +export type VersionedHostProfilePresentContactError = +/** Version 1 payload. */ +{ + tag: "V1"; + value: HostProfilePresentContactError; +}; +export declare const VersionedHostProfilePresentContactError: S.Codec; +/** Versioned envelope for [`HostProfilePresentContactRequest`]. */ +export type VersionedHostProfilePresentContactRequest = +/** Version 1 payload. */ +{ + tag: "V1"; + value: HostProfilePresentContactRequest; +}; +export declare const VersionedHostProfilePresentContactRequest: S.Codec; +/** Versioned envelope for [`HostProfilePresentContactResponse`]. */ +export type VersionedHostProfilePresentContactResponse = +/** Version 1 (no payload). */ +{ + tag: "V1"; + value?: undefined; +}; +export declare const VersionedHostProfilePresentContactResponse: S.Codec; /** Versioned envelope for [`HostProfilePresentError`]. */ export type VersionedHostProfilePresentError = /** Version 1 payload. */ @@ -1921,6 +1969,30 @@ export type VersionedHostProfilePresentResponse = value?: undefined; }; export declare const VersionedHostProfilePresentResponse: S.Codec; +/** Versioned envelope for [`HostProfileRetractError`]. */ +export type VersionedHostProfileRetractError = +/** Version 1 payload. */ +{ + tag: "V1"; + value: HostProfileRetractError; +}; +export declare const VersionedHostProfileRetractError: S.Codec; +/** Versioned envelope for [`HostProfileRetractRequest`]. */ +export type VersionedHostProfileRetractRequest = +/** Version 1 (no payload). */ +{ + tag: "V1"; + value?: undefined; +}; +export declare const VersionedHostProfileRetractRequest: S.Codec; +/** Versioned envelope for [`HostProfileRetractResponse`]. */ +export type VersionedHostProfileRetractResponse = +/** Version 1 (no payload). */ +{ + tag: "V1"; + value?: undefined; +}; +export declare const VersionedHostProfileRetractResponse: S.Codec; /** Versioned envelope for [`HostPushNotificationCancelError`]. */ export type VersionedHostPushNotificationCancelError = /** Version 1 payload. */ @@ -4472,6 +4544,64 @@ export interface HostPocketRemoveCardRequest { cardId: string; } export declare const HostPocketRemoveCardRequest: S.Codec; +/** Profile disclosure failure. */ +export type HostProfileDiscloseError = +/** The reference is empty, too long, or not printable ASCII. */ +{ + tag: "InvalidReference"; + value?: undefined; +} +/** Catch-all. */ + | { + tag: "Unknown"; + value: { + reason: string; + }; +}; +export declare const HostProfileDiscloseError: S.Codec; +/** + * Request to give the user's chat contacts a profile reference. + * + * The reference is a bearer capability for everyone the host relays it to. + * The host stores it as the user's own and never parses it. + */ +export interface HostProfileDiscloseRequest { + /** Opaque profile reference, e.g. a Seity contacts reference. */ + reference: string; +} +export declare const HostProfileDiscloseRequest: S.Codec; +/** Contact profile presentation failure. */ +export type HostProfilePresentContactError = +/** This contact has not shared a profile with the user. */ +{ + tag: "NotShared"; + value?: undefined; +} +/** The host holds a reference it cannot parse. */ + | { + tag: "InvalidReference"; + value?: undefined; +} +/** Catch-all. */ + | { + tag: "Unknown"; + value: { + reason: string; + }; +}; +export declare const HostProfilePresentContactError: S.Codec; +/** + * Request to show a chat contact's profile in host-owned UI. + * + * The product names the contact, never a reference: the host looks up the + * reference that contact's host sent, so the product cannot read, keep or + * substitute it. + */ +export interface HostProfilePresentContactRequest { + /** The contact's authenticated root identity, as the chat API names it. */ + peerIdentity: HexString; +} +export declare const HostProfilePresentContactRequest: S.Codec; /** Profile presentation failure. */ export type HostProfilePresentError = /** The reference is malformed or names a format this host cannot open. */ @@ -4499,6 +4629,21 @@ export interface HostProfilePresentRequest { reference: string; } export declare const HostProfilePresentRequest: S.Codec; +/** Profile retraction failure. */ +export type HostProfileRetractError = +/** Another product disclosed the reference the host holds. */ +{ + tag: "NotDiscloser"; + value?: undefined; +} +/** Catch-all. */ + | { + tag: "Unknown"; + value: { + reason: string; + }; +}; +export declare const HostProfileRetractError: S.Codec; /** Request to cancel a previously scheduled notification. */ export interface HostPushNotificationCancelRequest { /** The notification identifier returned by [`HostPushNotificationResponse`]. */ diff --git a/vendor/truapi/dist/generated/types.js b/vendor/truapi/dist/generated/types.js index 979e642bf..3dbf1d51e 100644 --- a/vendor/truapi/dist/generated/types.js +++ b/vendor/truapi/dist/generated/types.js @@ -214,9 +214,18 @@ export const VersionedHostPocketRemoveCardResponse = S.lazy(() => S.indexedTagge export const VersionedHostProductDeviceChatError = S.lazy(() => S.indexedTaggedUnion({ V1: [0, HostProductDeviceChatError] })); export const VersionedHostProductDeviceChatRequest = S.lazy(() => S.indexedTaggedUnion({ V2: [1, HostProductDeviceChatRequest] })); export const VersionedHostProductDeviceChatResponse = S.lazy(() => S.indexedTaggedUnion({ V2: [1, HostProductDeviceChatResponse] })); +export const VersionedHostProfileDiscloseError = S.lazy(() => S.indexedTaggedUnion({ V1: [0, HostProfileDiscloseError] })); +export const VersionedHostProfileDiscloseRequest = S.lazy(() => S.indexedTaggedUnion({ V1: [0, HostProfileDiscloseRequest] })); +export const VersionedHostProfileDiscloseResponse = S.lazy(() => S.indexedTaggedUnion({ V1: [0, S._void] })); +export const VersionedHostProfilePresentContactError = S.lazy(() => S.indexedTaggedUnion({ V1: [0, HostProfilePresentContactError] })); +export const VersionedHostProfilePresentContactRequest = S.lazy(() => S.indexedTaggedUnion({ V1: [0, HostProfilePresentContactRequest] })); +export const VersionedHostProfilePresentContactResponse = S.lazy(() => S.indexedTaggedUnion({ V1: [0, S._void] })); export const VersionedHostProfilePresentError = S.lazy(() => S.indexedTaggedUnion({ V1: [0, HostProfilePresentError] })); export const VersionedHostProfilePresentRequest = S.lazy(() => S.indexedTaggedUnion({ V1: [0, HostProfilePresentRequest] })); export const VersionedHostProfilePresentResponse = S.lazy(() => S.indexedTaggedUnion({ V1: [0, S._void] })); +export const VersionedHostProfileRetractError = S.lazy(() => S.indexedTaggedUnion({ V1: [0, HostProfileRetractError] })); +export const VersionedHostProfileRetractRequest = S.lazy(() => S.indexedTaggedUnion({ V1: [0, S._void] })); +export const VersionedHostProfileRetractResponse = S.lazy(() => S.indexedTaggedUnion({ V1: [0, S._void] })); export const VersionedHostPushNotificationCancelError = S.lazy(() => S.indexedTaggedUnion({ V1: [0, GenericError] })); export const VersionedHostPushNotificationCancelRequest = S.lazy(() => S.indexedTaggedUnion({ V1: [0, HostPushNotificationCancelRequest] })); export const VersionedHostPushNotificationCancelResponse = S.lazy(() => S.indexedTaggedUnion({ V1: [0, S._void] })); @@ -448,8 +457,13 @@ export const HostPaymentTopUpRequest = S.lazy(() => S.Struct({ into: S.Option(Co export const HostPocketListSubscribeItem = S.lazy(() => S.Struct({ cards: S.Vector(PocketCard) })); export const HostPocketRemoveCardError = S.lazy(() => S.TaggedUnion({ Privileged: S._void, Unknown: S.Struct({ reason: S.str }) })); export const HostPocketRemoveCardRequest = S.lazy(() => S.Struct({ cardId: S.str })); +export const HostProfileDiscloseError = S.lazy(() => S.TaggedUnion({ InvalidReference: S._void, Unknown: S.Struct({ reason: S.str }) })); +export const HostProfileDiscloseRequest = S.lazy(() => S.Struct({ reference: S.str })); +export const HostProfilePresentContactError = S.lazy(() => S.TaggedUnion({ NotShared: S._void, InvalidReference: S._void, Unknown: S.Struct({ reason: S.str }) })); +export const HostProfilePresentContactRequest = S.lazy(() => S.Struct({ peerIdentity: S.Hex(32) })); export const HostProfilePresentError = S.lazy(() => S.TaggedUnion({ InvalidReference: S._void, Unknown: S.Struct({ reason: S.str }) })); export const HostProfilePresentRequest = S.lazy(() => S.Struct({ reference: S.str })); +export const HostProfileRetractError = S.lazy(() => S.TaggedUnion({ NotDiscloser: S._void, Unknown: S.Struct({ reason: S.str }) })); export const HostPushNotificationCancelRequest = S.lazy(() => S.Struct({ id: NotificationId })); export const HostPushNotificationError = S.lazy(() => S.TaggedUnion({ ScheduleLimitReached: S._void, Unknown: S.Struct({ reason: S.str }) })); export const HostPushNotificationRequest = S.lazy(() => S.Struct({ text: S.str, deeplink: S.Option(S.str), scheduledAt: S.Option(S.u64) })); diff --git a/vendor/truapi/dist/generated/wire-decode.js b/vendor/truapi/dist/generated/wire-decode.js index 43ee50826..dfc2d001e 100644 --- a/vendor/truapi/dist/generated/wire-decode.js +++ b/vendor/truapi/dist/generated/wire-decode.js @@ -380,4 +380,16 @@ export const WIRE_DECODE_TABLE = { 0: (payload) => T.VersionedHostProfilePresentRequest.dec(payload), 1: (payload) => S.Result(T.VersionedHostProfilePresentResponse, S.CallError(T.VersionedHostProfilePresentError)).dec(payload), }, + [W.PROFILE_DISCLOSE.trait * 256 + W.PROFILE_DISCLOSE.method]: { + 0: (payload) => T.VersionedHostProfileDiscloseRequest.dec(payload), + 1: (payload) => S.Result(T.VersionedHostProfileDiscloseResponse, S.CallError(T.VersionedHostProfileDiscloseError)).dec(payload), + }, + [W.PROFILE_RETRACT.trait * 256 + W.PROFILE_RETRACT.method]: { + 0: (payload) => T.VersionedHostProfileRetractRequest.dec(payload), + 1: (payload) => S.Result(T.VersionedHostProfileRetractResponse, S.CallError(T.VersionedHostProfileRetractError)).dec(payload), + }, + [W.PROFILE_PRESENT_CONTACT.trait * 256 + W.PROFILE_PRESENT_CONTACT.method]: { + 0: (payload) => T.VersionedHostProfilePresentContactRequest.dec(payload), + 1: (payload) => S.Result(T.VersionedHostProfilePresentContactResponse, S.CallError(T.VersionedHostProfilePresentContactError)).dec(payload), + }, }; diff --git a/vendor/truapi/dist/generated/wire-table.d.ts b/vendor/truapi/dist/generated/wire-table.d.ts index 0f5ecad90..5262a9dd0 100644 --- a/vendor/truapi/dist/generated/wire-table.d.ts +++ b/vendor/truapi/dist/generated/wire-table.d.ts @@ -418,3 +418,18 @@ export declare const PROFILE_PRESENT: { readonly method: 0; readonly kind: "request"; }; +export declare const PROFILE_DISCLOSE: { + readonly trait: 20; + readonly method: 1; + readonly kind: "request"; +}; +export declare const PROFILE_RETRACT: { + readonly trait: 20; + readonly method: 2; + readonly kind: "request"; +}; +export declare const PROFILE_PRESENT_CONTACT: { + readonly trait: 20; + readonly method: 3; + readonly kind: "request"; +}; diff --git a/vendor/truapi/dist/generated/wire-table.js b/vendor/truapi/dist/generated/wire-table.js index ee90b599a..5c5d79115 100644 --- a/vendor/truapi/dist/generated/wire-table.js +++ b/vendor/truapi/dist/generated/wire-table.js @@ -429,3 +429,18 @@ export const PROFILE_PRESENT = { method: 0, kind: "request", }; +export const PROFILE_DISCLOSE = { + trait: 20, + method: 1, + kind: "request", +}; +export const PROFILE_RETRACT = { + trait: 20, + method: 2, + kind: "request", +}; +export const PROFILE_PRESENT_CONTACT = { + trait: 20, + method: 3, + kind: "request", +}; diff --git a/vendor/truapi/dist/playground/codegen/services.js b/vendor/truapi/dist/playground/codegen/services.js index 89200ad40..0fe8d977d 100644 --- a/vendor/truapi/dist/playground/codegen/services.js +++ b/vendor/truapi/dist/playground/codegen/services.js @@ -685,6 +685,34 @@ export const services = [ exampleSource: 'const result = await truapi.profile.present({\n reference: "bafkreigh2akiscaildc6ybwhxslp6rx2u4m2vpbhgvzhpsfkyzxiezxcnq#" + "00".repeat(44),\n});\nconsole.log("profile presentation:", result);', requestType: "host-profile-present-request", }, + { + name: "disclose", + type: "unary", + signature: "disclose(request: HostProfileDiscloseRequest): Promise>>", + docUrl: "api/profile/trait.Profile.html#method.disclose", + description: "Give the user's chat contacts this reference to their profile.\n\nThe host stores it as the user's own and relays it to each contact,\nreplacing whatever it sent before; the product never learns who they\nare. App executions only. A reference this core cannot screen is\n`InvalidReference`.", + requestDescription: "HostProfileDiscloseRequest", + exampleSource: 'const result = await truapi.profile.disclose({\n reference: "seity-contacts:v1:" + "00".repeat(64),\n});\nconsole.log("profile disclosed:", result);', + requestType: "host-profile-disclose-request", + }, + { + name: "retract", + type: "unary", + signature: "retract(): Promise>>", + docUrl: "api/profile/trait.Profile.html#method.retract", + description: "Withdraw the reference this product disclosed. Contacts are told to\ndrop what they hold. A product that did not disclose it is refused.", + exampleSource: 'const result = await truapi.profile.retract();\nconsole.log("profile retracted:", result);', + }, + { + name: "present_contact", + type: "unary", + signature: "presentContact(request: HostProfilePresentContactRequest): Promise>>", + docUrl: "api/profile/trait.Profile.html#method.present_contact", + description: "Show a chat contact's profile in host-owned UI.\n\nThe product names the contact; the host looks up the reference that\ncontact shared and presents it as `present` would. The reference never\nreaches the product. A contact who shared nothing is `NotShared`.", + requestDescription: "HostProfilePresentContactRequest", + exampleSource: 'const result = await truapi.profile.presentContact({\n peerIdentity: new Uint8Array(32),\n});\nconsole.log("contact profile presentation:", result);', + requestType: "host-profile-present-contact-request", + }, ], }, { diff --git a/vendor/truapi/dist/playground/codegen/truapi-dts.d.ts b/vendor/truapi/dist/playground/codegen/truapi-dts.d.ts index 4836e6add..f7d6a1f3f 100644 --- a/vendor/truapi/dist/playground/codegen/truapi-dts.d.ts +++ b/vendor/truapi/dist/playground/codegen/truapi-dts.d.ts @@ -1 +1 @@ -export declare const truapiDts = "// neverthrow (inlined)\n\ninterface ErrorConfig {\n withStackTrace: boolean;\n}\n\ndeclare class ResultAsync implements PromiseLike> {\n private _promise;\n constructor(res: Promise>);\n static fromSafePromise(promise: PromiseLike): ResultAsync;\n static fromPromise(promise: PromiseLike, errorFn: (e: unknown) => E): ResultAsync;\n static fromThrowable(fn: (...args: A) => Promise, errorFn?: (err: unknown) => E): (...args: A) => ResultAsync;\n static combine, ...ResultAsync[]]>(asyncResultList: T): CombineResultAsyncs;\n static combine[]>(asyncResultList: T): CombineResultAsyncs;\n static combineWithAllErrors, ...ResultAsync[]]>(asyncResultList: T): CombineResultsWithAllErrorsArrayAsync;\n static combineWithAllErrors[]>(asyncResultList: T): CombineResultsWithAllErrorsArrayAsync;\n map(f: (t: T) => A | Promise): ResultAsync;\n andThrough(f: (t: T) => Result | ResultAsync): ResultAsync;\n andTee(f: (t: T) => unknown): ResultAsync;\n orTee(f: (t: E) => unknown): ResultAsync;\n mapErr(f: (e: E) => U | Promise): ResultAsync;\n andThen>(f: (t: T) => R): ResultAsync, InferErrTypes | E>;\n andThen>(f: (t: T) => R): ResultAsync, InferAsyncErrTypes | E>;\n andThen(f: (t: T) => Result | ResultAsync): ResultAsync;\n orElse>(f: (e: E) => R): ResultAsync | T, InferErrTypes>;\n orElse>(f: (e: E) => R): ResultAsync | T, InferAsyncErrTypes>;\n orElse(f: (e: E) => Result | ResultAsync): ResultAsync;\n match(ok: (t: T) => A, _err: (e: E) => B): Promise;\n unwrapOr(t: A): Promise;\n /**\n * @deprecated will be removed in 9.0.0.\n *\n * You can use `safeTry` without this method.\n * @example\n * ```typescript\n * safeTry(async function* () {\n * const okValue = yield* yourResult\n * })\n * ```\n * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.\n */\n safeUnwrap(): AsyncGenerator, T>;\n then(successCallback?: (res: Result) => A | PromiseLike, failureCallback?: (reason: unknown) => B | PromiseLike): PromiseLike;\n [Symbol.asyncIterator](): AsyncGenerator, T>;\n}\ndeclare function okAsync(value: T): ResultAsync;\ndeclare function okAsync(value: void): ResultAsync;\ndeclare function errAsync(err: E): ResultAsync;\ndeclare function errAsync(err: void): ResultAsync;\ndeclare const fromPromise: typeof ResultAsync.fromPromise;\ndeclare const fromSafePromise: typeof ResultAsync.fromSafePromise;\ndeclare const fromAsyncThrowable: typeof ResultAsync.fromThrowable;\ndeclare type CombineResultAsyncs[]> = IsLiteralArray extends 1 ? TraverseAsync> : ResultAsync, ExtractErrAsyncTypes[number]>;\ndeclare type CombineResultsWithAllErrorsArrayAsync[]> = IsLiteralArray extends 1 ? TraverseWithAllErrorsAsync> : ResultAsync, ExtractErrAsyncTypes[number][]>;\ndeclare type UnwrapAsync = IsLiteralArray extends 1 ? Writable extends [infer H, ...infer Rest] ? H extends PromiseLike ? HI extends Result ? [Dedup, ...UnwrapAsync] : never : never : [] : T extends Array ? A extends PromiseLike ? HI extends Result ? Ok[] : never : never : never;\ndeclare type TraverseAsync = IsLiteralArray extends 1 ? Combine extends [infer Oks, infer Errs] ? ResultAsync, MembersToUnion> : never : T extends Array ? Combine, Depth> extends [infer Oks, infer Errs] ? Oks extends unknown[] ? Errs extends unknown[] ? ResultAsync, MembersToUnion> : ResultAsync, Errs> : Errs extends unknown[] ? ResultAsync> : ResultAsync : never : never;\ndeclare type TraverseWithAllErrorsAsync = TraverseAsync extends ResultAsync ? ResultAsync : never;\ndeclare type Writable = T extends ReadonlyArray ? [...T] : T;\n\ndeclare type ExtractOkTypes[]> = {\n [idx in keyof T]: T[idx] extends Result ? U : never;\n};\ndeclare type ExtractOkAsyncTypes[]> = {\n [idx in keyof T]: T[idx] extends ResultAsync ? U : never;\n};\ndeclare type ExtractErrTypes[]> = {\n [idx in keyof T]: T[idx] extends Result ? E : never;\n};\ndeclare type ExtractErrAsyncTypes[]> = {\n [idx in keyof T]: T[idx] extends ResultAsync ? E : never;\n};\ndeclare type InferOkTypes = R extends Result ? T : never;\ndeclare type InferErrTypes = R extends Result ? E : never;\ndeclare type InferAsyncOkTypes = R extends ResultAsync ? T : never;\ndeclare type InferAsyncErrTypes = R extends ResultAsync ? E : never;\n\ndeclare namespace Result {\n /**\n * Wraps a function with a try catch, creating a new function with the same\n * arguments but returning `Ok` if successful, `Err` if the function throws\n *\n * @param fn function to wrap with ok on success or err on failure\n * @param errorFn when an error is thrown, this will wrap the error result if provided\n */\n function fromThrowable any, E>(fn: Fn, errorFn?: (e: unknown) => E): (...args: Parameters) => Result, E>;\n function combine, ...Result[]]>(resultList: T): CombineResults;\n function combine[]>(resultList: T): CombineResults;\n function combineWithAllErrors, ...Result[]]>(resultList: T): CombineResultsWithAllErrorsArray;\n function combineWithAllErrors[]>(resultList: T): CombineResultsWithAllErrorsArray;\n}\ndeclare type Result = Ok | Err;\ndeclare function ok(value: T): Ok;\ndeclare function ok(value: void): Ok;\ndeclare function err(err: E): Err;\ndeclare function err(err: E): Err;\ndeclare function err(err: void): Err;\n/**\n * Evaluates the given generator to a Result returned or an Err yielded from it,\n * whichever comes first.\n *\n * This function is intended to emulate Rust's ? operator.\n * See `/tests/safeTry.test.ts` for examples.\n *\n * @param body - What is evaluated. In body, `yield* result` works as\n * Rust's `result?` expression.\n * @returns The first occurrence of either an yielded Err or a returned Result.\n */\ndeclare function safeTry(body: () => Generator, Result>): Result;\ndeclare function safeTry, GeneratorReturnResult extends Result>(body: () => Generator): Result, InferErrTypes | InferErrTypes>;\n/**\n * Evaluates the given generator to a Result returned or an Err yielded from it,\n * whichever comes first.\n *\n * This function is intended to emulate Rust's ? operator.\n * See `/tests/safeTry.test.ts` for examples.\n *\n * @param body - What is evaluated. In body, `yield* result` and\n * `yield* resultAsync` work as Rust's `result?` expression.\n * @returns The first occurrence of either an yielded Err or a returned Result.\n */\ndeclare function safeTry(body: () => AsyncGenerator, Result>): ResultAsync;\ndeclare function safeTry, GeneratorReturnResult extends Result>(body: () => AsyncGenerator): ResultAsync, InferErrTypes | InferErrTypes>;\ninterface IResult {\n /**\n * Used to check if a `Result` is an `OK`\n *\n * @returns `true` if the result is an `OK` variant of Result\n */\n isOk(): this is Ok;\n /**\n * Used to check if a `Result` is an `Err`\n *\n * @returns `true` if the result is an `Err` variant of Result\n */\n isErr(): this is Err;\n /**\n * Maps a `Result` to `Result`\n * by applying a function to a contained `Ok` value, leaving an `Err` value\n * untouched.\n *\n * @param f The function to apply an `OK` value\n * @returns the result of applying `f` or an `Err` untouched\n */\n map(f: (t: T) => A): Result;\n /**\n * Maps a `Result` to `Result` by applying a function to a\n * contained `Err` value, leaving an `Ok` value untouched.\n *\n * This function can be used to pass through a successful result while\n * handling an error.\n *\n * @param f a function to apply to the error `Err` value\n */\n mapErr(f: (e: E) => U): Result;\n /**\n * Similar to `map` Except you must return a new `Result`.\n *\n * This is useful for when you need to do a subsequent computation using the\n * inner `T` value, but that computation might fail.\n * Additionally, `andThen` is really useful as a tool to flatten a\n * `Result, E1>` into a `Result` (see example below).\n *\n * @param f The function to apply to the current value\n */\n andThen>(f: (t: T) => R): Result, InferErrTypes | E>;\n andThen(f: (t: T) => Result): Result;\n /**\n * This \"tee\"s the current value to an passed-in computation such as side\n * effect functions but still returns the same current value as the result.\n *\n * This is useful when you want to pass the current result to your side-track\n * work such as logging but want to continue main-track work after that.\n * This method does not care about the result of the passed in computation.\n *\n * @param f The function to apply to the current value\n */\n andTee(f: (t: T) => unknown): Result;\n /**\n * This \"tee\"s the current `Err` value to an passed-in computation such as side\n * effect functions but still returns the same `Err` value as the result.\n *\n * This is useful when you want to pass the current `Err` value to your side-track\n * work such as logging but want to continue error-track work after that.\n * This method does not care about the result of the passed in computation.\n *\n * @param f The function to apply to the current `Err` value\n */\n orTee(f: (t: E) => unknown): Result;\n /**\n * Similar to `andTee` except error result of the computation will be passed\n * to the downstream in case of an error.\n *\n * This version is useful when you want to make side-effects but in case of an\n * error, you want to pass the error to the downstream.\n *\n * @param f The function to apply to the current value\n */\n andThrough>(f: (t: T) => R): Result | E>;\n andThrough(f: (t: T) => Result): Result;\n /**\n * Takes an `Err` value and maps it to a `Result`.\n *\n * This is useful for error recovery.\n *\n *\n * @param f A function to apply to an `Err` value, leaving `Ok` values\n * untouched.\n */\n orElse>(f: (e: E) => R): Result | T, InferErrTypes>;\n orElse(f: (e: E) => Result): Result;\n /**\n * Similar to `map` Except you must return a new `Result`.\n *\n * This is useful for when you need to do a subsequent async computation using\n * the inner `T` value, but that computation might fail. Must return a ResultAsync\n *\n * @param f The function that returns a `ResultAsync` to apply to the current\n * value\n */\n asyncAndThen(f: (t: T) => ResultAsync): ResultAsync;\n /**\n * Maps a `Result` to `ResultAsync`\n * by applying an async function to a contained `Ok` value, leaving an `Err`\n * value untouched.\n *\n * @param f An async function to apply an `OK` value\n */\n asyncMap(f: (t: T) => Promise): ResultAsync;\n /**\n * Unwrap the `Ok` value, or return the default if there is an `Err`\n *\n * @param v the default value to return if there is an `Err`\n */\n unwrapOr(v: A): T | A;\n /**\n *\n * Given 2 functions (one for the `Ok` variant and one for the `Err` variant)\n * execute the function that matches the `Result` variant.\n *\n * Match callbacks do not necessitate to return a `Result`, however you can\n * return a `Result` if you want to.\n *\n * `match` is like chaining `map` and `mapErr`, with the distinction that\n * with `match` both functions must have the same return type.\n *\n * @param ok\n * @param err\n */\n match(ok: (t: T) => A, err: (e: E) => B): A | B;\n /**\n * @deprecated will be removed in 9.0.0.\n *\n * You can use `safeTry` without this method.\n * @example\n * ```typescript\n * safeTry(function* () {\n * const okValue = yield* yourResult\n * })\n * ```\n * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.\n */\n safeUnwrap(): Generator, T>;\n /**\n * **This method is unsafe, and should only be used in a test environments**\n *\n * Takes a `Result` and returns a `T` when the result is an `Ok`, otherwise it throws a custom object.\n *\n * @param config\n */\n _unsafeUnwrap(config?: ErrorConfig): T;\n /**\n * **This method is unsafe, and should only be used in a test environments**\n *\n * takes a `Result` and returns a `E` when the result is an `Err`,\n * otherwise it throws a custom object.\n *\n * @param config\n */\n _unsafeUnwrapErr(config?: ErrorConfig): E;\n}\ndeclare class Ok implements IResult {\n readonly value: T;\n constructor(value: T);\n isOk(): this is Ok;\n isErr(): this is Err;\n map(f: (t: T) => A): Result;\n mapErr(_f: (e: E) => U): Result;\n andThen>(f: (t: T) => R): Result, InferErrTypes | E>;\n andThen(f: (t: T) => Result): Result;\n andThrough>(f: (t: T) => R): Result | E>;\n andThrough(f: (t: T) => Result): Result;\n andTee(f: (t: T) => unknown): Result;\n orTee(_f: (t: E) => unknown): Result;\n orElse>(_f: (e: E) => R): Result | T, InferErrTypes>;\n orElse(_f: (e: E) => Result): Result;\n asyncAndThen(f: (t: T) => ResultAsync): ResultAsync;\n asyncAndThrough>(f: (t: T) => R): ResultAsync | E>;\n asyncAndThrough(f: (t: T) => ResultAsync): ResultAsync;\n asyncMap(f: (t: T) => Promise): ResultAsync;\n unwrapOr(_v: A): T | A;\n match(ok: (t: T) => A, _err: (e: E) => B): A | B;\n safeUnwrap(): Generator, T>;\n _unsafeUnwrap(_?: ErrorConfig): T;\n _unsafeUnwrapErr(config?: ErrorConfig): E;\n [Symbol.iterator](): Generator, T>;\n}\ndeclare class Err implements IResult {\n readonly error: E;\n constructor(error: E);\n isOk(): this is Ok;\n isErr(): this is Err;\n map(_f: (t: T) => A): Result;\n mapErr(f: (e: E) => U): Result;\n andThrough(_f: (t: T) => Result): Result;\n andTee(_f: (t: T) => unknown): Result;\n orTee(f: (t: E) => unknown): Result;\n andThen>(_f: (t: T) => R): Result, InferErrTypes | E>;\n andThen(_f: (t: T) => Result): Result;\n orElse>(f: (e: E) => R): Result | T, InferErrTypes>;\n orElse(f: (e: E) => Result): Result;\n asyncAndThen(_f: (t: T) => ResultAsync): ResultAsync;\n asyncAndThrough(_f: (t: T) => ResultAsync): ResultAsync;\n asyncMap(_f: (t: T) => Promise): ResultAsync;\n unwrapOr(v: A): T | A;\n match(_ok: (t: T) => A, err: (e: E) => B): A | B;\n safeUnwrap(): Generator, T>;\n _unsafeUnwrap(config?: ErrorConfig): T;\n _unsafeUnwrapErr(_?: ErrorConfig): E;\n [Symbol.iterator](): Generator, T>;\n}\ndeclare const fromThrowable: typeof Result.fromThrowable;\ndeclare type Prev = [\n never,\n 0,\n 1,\n 2,\n 3,\n 4,\n 5,\n 6,\n 7,\n 8,\n 9,\n 10,\n 11,\n 12,\n 13,\n 14,\n 15,\n 16,\n 17,\n 18,\n 19,\n 20,\n 21,\n 22,\n 23,\n 24,\n 25,\n 26,\n 27,\n 28,\n 29,\n 30,\n 31,\n 32,\n 33,\n 34,\n 35,\n 36,\n 37,\n 38,\n 39,\n 40,\n 41,\n 42,\n 43,\n 44,\n 45,\n 46,\n 47,\n 48,\n 49,\n ...0[]\n];\ndeclare type CollectResults = [\n Depth\n] extends [never] ? [] : T extends [infer H, ...infer Rest] ? H extends Result ? CollectResults : never : Collected;\ndeclare type Transpose = A extends [infer T, ...infer Rest] ? T extends [infer L, infer R] ? Transposed extends [infer PL, infer PR] ? PL extends unknown[] ? PR extends unknown[] ? Transpose : never : never : Transpose : Transposed : Transposed;\ndeclare type Combine = Transpose, [], Depth> extends [\n infer L,\n infer R\n] ? [UnknownMembersToNever, UnknownMembersToNever] : Transpose, [], Depth> extends [] ? [[], []] : never;\ndeclare type Dedup = T extends Result ? [unknown] extends [RL] ? Err : Ok : T;\ndeclare type MemberListOf = ((T extends unknown ? (t: T) => T : never) extends infer U ? (U extends unknown ? (u: U) => unknown : never) extends (v: infer V) => unknown ? V : never : never) extends (_: unknown) => infer W ? [...MemberListOf>, W] : [];\ndeclare type EmptyArrayToNever = T extends [] ? never : NeverArrayToNever extends 1 ? T extends [never, ...infer Rest] ? [EmptyArrayToNever] extends [never] ? never : T : T : T;\ndeclare type UnknownMembersToNever = T extends [infer H, ...infer R] ? [[unknown] extends [H] ? never : H, ...UnknownMembersToNever] : T;\ndeclare type MembersToUnion = T extends unknown[] ? T[number] : never;\ndeclare type IsLiteralArray = T extends {\n length: infer L;\n} ? L extends number ? number extends L ? 0 : 1 : 0 : 0;\ndeclare type Traverse = Combine extends [infer Oks, infer Errs] ? Result, MembersToUnion> : never;\ndeclare type TraverseWithAllErrors = Traverse extends Result ? Result : never;\ndeclare type CombineResults[]> = IsLiteralArray extends 1 ? Traverse : Result, ExtractErrTypes[number]>;\ndeclare type CombineResultsWithAllErrorsArray[]> = IsLiteralArray extends 1 ? TraverseWithAllErrors : Result, ExtractErrTypes[number][]>;\n\n\n\n// scale.d.ts (module-scope)\n\n/** SCALE codec primitives used by the generated client.\n *\n * Thin wrapper over `scale-ts`: re-exports its primitives and combinators,\n * plus the Polkadot-flavour helpers it does not ship (hex-encoded bytes,\n * lazy recursive codecs, and `V`-indexed tagged unions).\n */\nimport { type Codec, type ResultPayload } from \"scale-ts\";\nexport type { Codec };\nexport type { ResultPayload } from \"scale-ts\";\n/**\n * Bare-named type alias matching generated codegen's naming convention for\n * generic wire types: `Result` is used as both a value (the codec\n * builder re-exported below) and a type (this alias for scale-ts's own\n * `ResultPayload`) in generated `types.ts`.\n */\nexport type Result = ResultPayload;\nexport { Bytes, Enum, Option, Result, Struct, Tuple, Vector, _void, compact, i8, i16, i32, i64, i128, str, u8, u16, u32, u64, u128, } from \"scale-ts\";\n/** SCALE boolean, rejecting byte values Rust cannot decode. */\nexport declare const bool: Codec;\n/**\n * Substrate `OptionBool`: a one-byte `Option`.\n *\n * Canonical SCALE encoding (matches `parity_scale_codec::OptionBool`):\n * `undefined` \u2192 `0`, `true` \u2192 `1`, `false` \u2192 `2`.\n */\nexport declare const OptionBool: Codec;\n/** Hex-encoded byte string, e.g. `\"0xdeadbeef\"`. */\nexport type HexString = `0x${string}`;\n/** Assert that a string is a valid hex string (`0x...`). */\nexport declare function toHexString(value: string): HexString;\n/** Encode a byte array as a lower-case hex string with a `0x` prefix. */\nexport declare function bytesToHex(bytes: Uint8Array): HexString;\n/** Decode a hex string into a byte array. Tolerates a missing `0x` prefix. */\nexport declare function hexToBytes(hex: string): Uint8Array;\n/**\n * SCALE codec for hex-encoded byte strings.\n *\n * Encode accepts a `0x`-prefixed hex string and emits SCALE bytes; decode\n * returns the bytes as a hex string. Pass `length` for fixed-size byte arrays\n * (`[u8; N]`); omit it for variable-length byte vectors (`Vec`).\n */\nexport declare function Hex(length?: number): Codec;\n/**\n * Same wire format as `scale-ts`'s `Enum`, but exposes `value` as optional in\n * the public TS type when the variant codec is `Codec`. Lets unit\n * variants of mixed enums round-trip as `{ tag: \"X\" }` (no `value` key).\n */\nexport declare function TaggedUnion(inner: O): Codec>;\n/** Public TS value for Rust's derived `CallError` enum. */\nexport type CallErrorValue = {\n tag: \"Domain\";\n value: D;\n} | {\n tag: \"Denied\";\n value?: undefined;\n} | {\n tag: \"Unsupported\";\n value?: undefined;\n} | {\n tag: \"MalformedFrame\";\n value: {\n reason: string;\n };\n} | {\n tag: \"HostFailure\";\n value: {\n reason: string;\n };\n} | {\n tag: \"Cancelled\";\n value?: undefined;\n};\n/** SCALE codec for Rust's derived `CallError` enum. */\nexport declare function CallError(domain: Codec): Codec>;\ntype TaggedUnionCodecs = {\n [Sym: symbol]: never;\n [Num: number]: never;\n [Str: string]: Codec;\n};\ntype TaggedUnionValue = {\n [K in keyof O & string]: O[K] extends Codec ? [T] extends [undefined] ? {\n tag: K;\n value?: undefined;\n } : {\n tag: K;\n value: T;\n } : never;\n}[keyof O & string];\n/**\n * Enum without payloads \u2014 maps string labels to SCALE discriminant bytes.\n *\n * `scale-ts` models `Enum({ Foo: _void, Bar: _void })` as tagged objects. For\n * user-facing TrUAPI enums with only unit variants, we keep the public TS shape\n * as a plain string union instead.\n */\nexport declare function Status(...variants: readonly T[]): Codec;\n/**\n * Defers codec construction until first use so recursive generated codecs can\n * reference each other safely.\n */\nexport declare function lazy(factory: () => Codec): Codec;\ntype IndexedVariantCodec = readonly [index: number, codec: Codec];\ntype IndexedVariantValue>, K extends keyof Variants & string> = Variants[K] extends IndexedVariantCodec ? [T] extends [undefined] ? {\n tag: K;\n value?: undefined;\n} : {\n tag: K;\n value: T;\n} : never;\n/**\n * Builds a tagged union codec with explicit SCALE discriminants.\n *\n * `scale-ts` assigns enum indexes by object key order. TrUAPI versioned enums pin\n * `V` to index `N - 1`, including V2-only enums, so generated codecs use this\n * helper for versioned wire wrappers.\n */\nexport declare function indexedTaggedUnion>>(variants: Variants): Codec<{\n [K in keyof Variants & string]: IndexedVariantValue;\n}[keyof Variants & string]>;\n\n\n// generated/types.d.ts (namespace T)\n\ndeclare namespace T {\n/** A 32-byte raw account identifier used for legacy (non-product) accounts. */\nexport type AccountId = HexString;\nexport const AccountId: Codec;\n/**\n * A press on a button the host draws for a `ChatMessageContent::Actions`\n * message.\n */\nexport interface ActionTrigger {\n /**\n * Message containing the action, as returned by `Chat::post_message` in\n * [`HostChatPostMessageResponse::message_id`].\n */\n messageId: string;\n /** Which action was triggered. */\n actionId: string;\n /** Optional additional data. */\n payload?: HexString;\n}\nexport const ActionTrigger: Codec;\n/**\n * A resource the host can pre-allocate on behalf of the product (RFC 0010).\n *\n * For the slot-table allowances (`StatementStoreAllowance`,\n * `BulletinAllowance`, `SmartContractAllowance`), pre-allocation is\n * opportunistic and the host may also fulfil the allowance implicitly on the\n * first submission. `AutoSigning` must be requested explicitly through this\n * call.\n */\nexport type AllocatableResource = \n/** Statement Store slot allowance for the product's own allowance account. */\n{\n tag: \"StatementStoreAllowance\";\n value?: undefined;\n}\n/** Bulletin chain slot allowance for the product's own allowance account. */\n | {\n tag: \"BulletinAllowance\";\n value?: undefined;\n}\n/**\n * Pre-warmed PGAS balance for the product account selected by this\n * derivation index.\n */\n | {\n tag: \"SmartContractAllowance\";\n value: DerivationIndex;\n}\n/** Permission to sign on the product's behalf without per-call user prompts. */\n | {\n tag: \"AutoSigning\";\n value?: undefined;\n}\n/**\n * Current UTC-day Statement Store allowance whose target is the product\n * account selected by this derivation index.\n */\n | {\n tag: \"ProductStatementStoreAllowance\";\n value: DerivationIndex;\n};\nexport const AllocatableResource: Codec;\n/** Outcome of allocating a single resource (RFC 0010). */\nexport type AllocationOutcome = \"Allocated\" | \"Rejected\" | \"NotAvailable\";\nexport const AllocationOutcome: Codec;\n/** Main-axis distribution of children. */\nexport type Arrangement = \"Start\" | \"End\" | \"Center\" | \"SpaceBetween\" | \"SpaceAround\" | \"SpaceEvenly\";\nexport const Arrangement: Codec;\n/** Background styling. */\nexport interface Background {\n /** Background color. */\n color: ColorToken;\n /** Background shape. */\n shape?: Shape;\n}\nexport const Background: Codec;\n/**\n * Balance amount for payment operations. Interpreted according to the host's\n * single fixed payment asset (e.g. pUSD).\n */\nexport type Balance = bigint;\nexport const Balance: Codec;\n/**\n * How a node composites with what is behind it. The values are those common\n * to CSS `mix-blend-mode`, SwiftUI `BlendMode` and Compose `BlendMode`.\n */\nexport type BlendingMode = \"Normal\" | \"Multiply\" | \"Screen\" | \"Overlay\" | \"Darken\" | \"Lighten\" | \"ColorDodge\" | \"ColorBurn\" | \"HardLight\" | \"SoftLight\" | \"Difference\" | \"Exclusion\" | \"Hue\" | \"Saturation\" | \"Color\" | \"Luminosity\";\nexport const BlendingMode: Codec;\n/** Border styling. */\nexport interface BorderStyle {\n /** Border width. */\n width: Size;\n /** Border color. */\n color: ColorToken;\n /** Border shape. */\n shape?: Shape;\n}\nexport const BorderStyle: Codec;\n/** Properties of a `Box`. */\nexport interface BoxProps {\n /** Placement of content within the box. */\n contentAlignment?: ContentAlignment;\n}\nexport const BoxProps: Codec;\n/** Properties of a `Button`. */\nexport interface ButtonProps {\n /** Button label. */\n text: string;\n /** Button emphasis. */\n variant?: ButtonVariant;\n /** Whether the button accepts presses. Absent leaves the default to the host. */\n enabled?: boolean;\n /**\n * Whether the button shows a loading state. A loading button accepts no\n * presses. Absent leaves the default to the host.\n */\n loading?: boolean;\n /** Action triggered on press. A button without one is inert. */\n clickAction?: string;\n}\nexport const ButtonProps: Codec;\n/** Button emphasis. */\nexport type ButtonVariant = \"Primary\" | \"Secondary\" | \"Text\";\nexport const ButtonVariant: Codec;\n/**\n * A 32-byte value, passed as plain bytes on FFI surfaces. Version-neutral:\n * the FFI conversion below applies to `[u8; 32]` fields in every protocol\n * version.\n */\nexport type Bytes32 = HexString;\nexport const Bytes32: Codec;\n/** Role of a chain within the host's configured environment. */\nexport type ChainIdentifier = \"Relay\" | \"AssetHub\" | \"People\" | \"Bulletin\";\nexport const ChainIdentifier: Codec;\n/** A clickable action button in a chat message. */\nexport interface ChatAction {\n /** Action identifier. */\n actionId: string;\n /** Button label. */\n title: string;\n}\nexport const ChatAction: Codec;\n/** Layout for action buttons. */\nexport type ChatActionLayout = \"Column\" | \"Grid\";\nexport const ChatActionLayout: Codec;\n/** Payload of a received chat action. */\nexport type ChatActionPayload = \n/** A peer posted a message. */\n{\n tag: \"MessagePosted\";\n value: ChatMessageContent;\n}\n/** A user pressed a host-drawn `Actions` button. */\n | {\n tag: \"ActionTriggered\";\n value: ActionTrigger;\n}\n/** A user issued a command. */\n | {\n tag: \"Command\";\n value: ChatCommand;\n};\nexport const ChatActionPayload: Codec;\n/** A set of action buttons with optional text. */\nexport interface ChatActions {\n /** Optional message text. */\n text?: string;\n /** List of action buttons. */\n actions: Array;\n /** `Column` or `Grid` layout. */\n layout: ChatActionLayout;\n}\nexport const ChatActions: Codec;\n/** Whether the bot was newly registered or already existed. */\nexport type ChatBotRegistrationStatus = \"New\" | \"Exists\";\nexport const ChatBotRegistrationStatus: Codec;\n/** A slash command from a chat user. */\nexport interface ChatCommand {\n /** Command name. */\n command: string;\n /** Command arguments. */\n payload: string;\n}\nexport const ChatCommand: Codec;\n/**\n * A custom message with application-defined type and binary payload. The\n * host draws it through `Renderer::render`, with a `ChatMessage` context\n * carrying `message_type` and `payload` as the render payload.\n */\nexport interface ChatCustomMessage {\n /** Application-defined type key. */\n messageType: string;\n /** Binary payload. */\n payload: HexString;\n}\nexport const ChatCustomMessage: Codec;\n/** A file attachment in a chat message. */\nexport interface ChatFile {\n /** File download URL. */\n url: string;\n /** File name. */\n fileName: string;\n /** MIME type. */\n mimeType: string;\n /** File size in bytes. */\n sizeBytes: bigint;\n /** Optional caption text. */\n text?: string;\n}\nexport const ChatFile: Codec;\n/** A media attachment. */\nexport interface ChatMedia {\n /** Media URL. */\n url: string;\n}\nexport const ChatMedia: Codec;\n/** Content of a chat message -- one of several types. */\nexport type ChatMessageContent = \n/** Plain text message. */\n{\n tag: \"Text\";\n value: {\n text: string;\n };\n}\n/** Rich text with media. */\n | {\n tag: \"RichText\";\n value: ChatRichText;\n}\n/** Action button set. */\n | {\n tag: \"Actions\";\n value: ChatActions;\n}\n/** File attachment. */\n | {\n tag: \"File\";\n value: ChatFile;\n}\n/** Emoji reaction. */\n | {\n tag: \"Reaction\";\n value: ChatReaction;\n}\n/** Reaction removal. */\n | {\n tag: \"ReactionRemoved\";\n value: ChatReaction;\n}\n/** Custom message. */\n | {\n tag: \"Custom\";\n value: ChatCustomMessage;\n};\nexport const ChatMessageContent: Codec;\n/** A reaction to a chat message. */\nexport interface ChatReaction {\n /** Message being reacted to. */\n messageId: string;\n /** Emoji reaction. */\n emoji: string;\n}\nexport const ChatReaction: Codec;\n/** Rich text message with optional media. */\nexport interface ChatRichText {\n /** Optional text content. */\n text?: string;\n /** Attached media items. */\n media: Array;\n}\nexport const ChatRichText: Codec;\n/** A chat room the product participates in. */\nexport interface ChatRoom {\n /** Room identifier. */\n roomId: string;\n /** `RoomHost` or `Bot`. */\n participatingAs: ChatRoomParticipation;\n}\nexport const ChatRoom: Codec;\n/** How the product participates in a chat room. */\nexport type ChatRoomParticipation = \"RoomHost\" | \"Bot\";\nexport const ChatRoomParticipation: Codec;\n/** Whether the room was newly created or already existed. */\nexport type ChatRoomRegistrationStatus = \"New\" | \"Exists\";\nexport const ChatRoomRegistrationStatus: Codec;\n/** Balance amount for CoinPayment operations. */\nexport type CoinPaymentBalance = number;\nexport const CoinPaymentBalance: Codec;\n/** Standardized encrypted Coinage secret transmission payload. */\nexport interface CoinPaymentCheque {\n /** Receivable public key protecting the cheque contents. */\n id: CoinPaymentReceivable;\n /** Claimed payment amount. */\n amount: CoinPaymentBalance;\n /** Concatenated coin secrets encrypted to the receivable. */\n encryptedSecrets: HexString;\n}\nexport const CoinPaymentCheque: Codec;\n/** Product-visible clearing reference for reconciliation and receipts. */\nexport interface CoinPaymentClearingReference {\n /** Clearing Merkle root. */\n root: CoinPaymentMerkleRoot;\n /** Product-visible coin key and transaction hash leaves. */\n leaves: Array<[CoinPaymentCoinagePubKey, CoinPaymentTransactionHash]>;\n}\nexport const CoinPaymentClearingReference: Codec;\n/** Public Coinage key referenced by clearing evidence. */\nexport type CoinPaymentCoinagePubKey = HexString;\nexport const CoinPaymentCoinagePubKey: Codec;\n/** Errors returned by CoinPayment host operations. */\nexport type CoinPaymentError = \"BalanceLow\" | \"Denied\" | \"BadCoins\" | \"SnipedCoins\" | \"PurseNotFound\" | \"ReceivableNotFound\" | \"UnsupportedChannel\" | \"UserAgentCapabilityUnavailable\" | \"Internal\";\nexport const CoinPaymentError: Codec;\n/** Merkle root for a product-visible clearing reference. */\nexport type CoinPaymentMerkleRoot = HexString;\nexport const CoinPaymentMerkleRoot: Codec;\n/** Authenticated product identifier recorded for a product-created purse. */\nexport type CoinPaymentProductId = string;\nexport const CoinPaymentProductId: Codec;\n/** RFC 0017 CoinPayment purse identifier. */\nexport type CoinPaymentPurseId = number;\nexport const CoinPaymentPurseId: Codec;\n/** Product-visible metadata and balance state for a CoinPayment purse. */\nexport interface CoinPaymentPurseInfo {\n /** Human-readable purse name supplied by the creating product. */\n name: string;\n /** Creation timestamp. */\n created: CoinPaymentTimestamp;\n /** Product that created the purse. */\n creator: CoinPaymentProductId;\n /** Current product-visible balance. */\n balance: CoinPaymentBalance;\n}\nexport const CoinPaymentPurseInfo: Codec;\n/** Public key identifying a CoinPayment receivable. */\nexport type CoinPaymentReceivable = HexString;\nexport const CoinPaymentReceivable: Codec;\n/** Clearing status stream item. */\nexport type CoinPaymentStatus = \n/** More coins have cleared. */\n{\n tag: \"Clearing\";\n value: {\n clearing: CoinPaymentBalance;\n cleared: CoinPaymentBalance;\n };\n}\n/** Some or all coins failed to transfer. */\n | {\n tag: \"Failed\";\n value: {\n error: CoinPaymentError;\n cleared: CoinPaymentBalance;\n reference: CoinPaymentClearingReference;\n };\n}\n/** All coins cleared. */\n | {\n tag: \"Done\";\n value: {\n cleared: CoinPaymentBalance;\n reference: CoinPaymentClearingReference;\n };\n};\nexport const CoinPaymentStatus: Codec;\n/** Milliseconds since Unix epoch. */\nexport type CoinPaymentTimestamp = bigint;\nexport const CoinPaymentTimestamp: Codec;\n/** Transaction hash for a product-visible clearing reference. */\nexport type CoinPaymentTransactionHash = HexString;\nexport const CoinPaymentTransactionHash: Codec;\n/** Standardized cheque transmission channel. */\nexport type CoinPaymentTransmissionChannel = \n/** Statement-store/HOP handoff identified by an SSS topic. */\n{\n tag: \"Standard\";\n value: {\n sssTopic: HexString;\n };\n};\nexport const CoinPaymentTransmissionChannel: Codec;\n/** Semantic color tokens, resolved by the host's theme. */\nexport type ColorToken = \"FgPrimary\" | \"FgSecondary\" | \"FgTertiary\" | \"BgSurfaceMain\" | \"BgSurfaceContainer\" | \"BgSurfaceNested\" | \"FgSuccess\" | \"FgError\" | \"FgWarning\";\nexport const ColorToken: Codec;\n/** Properties of a `Column`. */\nexport interface ColumnProps {\n /** Cross-axis alignment of children. */\n horizontalAlignment?: HorizontalAlignment;\n /** Main-axis distribution of children. */\n verticalArrangement?: Arrangement;\n}\nexport const ColumnProps: Codec;\n/** Placement of content within a `Box`. */\nexport type ContentAlignment = \"TopStart\" | \"TopCenter\" | \"TopEnd\" | \"CenterStart\" | \"Center\" | \"CenterEnd\" | \"BottomStart\" | \"BottomCenter\" | \"BottomEnd\";\nexport const ContentAlignment: Codec;\n/** A privacy-preserving alias derived via ring VRF, bound to a specific context. */\nexport interface ContextualAlias {\n /** 32-byte context identifier the alias is bound to. */\n context: HexString;\n /** Ring VRF alias (variable length). */\n alias: HexString;\n}\nexport const ContextualAlias: Codec;\n/**\n * Account selector within a product subtree. Encodes as\n * `Either` on the wire (`Index` = left, `Raw` = right).\n *\n * `Index` is the primary form \u2014 plain indices keep a product's accounts\n * enumerable. `Raw` carries a raw 32-byte derivation index for cases where\n * bytes are genuinely necessary. Hosts expand `Index(n)` to the internal\n * 32-byte index (`u32` little-endian plus the index magic).\n */\nexport type DerivationIndex = \n/** Plain account index. */\n{\n tag: \"Index\";\n value: number;\n}\n/** Raw 32-byte derivation index. */\n | {\n tag: \"Raw\";\n value: HexString;\n};\nexport const DerivationIndex: Codec;\n/** Edge dimensions. `bottom` defaults to `top` and `start` to `end` when absent. */\nexport interface Dimensions {\n /** Top edge. */\n top: Size;\n /** End edge. */\n end: Size;\n /** Bottom edge; defaults to `top`. */\n bottom?: Size;\n /** Start edge; defaults to `end`. */\n start?: Size;\n}\nexport const Dimensions: Codec;\n/** A visual effect. Each variant names one effect and carries its parameters. */\nexport type Effect = \"Rainbow\";\nexport const Effect: Codec;\n/** Properties of an `Effect`. */\nexport interface EffectProps {\n /** The effect applied to the children. */\n effect: Effect;\n}\nexport const EffectProps: Codec;\n/**\n * Generic error payload carrying a human-readable reason string. Used by many\n * methods as a catch-all error type.\n */\nexport interface GenericError {\n /** Human-readable failure reason. */\n reason: string;\n}\nexport const GenericError: Codec;\n/** A 32-byte chain genesis hash used to identify the target chain. */\nexport type GenesisHash = HexString;\nexport const GenesisHash: Codec;\n/** Cross-axis alignment of `Column` children. */\nexport type HorizontalAlignment = \"Start\" | \"Center\" | \"End\";\nexport const HorizontalAlignment: Codec;\n/** Versioned envelope for [`HostAccountConnectionStatusSubscribeError`]. */\nexport type VersionedHostAccountConnectionStatusSubscribeError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedHostAccountConnectionStatusSubscribeError: Codec;\n/** Versioned envelope for [`HostAccountConnectionStatusSubscribeItem`]. */\nexport type VersionedHostAccountConnectionStatusSubscribeItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountConnectionStatusSubscribeItem;\n};\nexport const VersionedHostAccountConnectionStatusSubscribeItem: Codec;\n/** Versioned envelope for [`HostAccountConnectionStatusSubscribeRequest`]. */\nexport type VersionedHostAccountConnectionStatusSubscribeRequest = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostAccountConnectionStatusSubscribeRequest: Codec;\n/** Versioned envelope for [`HostAccountCreateProofError`]. */\nexport type VersionedHostAccountCreateProofError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountCreateProofError;\n};\nexport const VersionedHostAccountCreateProofError: Codec;\n/** Versioned envelope for [`HostAccountCreateProofRequest`]. */\nexport type VersionedHostAccountCreateProofRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountCreateProofRequest;\n};\nexport const VersionedHostAccountCreateProofRequest: Codec;\n/** Versioned envelope for [`HostAccountCreateProofResponse`]. */\nexport type VersionedHostAccountCreateProofResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountCreateProofResponse;\n};\nexport const VersionedHostAccountCreateProofResponse: Codec;\n/** Versioned envelope for [`HostAccountGetAliasError`]. */\nexport type VersionedHostAccountGetAliasError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountGetAliasError;\n};\nexport const VersionedHostAccountGetAliasError: Codec;\n/** Versioned envelope for [`HostAccountGetAliasRequest`]. */\nexport type VersionedHostAccountGetAliasRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountGetAliasRequest;\n};\nexport const VersionedHostAccountGetAliasRequest: Codec;\n/** Versioned envelope for [`HostAccountGetAliasResponse`]. */\nexport type VersionedHostAccountGetAliasResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: ContextualAlias;\n};\nexport const VersionedHostAccountGetAliasResponse: Codec;\n/** Versioned envelope for [`HostAccountGetError`]. */\nexport type VersionedHostAccountGetError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountGetError;\n};\nexport const VersionedHostAccountGetError: Codec;\n/** Versioned envelope for [`HostAccountGetRequest`]. */\nexport type VersionedHostAccountGetRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountGetRequest;\n};\nexport const VersionedHostAccountGetRequest: Codec;\n/** Versioned envelope for [`HostAccountGetResponse`]. */\nexport type VersionedHostAccountGetResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountGetResponse;\n};\nexport const VersionedHostAccountGetResponse: Codec;\n/** Versioned envelope for [`HostAccountListRingVrfKeysError`]. */\nexport type VersionedHostAccountListRingVrfKeysError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountListRingVrfKeysError;\n};\nexport const VersionedHostAccountListRingVrfKeysError: Codec;\n/** Versioned envelope for [`HostAccountListRingVrfKeysRequest`]. */\nexport type VersionedHostAccountListRingVrfKeysRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountListRingVrfKeysRequest;\n};\nexport const VersionedHostAccountListRingVrfKeysRequest: Codec;\n/** Versioned envelope for [`HostAccountListRingVrfKeysResponse`]. */\nexport type VersionedHostAccountListRingVrfKeysResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: Array;\n};\nexport const VersionedHostAccountListRingVrfKeysResponse: Codec;\n/** Versioned envelope for [`HostAccountRegisterRingVrfKeyError`]. */\nexport type VersionedHostAccountRegisterRingVrfKeyError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountRegisterRingVrfKeyError;\n};\nexport const VersionedHostAccountRegisterRingVrfKeyError: Codec;\n/** Versioned envelope for [`HostAccountRegisterRingVrfKeyRequest`]. */\nexport type VersionedHostAccountRegisterRingVrfKeyRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountRegisterRingVrfKeyRequest;\n};\nexport const VersionedHostAccountRegisterRingVrfKeyRequest: Codec;\n/** Versioned envelope for [`HostAccountRegisterRingVrfKeyResponse`]. */\nexport type VersionedHostAccountRegisterRingVrfKeyResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RingVrfPublicKey;\n};\nexport const VersionedHostAccountRegisterRingVrfKeyResponse: Codec;\n/** Versioned envelope for [`HostAccountRingVrfSignError`]. */\nexport type VersionedHostAccountRingVrfSignError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountRingVrfSignError;\n};\nexport const VersionedHostAccountRingVrfSignError: Codec;\n/** Versioned envelope for [`HostAccountRingVrfSignRequest`]. */\nexport type VersionedHostAccountRingVrfSignRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountRingVrfSignRequest;\n};\nexport const VersionedHostAccountRingVrfSignRequest: Codec;\n/** Versioned envelope for [`HostAccountRingVrfSignResponse`]. */\nexport type VersionedHostAccountRingVrfSignResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HexString;\n};\nexport const VersionedHostAccountRingVrfSignResponse: Codec;\n/** Versioned envelope for [`HostAccountSignVrfError`]. */\nexport type VersionedHostAccountSignVrfError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountSignVrfError;\n};\nexport const VersionedHostAccountSignVrfError: Codec;\n/** Versioned envelope for [`HostAccountSignVrfRequest`]. */\nexport type VersionedHostAccountSignVrfRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountSignVrfRequest;\n};\nexport const VersionedHostAccountSignVrfRequest: Codec;\n/** Versioned envelope for [`HostAccountSignVrfResponse`]. */\nexport type VersionedHostAccountSignVrfResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: VrfSignature;\n};\nexport const VersionedHostAccountSignVrfResponse: Codec;\n/** Versioned envelope for [`HostChatActionSubscribeError`]. */\nexport type VersionedHostChatActionSubscribeError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedHostChatActionSubscribeError: Codec;\n/** Versioned envelope for [`HostChatActionSubscribeItem`]. */\nexport type VersionedHostChatActionSubscribeItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostChatActionSubscribeItem;\n};\nexport const VersionedHostChatActionSubscribeItem: Codec;\n/** Versioned envelope for [`HostChatActionSubscribeRequest`]. */\nexport type VersionedHostChatActionSubscribeRequest = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostChatActionSubscribeRequest: Codec;\n/** Versioned envelope for [`HostChatCreateRoomError`]. */\nexport type VersionedHostChatCreateRoomError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostChatCreateRoomError;\n};\nexport const VersionedHostChatCreateRoomError: Codec;\n/** Versioned envelope for [`HostChatCreateRoomRequest`]. */\nexport type VersionedHostChatCreateRoomRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostChatCreateRoomRequest;\n};\nexport const VersionedHostChatCreateRoomRequest: Codec;\n/** Versioned envelope for [`HostChatCreateRoomResponse`]. */\nexport type VersionedHostChatCreateRoomResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostChatCreateRoomResponse;\n};\nexport const VersionedHostChatCreateRoomResponse: Codec;\n/** Versioned envelope for [`HostChatListSubscribeError`]. */\nexport type VersionedHostChatListSubscribeError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedHostChatListSubscribeError: Codec;\n/** Versioned envelope for [`HostChatListSubscribeItem`]. */\nexport type VersionedHostChatListSubscribeItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostChatListSubscribeItem;\n};\nexport const VersionedHostChatListSubscribeItem: Codec;\n/** Versioned envelope for [`HostChatListSubscribeRequest`]. */\nexport type VersionedHostChatListSubscribeRequest = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostChatListSubscribeRequest: Codec;\n/** Versioned envelope for [`HostChatPostMessageError`]. */\nexport type VersionedHostChatPostMessageError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostChatPostMessageError;\n};\nexport const VersionedHostChatPostMessageError: Codec;\n/** Versioned envelope for [`HostChatPostMessageRequest`]. */\nexport type VersionedHostChatPostMessageRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostChatPostMessageRequest;\n};\nexport const VersionedHostChatPostMessageRequest: Codec;\n/** Versioned envelope for [`HostChatPostMessageResponse`]. */\nexport type VersionedHostChatPostMessageResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostChatPostMessageResponse;\n};\nexport const VersionedHostChatPostMessageResponse: Codec;\n/** Versioned envelope for [`HostChatRegisterBotError`]. */\nexport type VersionedHostChatRegisterBotError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostChatRegisterBotError;\n};\nexport const VersionedHostChatRegisterBotError: Codec;\n/** Versioned envelope for [`HostChatRegisterBotRequest`]. */\nexport type VersionedHostChatRegisterBotRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostChatRegisterBotRequest;\n};\nexport const VersionedHostChatRegisterBotRequest: Codec;\n/** Versioned envelope for [`HostChatRegisterBotResponse`]. */\nexport type VersionedHostChatRegisterBotResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostChatRegisterBotResponse;\n};\nexport const VersionedHostChatRegisterBotResponse: Codec;\n/** Versioned envelope for [`HostCoinPaymentCreateChequeError`]. */\nexport type VersionedHostCoinPaymentCreateChequeError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: CoinPaymentError;\n};\nexport const VersionedHostCoinPaymentCreateChequeError: Codec;\n/** Versioned envelope for [`HostCoinPaymentCreateChequeRequest`]. */\nexport type VersionedHostCoinPaymentCreateChequeRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCoinPaymentCreateChequeRequest;\n};\nexport const VersionedHostCoinPaymentCreateChequeRequest: Codec;\n/** Versioned envelope for [`HostCoinPaymentCreateChequeResponse`]. */\nexport type VersionedHostCoinPaymentCreateChequeResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCoinPaymentCreateChequeResponse;\n};\nexport const VersionedHostCoinPaymentCreateChequeResponse: Codec;\n/** Versioned envelope for [`HostCoinPaymentCreatePurseError`]. */\nexport type VersionedHostCoinPaymentCreatePurseError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: CoinPaymentError;\n};\nexport const VersionedHostCoinPaymentCreatePurseError: Codec;\n/** Versioned envelope for [`HostCoinPaymentCreatePurseRequest`]. */\nexport type VersionedHostCoinPaymentCreatePurseRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCoinPaymentCreatePurseRequest;\n};\nexport const VersionedHostCoinPaymentCreatePurseRequest: Codec;\n/** Versioned envelope for [`HostCoinPaymentCreatePurseResponse`]. */\nexport type VersionedHostCoinPaymentCreatePurseResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCoinPaymentCreatePurseResponse;\n};\nexport const VersionedHostCoinPaymentCreatePurseResponse: Codec;\n/** Versioned envelope for [`HostCoinPaymentCreateReceivableError`]. */\nexport type VersionedHostCoinPaymentCreateReceivableError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: CoinPaymentError;\n};\nexport const VersionedHostCoinPaymentCreateReceivableError: Codec;\n/** Versioned envelope for [`HostCoinPaymentCreateReceivableRequest`]. */\nexport type VersionedHostCoinPaymentCreateReceivableRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCoinPaymentCreateReceivableRequest;\n};\nexport const VersionedHostCoinPaymentCreateReceivableRequest: Codec;\n/** Versioned envelope for [`HostCoinPaymentCreateReceivableResponse`]. */\nexport type VersionedHostCoinPaymentCreateReceivableResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCoinPaymentCreateReceivableResponse;\n};\nexport const VersionedHostCoinPaymentCreateReceivableResponse: Codec;\n/** Versioned envelope for [`HostCoinPaymentDeletePurseError`]. */\nexport type VersionedHostCoinPaymentDeletePurseError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: CoinPaymentError;\n};\nexport const VersionedHostCoinPaymentDeletePurseError: Codec;\n/** Versioned envelope for [`HostCoinPaymentDeletePurseItem`]. */\nexport type VersionedHostCoinPaymentDeletePurseItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: CoinPaymentStatus;\n};\nexport const VersionedHostCoinPaymentDeletePurseItem: Codec;\n/** Versioned envelope for [`HostCoinPaymentDeletePurseRequest`]. */\nexport type VersionedHostCoinPaymentDeletePurseRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCoinPaymentDeletePurseRequest;\n};\nexport const VersionedHostCoinPaymentDeletePurseRequest: Codec;\n/** Versioned envelope for [`HostCoinPaymentDepositError`]. */\nexport type VersionedHostCoinPaymentDepositError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: CoinPaymentError;\n};\nexport const VersionedHostCoinPaymentDepositError: Codec;\n/** Versioned envelope for [`HostCoinPaymentDepositItem`]. */\nexport type VersionedHostCoinPaymentDepositItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: CoinPaymentStatus;\n};\nexport const VersionedHostCoinPaymentDepositItem: Codec;\n/** Versioned envelope for [`HostCoinPaymentDepositRequest`]. */\nexport type VersionedHostCoinPaymentDepositRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCoinPaymentDepositRequest;\n};\nexport const VersionedHostCoinPaymentDepositRequest: Codec;\n/** Versioned envelope for [`HostCoinPaymentListenForError`]. */\nexport type VersionedHostCoinPaymentListenForError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: CoinPaymentError;\n};\nexport const VersionedHostCoinPaymentListenForError: Codec;\n/** Versioned envelope for [`HostCoinPaymentListenForItem`]. */\nexport type VersionedHostCoinPaymentListenForItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCoinPaymentListenForItem;\n};\nexport const VersionedHostCoinPaymentListenForItem: Codec;\n/** Versioned envelope for [`HostCoinPaymentListenForRequest`]. */\nexport type VersionedHostCoinPaymentListenForRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCoinPaymentListenForRequest;\n};\nexport const VersionedHostCoinPaymentListenForRequest: Codec;\n/** Versioned envelope for [`HostCoinPaymentQueryPurseError`]. */\nexport type VersionedHostCoinPaymentQueryPurseError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: CoinPaymentError;\n};\nexport const VersionedHostCoinPaymentQueryPurseError: Codec;\n/** Versioned envelope for [`HostCoinPaymentQueryPurseRequest`]. */\nexport type VersionedHostCoinPaymentQueryPurseRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCoinPaymentQueryPurseRequest;\n};\nexport const VersionedHostCoinPaymentQueryPurseRequest: Codec;\n/** Versioned envelope for [`HostCoinPaymentQueryPurseResponse`]. */\nexport type VersionedHostCoinPaymentQueryPurseResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCoinPaymentQueryPurseResponse;\n};\nexport const VersionedHostCoinPaymentQueryPurseResponse: Codec;\n/** Versioned envelope for [`HostCoinPaymentRebalancePurseError`]. */\nexport type VersionedHostCoinPaymentRebalancePurseError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: CoinPaymentError;\n};\nexport const VersionedHostCoinPaymentRebalancePurseError: Codec;\n/** Versioned envelope for [`HostCoinPaymentRebalancePurseItem`]. */\nexport type VersionedHostCoinPaymentRebalancePurseItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: CoinPaymentStatus;\n};\nexport const VersionedHostCoinPaymentRebalancePurseItem: Codec;\n/** Versioned envelope for [`HostCoinPaymentRebalancePurseRequest`]. */\nexport type VersionedHostCoinPaymentRebalancePurseRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCoinPaymentRebalancePurseRequest;\n};\nexport const VersionedHostCoinPaymentRebalancePurseRequest: Codec;\n/** Versioned envelope for [`HostCoinPaymentRefundError`]. */\nexport type VersionedHostCoinPaymentRefundError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: CoinPaymentError;\n};\nexport const VersionedHostCoinPaymentRefundError: Codec;\n/** Versioned envelope for [`HostCoinPaymentRefundItem`]. */\nexport type VersionedHostCoinPaymentRefundItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: CoinPaymentStatus;\n};\nexport const VersionedHostCoinPaymentRefundItem: Codec;\n/** Versioned envelope for [`HostCoinPaymentRefundRequest`]. */\nexport type VersionedHostCoinPaymentRefundRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCoinPaymentRefundRequest;\n};\nexport const VersionedHostCoinPaymentRefundRequest: Codec;\n/** Versioned envelope for [`HostCreateTransactionError`]. */\nexport type VersionedHostCreateTransactionError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCreateTransactionError;\n};\nexport const VersionedHostCreateTransactionError: Codec;\n/** Versioned envelope for [`HostCreateTransactionRequest`]. */\nexport type VersionedHostCreateTransactionRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: ProductAccountTxPayload;\n};\nexport const VersionedHostCreateTransactionRequest: Codec;\n/** Versioned envelope for [`HostCreateTransactionResponse`]. */\nexport type VersionedHostCreateTransactionResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCreateTransactionResponse;\n};\nexport const VersionedHostCreateTransactionResponse: Codec;\n/** Versioned envelope for [`HostCreateTransactionWithLegacyAccountError`]. */\nexport type VersionedHostCreateTransactionWithLegacyAccountError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCreateTransactionError;\n};\nexport const VersionedHostCreateTransactionWithLegacyAccountError: Codec;\n/** Versioned envelope for [`HostCreateTransactionWithLegacyAccountRequest`]. */\nexport type VersionedHostCreateTransactionWithLegacyAccountRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: LegacyAccountTxPayload;\n};\nexport const VersionedHostCreateTransactionWithLegacyAccountRequest: Codec;\n/** Versioned envelope for [`HostCreateTransactionWithLegacyAccountResponse`]. */\nexport type VersionedHostCreateTransactionWithLegacyAccountResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCreateTransactionWithLegacyAccountResponse;\n};\nexport const VersionedHostCreateTransactionWithLegacyAccountResponse: Codec;\n/** Versioned envelope for [`HostDeriveEntropyError`]. */\nexport type VersionedHostDeriveEntropyError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostDeriveEntropyError;\n};\nexport const VersionedHostDeriveEntropyError: Codec;\n/** Versioned envelope for [`HostDeriveEntropyRequest`]. */\nexport type VersionedHostDeriveEntropyRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostDeriveEntropyRequest;\n};\nexport const VersionedHostDeriveEntropyRequest: Codec;\n/** Versioned envelope for [`HostDeriveEntropyResponse`]. */\nexport type VersionedHostDeriveEntropyResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostDeriveEntropyResponse;\n};\nexport const VersionedHostDeriveEntropyResponse: Codec;\n/** Versioned envelope for [`HostDevicePermissionError`]. */\nexport type VersionedHostDevicePermissionError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedHostDevicePermissionError: Codec;\n/** Versioned envelope for [`HostDevicePermissionRequest`]. */\nexport type VersionedHostDevicePermissionRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostDevicePermissionRequest;\n};\nexport const VersionedHostDevicePermissionRequest: Codec;\n/** Versioned envelope for [`HostDevicePermissionResponse`]. */\nexport type VersionedHostDevicePermissionResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostDevicePermissionResponse;\n};\nexport const VersionedHostDevicePermissionResponse: Codec;\n/** Versioned envelope for [`HostFeatureSupportedError`]. */\nexport type VersionedHostFeatureSupportedError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedHostFeatureSupportedError: Codec;\n/** Versioned envelope for [`HostFeatureSupportedRequest`]. */\nexport type VersionedHostFeatureSupportedRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostFeatureSupportedRequest;\n};\nexport const VersionedHostFeatureSupportedRequest: Codec;\n/** Versioned envelope for [`HostFeatureSupportedResponse`]. */\nexport type VersionedHostFeatureSupportedResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostFeatureSupportedResponse;\n};\nexport const VersionedHostFeatureSupportedResponse: Codec;\n/** Versioned envelope for [`HostGetLegacyAccountsError`]. */\nexport type VersionedHostGetLegacyAccountsError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountGetError;\n};\nexport const VersionedHostGetLegacyAccountsError: Codec;\n/** Versioned envelope for [`HostGetLegacyAccountsRequest`]. */\nexport type VersionedHostGetLegacyAccountsRequest = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostGetLegacyAccountsRequest: Codec;\n/** Versioned envelope for [`HostGetLegacyAccountsResponse`]. */\nexport type VersionedHostGetLegacyAccountsResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostGetLegacyAccountsResponse;\n};\nexport const VersionedHostGetLegacyAccountsResponse: Codec;\n/** Versioned envelope for [`HostGetProductContextError`]. */\nexport type VersionedHostGetProductContextError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedHostGetProductContextError: Codec;\n/** Versioned envelope for [`HostGetProductContextRequest`]. */\nexport type VersionedHostGetProductContextRequest = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostGetProductContextRequest: Codec;\n/** Versioned envelope for [`HostGetProductContextResponse`]. */\nexport type VersionedHostGetProductContextResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostGetProductContextResponse;\n};\nexport const VersionedHostGetProductContextResponse: Codec;\n/** Versioned envelope for [`HostGetUserIdError`]. */\nexport type VersionedHostGetUserIdError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostGetUserIdError;\n};\nexport const VersionedHostGetUserIdError: Codec;\n/** Versioned envelope for [`HostGetUserIdRequest`]. */\nexport type VersionedHostGetUserIdRequest = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostGetUserIdRequest: Codec;\n/** Versioned envelope for [`HostGetUserIdResponse`]. */\nexport type VersionedHostGetUserIdResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostGetUserIdResponse;\n};\nexport const VersionedHostGetUserIdResponse: Codec;\n/** Versioned envelope for [`HostHandshakeError`]. */\nexport type VersionedHostHandshakeError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostHandshakeError;\n};\nexport const VersionedHostHandshakeError: Codec;\n/** Versioned envelope for [`HostHandshakeRequest`]. */\nexport type VersionedHostHandshakeRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostHandshakeRequest;\n};\nexport const VersionedHostHandshakeRequest: Codec;\n/** Versioned envelope for [`HostHandshakeResponse`]. */\nexport type VersionedHostHandshakeResponse = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostHandshakeResponse: Codec;\n/**\n * Identity and version of the host currently running the product.\n *\n * Reported by [`crate::api::System::host_info`] so a product knows which host\n * (and which build of it) is running it \u2014 for adapting to the host,\n * telemetry, and attributing behaviour to a concrete build in diagnostics and\n * bug reports.\n */\nexport interface HostInfo {\n /** Platform category the host runs on. */\n platform: HostPlatform;\n /**\n * Human-readable name of the host implementation, e.g. `\"Polkadot\n * Desktop\"`, `\"Polkadot Mobile\"`, or `\"dotli\"`. Hosts should report a\n * stable, non-empty name.\n */\n name: string;\n /**\n * Host-native version string, e.g. a semver such as `\"1.2.3\"`. Hosts\n * should report a non-empty value; the format is the host's own.\n */\n version: string;\n}\nexport const HostInfo: Codec;\n/** Versioned envelope for [`HostInfoError`]. */\nexport type VersionedHostInfoError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedHostInfoError: Codec;\n/** Versioned envelope for [`HostInfoRequest`]. */\nexport type VersionedHostInfoRequest = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostInfoRequest: Codec;\n/** Versioned envelope for [`HostInfoResponse`]. */\nexport type VersionedHostInfoResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostInfo;\n};\nexport const VersionedHostInfoResponse: Codec;\n/** Versioned envelope for [`HostLocalStorageChangeItem`]. */\nexport type VersionedHostLocalStorageChangeItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostLocalStorageChangeItem;\n};\nexport const VersionedHostLocalStorageChangeItem: Codec;\n/** Versioned envelope for [`HostLocalStorageClearError`]. */\nexport type VersionedHostLocalStorageClearError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: V01HostLocalStorageReadError;\n};\nexport const VersionedHostLocalStorageClearError: Codec;\n/** Versioned envelope for [`HostLocalStorageClearRequest`]. */\nexport type VersionedHostLocalStorageClearRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostLocalStorageClearRequest;\n};\nexport const VersionedHostLocalStorageClearRequest: Codec;\n/** Versioned envelope for [`HostLocalStorageClearResponse`]. */\nexport type VersionedHostLocalStorageClearResponse = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostLocalStorageClearResponse: Codec;\n/** Versioned envelope for [`HostLocalStorageReadError`]. */\nexport type VersionedHostLocalStorageReadError = \n/** Version 2 payload. */\n{\n tag: \"V2\";\n value: HostLocalStorageReadError;\n};\nexport const VersionedHostLocalStorageReadError: Codec;\n/** Versioned envelope for [`HostLocalStorageReadRequest`]. */\nexport type VersionedHostLocalStorageReadRequest = \n/** Version 2 payload. */\n{\n tag: \"V2\";\n value: HostLocalStorageReadRequest;\n};\nexport const VersionedHostLocalStorageReadRequest: Codec;\n/** Versioned envelope for [`HostLocalStorageReadResponse`]. */\nexport type VersionedHostLocalStorageReadResponse = \n/** Version 2 payload. */\n{\n tag: \"V2\";\n value: HostLocalStorageReadResponse;\n};\nexport const VersionedHostLocalStorageReadResponse: Codec;\n/** Versioned envelope for [`HostLocalStorageSubscribeError`]. */\nexport type VersionedHostLocalStorageSubscribeError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedHostLocalStorageSubscribeError: Codec;\n/** Versioned envelope for [`HostLocalStorageSubscribeRequest`]. */\nexport type VersionedHostLocalStorageSubscribeRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostLocalStorageSubscribeRequest;\n};\nexport const VersionedHostLocalStorageSubscribeRequest: Codec;\n/** Versioned envelope for [`HostLocalStorageWriteError`]. */\nexport type VersionedHostLocalStorageWriteError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: V01HostLocalStorageReadError;\n};\nexport const VersionedHostLocalStorageWriteError: Codec;\n/** Versioned envelope for [`HostLocalStorageWriteRequest`]. */\nexport type VersionedHostLocalStorageWriteRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostLocalStorageWriteRequest;\n};\nexport const VersionedHostLocalStorageWriteRequest: Codec;\n/** Versioned envelope for [`HostLocalStorageWriteResponse`]. */\nexport type VersionedHostLocalStorageWriteResponse = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostLocalStorageWriteResponse: Codec;\n/** Versioned envelope for [`HostLocaleSubscribeError`]. */\nexport type VersionedHostLocaleSubscribeError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedHostLocaleSubscribeError: Codec;\n/** Versioned envelope for [`HostLocaleSubscribeItem`]. */\nexport type VersionedHostLocaleSubscribeItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostLocaleSubscribeItem;\n};\nexport const VersionedHostLocaleSubscribeItem: Codec;\n/** Versioned envelope for [`HostLocaleSubscribeRequest`]. */\nexport type VersionedHostLocaleSubscribeRequest = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostLocaleSubscribeRequest: Codec;\n/** A peer's native delivery acknowledgment, not a payment-clearing receipt. */\nexport interface HostNativeChatAcknowledgment {\n /** Authenticated acknowledging identity. */\n peerIdentity: HexString;\n /** Acknowledged native request identifier. */\n requestId: string;\n /** Native response code; zero denotes successful delivery processing. */\n responseCode: number;\n}\nexport const HostNativeChatAcknowledgment: Codec;\n/** Public attachment handle; only the Host can resolve its private backing. */\nexport interface HostNativeChatAttachment {\n /** Opaque handle scoped to the current wallet, network and calling product. */\n attachmentId: HexString;\n /** Non-secret native metadata. */\n metadata: HostNativeChatAttachmentMetadata;\n /** Current durable transfer progress. */\n state: HostNativeChatAttachmentState;\n}\nexport const HostNativeChatAttachment: Codec;\n/** Public native media metadata; thumbnails are BlurHash text, not executable images. */\nexport type HostNativeChatAttachmentKind = \n/** A general document or other opaque file. */\n{\n tag: \"File\";\n value?: undefined;\n}\n/** An image with native dimensions and an optional UTF-8 BlurHash. */\n | {\n tag: \"Image\";\n value: {\n width: number;\n height: number;\n thumbnail?: HexString;\n };\n}\n/** A video with native duration and an optional UTF-8 BlurHash. */\n | {\n tag: \"Video\";\n value: {\n durationSeconds: number;\n thumbnail?: HexString;\n };\n};\nexport const HostNativeChatAttachmentKind: Codec;\n/** Safe attachment description, independent of private transfer credentials. */\nexport interface HostNativeChatAttachmentMetadata {\n /** Validated media type; it does not authorize execution or network loading. */\n mimeType: string;\n /** Exact native file size, verified against the downloaded root and chunks. */\n sizeBytes: number;\n /** General file, image or video metadata. */\n kind: HostNativeChatAttachmentKind;\n}\nexport const HostNativeChatAttachmentMetadata: Codec;\n/** Durable transfer progress, distinct from message delivery acknowledgment. */\nexport type HostNativeChatAttachmentState = \n/** The Host is securing an immutable selected source. */\n{\n tag: \"Preparing\";\n value?: undefined;\n}\n/** Native HOP entries are being uploaded. */\n | {\n tag: \"Uploading\";\n value: {\n uploadedBytes: number;\n };\n}\n/** Verified file bytes are being committed to private local storage. */\n | {\n tag: \"Downloading\";\n value: {\n downloadedBytes: number;\n };\n}\n/** Complete verified bytes are available through trusted Host presentation. */\n | {\n tag: \"Ready\";\n value?: undefined;\n}\n/** An interrupted transfer retains its exact credentials and progress for retry. */\n | {\n tag: \"Recovering\";\n value?: undefined;\n};\nexport const HostNativeChatAttachmentState: Codec;\n/** Peer cryptographic identity independently resolved and bound by the Host. */\nexport interface HostNativeChatBinding {\n /** Authenticated peer root identity. */\n peerIdentity: HexString;\n /** Peer identity-level native Chat encryption key. */\n peerChatPublicKey: HexString;\n /** Identity proof used in the native invitation handshake. */\n identityProof: HexString;\n}\nexport const HostNativeChatBinding: Codec;\n/** The Host-owned device's public identity and statement-signing account. */\nexport interface HostNativeChatDevice {\n /** Wallet identity on the configured People chain. */\n identityAccountId: HexString;\n /** Wallet identity's public X25519 key. */\n identityChatPublicKey: HexString;\n /** Product account used to obtain a statement-store allowance for this device. */\n productAccount: ProductAccountId;\n /** Public statement signer for the Host-owned device. */\n accountId: HexString;\n /** Public X25519 key; its secret never leaves the Host. */\n chatPublicKey: HexString;\n}\nexport const HostNativeChatDevice: Codec;\n/** An authenticated invitation awaiting the user's Chat decision. */\nexport interface HostNativeChatInvitation {\n /** Host-generated stable invitation identifier. */\n invitationId: HexString;\n /** Authenticated sender identity. */\n peerIdentity: HexString;\n /** Host-resolved sender username, when available. */\n username?: string;\n /** Authenticated native invitation timestamp in milliseconds. */\n timestamp: bigint;\n /** Ordinary initial text, never an embedded payment or control message. */\n text: string;\n}\nexport const HostNativeChatInvitation: Codec;\n/** Safe ordinary messages from one authenticated native request. */\nexport interface HostNativeChatMessages {\n /** Authenticated counterparty identity. */\n peerIdentity: HexString;\n /** Whether the peer sent these messages; false also covers our welcome text. */\n incoming: boolean;\n /** Native request identifier, retained for message-delivery correlation. */\n requestId: string;\n /** Native message encodings after custody-sensitive content is removed. */\n messages: Array;\n}\nexport const HostNativeChatMessages: Codec;\n/** Native request identity needed to answer a migrated legacy invitation. */\nexport interface HostNativeChatMigrationInvitation {\n /** Invitation handle in the accompanying legacy public view. */\n invitationId: HexString;\n /** Original native request identity to acknowledge when answering. */\n requestId: string;\n}\nexport const HostNativeChatMigrationInvitation: Codec;\n/** Continuation metadata for a bounded page of authenticated incoming plaintext. */\nexport interface HostNativeChatOpenPage {\n /** Opaque identifier of the authenticated opening operation. */\n openId: HexString;\n /** Cursor identifying this page. */\n cursor: number;\n /** Cursor to request next; absent when the authenticated batch is complete. */\n nextCursor?: number;\n}\nexport const HostNativeChatOpenPage: Codec;\n/** Authenticated incoming native plaintext, potentially containing incoming coin keys. */\nexport interface HostNativeChatOpened {\n /** Authenticated peer root identity, never the local wallet's own identity. */\n peerIdentity: HexString;\n /** Account that signed the accepted native statement. */\n senderAccountId: HexString;\n /** Authenticated native context of the incoming statement. */\n route: HostNativeChatRoute;\n /** Native invitation or tagged request/response plaintext; never outgoing payment memos. */\n plaintext: HexString;\n}\nexport const HostNativeChatOpened: Codec;\n/** A product-visible payment card; it contains no spendable memo material. */\nexport interface HostNativeChatPayment {\n /** Durable, product-scoped operation identifier. */\n operationId: HexString;\n /** Caller request id for outgoing payments; native request id for incoming ones. */\n requestId: string;\n /** Native message id used to place the payment in conversation history. */\n messageId: string;\n /** Native message timestamp in milliseconds. */\n timestamp: bigint;\n /** Counterparty identity authenticated by the Host. */\n peerIdentity: HexString;\n /** Incoming or outgoing relative to the current wallet. */\n direction: HostNativeChatPaymentDirection;\n /** Exact requested/received value in cents. */\n amountCents: bigint;\n /** Durable transport/clearing state. */\n state: HostNativeChatPaymentState;\n}\nexport const HostNativeChatPayment: Codec;\n/** Payment direction relative to the current wallet. */\nexport type HostNativeChatPaymentDirection = \"Outgoing\" | \"Incoming\";\nexport const HostNativeChatPaymentDirection: Codec;\n/** Public, non-secret payment failure categories. */\nexport type HostNativeChatPaymentFailure = \"Cancelled\" | \"InsufficientBalance\" | \"AlreadySpent\" | \"InvalidMemo\" | \"ChainRejected\";\nexport const HostNativeChatPaymentFailure: Codec;\n/** Durable payment state. Delivery and on-chain clearing are deliberately distinct. */\nexport type HostNativeChatPaymentState = \n/** Approved inputs are reserved; required split/unload work is in progress. */\n{\n tag: \"Preparing\";\n value?: undefined;\n}\n/** The encrypted memo is durable and transport delivery is being retried. */\n | {\n tag: \"Delivering\";\n value?: undefined;\n}\n/** The peer acknowledged the memo; settlement has not yet been established. */\n | {\n tag: \"Delivered\";\n value?: undefined;\n}\n/** Received secrets are durably held while their claim is in progress. */\n | {\n tag: \"Claiming\";\n value?: undefined;\n}\n/** Some, but not all, of the payment has been observed clearing on chain. */\n | {\n tag: \"PartiallyCleared\";\n value: {\n clearedCents: bigint;\n };\n}\n/** The complete payment has been verified at chain finality. */\n | {\n tag: \"Cleared\";\n value?: undefined;\n}\n/** An ambiguous effect is retained for reconciliation; inputs remain reserved. */\n | {\n tag: \"Recovering\";\n value?: undefined;\n}\n/** A definitive failure; the Host has reconciled any possible prior effects. */\n | {\n tag: \"Failed\";\n value: {\n reason: HostNativeChatPaymentFailure;\n };\n};\nexport const HostNativeChatPaymentState: Codec;\n/** Public conversation state; products cannot write this roster back to the Host. */\nexport interface HostNativeChatPeer {\n /** Recipient wallet identity. */\n identityAccountId: HexString;\n /** Username resolved by the Host, if currently available. */\n username?: string;\n /** Devices admitted by authenticated native invitation/control messages. */\n devices: Array;\n /** Native session topics for subscriptions, not request/response channel hashes. */\n incomingChannels: Array;\n /** Whether establishment and legacy-device revocation have been acknowledged. */\n readyForPayments: boolean;\n}\nexport const HostNativeChatPeer: Codec;\n/** Public metadata for one authenticated remote device. */\nexport interface HostNativeChatPeerDevice {\n /** Remote device's statement signer. */\n accountId: HexString;\n /** Remote device's authenticated public X25519 key. */\n chatPublicKey: HexString;\n}\nexport const HostNativeChatPeerDevice: Codec;\n/** Signed ciphertext with the native identity required for durable product delivery. */\nexport interface HostNativeChatPrepared {\n /** Exact signed ciphertext to submit again when retrying delivery. */\n statement: SignedStatement;\n /** Authenticated recipient root identity. */\n peerIdentity: HexString;\n /** Native request identity used to correlate delivery acknowledgments. */\n requestId: string;\n /** Whether delivery remains pending until a native peer acknowledgment arrives. */\n requiresAck: boolean;\n /** Original product intent id for correlating migrated pending UI, when retained. */\n clientRequestId?: string;\n}\nexport const HostNativeChatPrepared: Codec;\n/** Authenticated rich content after private file capabilities have been removed. */\nexport interface HostNativeChatRichMessage {\n /** Authenticated conversation identity. */\n peerIdentity: HexString;\n /** Whether the remote peer authored this content. */\n incoming: boolean;\n /** Native request id used for delivery acknowledgment. */\n requestId: string;\n /** Native id of this message or edit event. */\n messageId: string;\n /** Native timestamp in milliseconds. */\n timestamp: bigint;\n /** New message, reply or edit; authorship checks still apply to edits. */\n kind: HostNativeChatRichMessageKind;\n /** Ordinary optional text. */\n text?: string;\n /** Opaque file handles and safe metadata, never native file references. */\n attachments: Array;\n}\nexport const HostNativeChatRichMessage: Codec;\n/** Native rich-content timeline operation. */\nexport type HostNativeChatRichMessageKind = \n/** A new ordinary rich message. */\n{\n tag: \"Message\";\n value?: undefined;\n}\n/** A new rich message replying to an earlier message. */\n | {\n tag: \"Reply\";\n value: {\n messageId: string;\n };\n}\n/** A replacement of the same author's earlier rich content. */\n | {\n tag: \"Edited\";\n value: {\n messageId: string;\n };\n};\nexport const HostNativeChatRichMessageKind: Codec;\n/** The authenticated native encryption and statement-routing context. */\nexport type HostNativeChatRoute = \"Invitation\" | \"Identity\" | \"Device\";\nexport const HostNativeChatRoute: Codec;\n/** Continuation metadata for a bounded page of a stable public state snapshot. */\nexport interface HostNativeChatStatePage {\n /** Opaque identifier of the Host-retained public state snapshot. */\n stateId: HexString;\n /** Cursor identifying this page. */\n cursor: number;\n /** Cursor to request next; absent when the snapshot is complete. */\n nextCursor?: number;\n}\nexport const HostNativeChatStatePage: Codec;\n/** Versioned envelope for [`HostNavigateToError`]. */\nexport type VersionedHostNavigateToError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostNavigateToError;\n};\nexport const VersionedHostNavigateToError: Codec;\n/** Versioned envelope for [`HostNavigateToRequest`]. */\nexport type VersionedHostNavigateToRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostNavigateToRequest;\n};\nexport const VersionedHostNavigateToRequest: Codec;\n/** Versioned envelope for [`HostNavigateToResponse`]. */\nexport type VersionedHostNavigateToResponse = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostNavigateToResponse: Codec;\n/** Versioned envelope for [`HostPaymentBalanceSubscribeError`]. */\nexport type VersionedHostPaymentBalanceSubscribeError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPaymentBalanceSubscribeError;\n};\nexport const VersionedHostPaymentBalanceSubscribeError: Codec;\n/** Versioned envelope for [`HostPaymentBalanceSubscribeItem`]. */\nexport type VersionedHostPaymentBalanceSubscribeItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPaymentBalanceSubscribeItem;\n};\nexport const VersionedHostPaymentBalanceSubscribeItem: Codec;\n/** Versioned envelope for [`HostPaymentBalanceSubscribeRequest`]. */\nexport type VersionedHostPaymentBalanceSubscribeRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPaymentBalanceSubscribeRequest;\n};\nexport const VersionedHostPaymentBalanceSubscribeRequest: Codec;\n/** Versioned envelope for [`HostPaymentError`]. */\nexport type VersionedHostPaymentError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPaymentError;\n};\nexport const VersionedHostPaymentError: Codec;\n/** Versioned envelope for [`HostPaymentRequest`]. */\nexport type VersionedHostPaymentRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPaymentRequest;\n};\nexport const VersionedHostPaymentRequest: Codec;\n/** Versioned envelope for [`HostPaymentResponse`]. */\nexport type VersionedHostPaymentResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPaymentResponse;\n};\nexport const VersionedHostPaymentResponse: Codec;\n/** Versioned envelope for [`HostPaymentStatusSubscribeError`]. */\nexport type VersionedHostPaymentStatusSubscribeError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPaymentStatusSubscribeError;\n};\nexport const VersionedHostPaymentStatusSubscribeError: Codec;\n/** Versioned envelope for [`HostPaymentStatusSubscribeItem`]. */\nexport type VersionedHostPaymentStatusSubscribeItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPaymentStatusSubscribeItem;\n};\nexport const VersionedHostPaymentStatusSubscribeItem: Codec;\n/** Versioned envelope for [`HostPaymentStatusSubscribeRequest`]. */\nexport type VersionedHostPaymentStatusSubscribeRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPaymentStatusSubscribeRequest;\n};\nexport const VersionedHostPaymentStatusSubscribeRequest: Codec;\n/** Versioned envelope for [`HostPaymentTopUpError`]. */\nexport type VersionedHostPaymentTopUpError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPaymentTopUpError;\n};\nexport const VersionedHostPaymentTopUpError: Codec;\n/** Versioned envelope for [`HostPaymentTopUpRequest`]. */\nexport type VersionedHostPaymentTopUpRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPaymentTopUpRequest;\n};\nexport const VersionedHostPaymentTopUpRequest: Codec;\n/** Versioned envelope for [`HostPaymentTopUpResponse`]. */\nexport type VersionedHostPaymentTopUpResponse = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostPaymentTopUpResponse: Codec;\n/** Platform category a host runs on. */\nexport type HostPlatform = \"Web\" | \"Android\" | \"Ios\" | \"Desktop\" | \"Cli\" | \"Unknown\";\nexport const HostPlatform: Codec;\n/** Versioned envelope for [`HostPocketListSubscribeError`]. */\nexport type VersionedHostPocketListSubscribeError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedHostPocketListSubscribeError: Codec;\n/** Versioned envelope for [`HostPocketListSubscribeItem`]. */\nexport type VersionedHostPocketListSubscribeItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPocketListSubscribeItem;\n};\nexport const VersionedHostPocketListSubscribeItem: Codec;\n/** Versioned envelope for [`HostPocketListSubscribeRequest`]. */\nexport type VersionedHostPocketListSubscribeRequest = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostPocketListSubscribeRequest: Codec;\n/** Versioned envelope for [`HostPocketRemoveCardError`]. */\nexport type VersionedHostPocketRemoveCardError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPocketRemoveCardError;\n};\nexport const VersionedHostPocketRemoveCardError: Codec;\n/** Versioned envelope for [`HostPocketRemoveCardRequest`]. */\nexport type VersionedHostPocketRemoveCardRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPocketRemoveCardRequest;\n};\nexport const VersionedHostPocketRemoveCardRequest: Codec;\n/** Versioned envelope for [`HostPocketRemoveCardResponse`]. */\nexport type VersionedHostPocketRemoveCardResponse = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostPocketRemoveCardResponse: Codec;\n/** Versioned envelope for [`HostProductDeviceChatError`]. */\nexport type VersionedHostProductDeviceChatError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostProductDeviceChatError;\n};\nexport const VersionedHostProductDeviceChatError: Codec;\n/** Versioned envelope for [`HostProductDeviceChatRequest`]. */\nexport type VersionedHostProductDeviceChatRequest = \n/** Version 2 payload. */\n{\n tag: \"V2\";\n value: HostProductDeviceChatRequest;\n};\nexport const VersionedHostProductDeviceChatRequest: Codec;\n/** Versioned envelope for [`HostProductDeviceChatResponse`]. */\nexport type VersionedHostProductDeviceChatResponse = \n/** Version 2 payload. */\n{\n tag: \"V2\";\n value: HostProductDeviceChatResponse;\n};\nexport const VersionedHostProductDeviceChatResponse: Codec;\n/** Versioned envelope for [`HostProfilePresentError`]. */\nexport type VersionedHostProfilePresentError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostProfilePresentError;\n};\nexport const VersionedHostProfilePresentError: Codec;\n/** Versioned envelope for [`HostProfilePresentRequest`]. */\nexport type VersionedHostProfilePresentRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostProfilePresentRequest;\n};\nexport const VersionedHostProfilePresentRequest: Codec;\n/** Versioned envelope for [`HostProfilePresentResponse`]. */\nexport type VersionedHostProfilePresentResponse = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostProfilePresentResponse: Codec;\n/** Versioned envelope for [`HostPushNotificationCancelError`]. */\nexport type VersionedHostPushNotificationCancelError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedHostPushNotificationCancelError: Codec;\n/** Versioned envelope for [`HostPushNotificationCancelRequest`]. */\nexport type VersionedHostPushNotificationCancelRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPushNotificationCancelRequest;\n};\nexport const VersionedHostPushNotificationCancelRequest: Codec;\n/** Versioned envelope for [`HostPushNotificationCancelResponse`]. */\nexport type VersionedHostPushNotificationCancelResponse = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostPushNotificationCancelResponse: Codec;\n/** Versioned envelope for [`HostPushNotificationError`]. */\nexport type VersionedHostPushNotificationError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPushNotificationError;\n};\nexport const VersionedHostPushNotificationError: Codec;\n/** Versioned envelope for [`HostPushNotificationRequest`]. */\nexport type VersionedHostPushNotificationRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPushNotificationRequest;\n};\nexport const VersionedHostPushNotificationRequest: Codec;\n/** Versioned envelope for [`HostPushNotificationResponse`]. */\nexport type VersionedHostPushNotificationResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPushNotificationResponse;\n};\nexport const VersionedHostPushNotificationResponse: Codec;\n/** Versioned envelope for [`HostRendererActionSubscribeError`]. */\nexport type VersionedHostRendererActionSubscribeError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedHostRendererActionSubscribeError: Codec;\n/** Versioned envelope for [`HostRendererActionSubscribeItem`]. */\nexport type VersionedHostRendererActionSubscribeItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostRendererActionSubscribeItem;\n};\nexport const VersionedHostRendererActionSubscribeItem: Codec;\n/** Versioned envelope for [`HostRendererActionSubscribeRequest`]. */\nexport type VersionedHostRendererActionSubscribeRequest = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostRendererActionSubscribeRequest: Codec;\n/** Versioned envelope for [`HostRequestLoginError`]. */\nexport type VersionedHostRequestLoginError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostRequestLoginError;\n};\nexport const VersionedHostRequestLoginError: Codec;\n/** Versioned envelope for [`HostRequestLoginRequest`]. */\nexport type VersionedHostRequestLoginRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostRequestLoginRequest;\n};\nexport const VersionedHostRequestLoginRequest: Codec;\n/** Versioned envelope for [`HostRequestLoginResponse`]. */\nexport type VersionedHostRequestLoginResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostRequestLoginResponse;\n};\nexport const VersionedHostRequestLoginResponse: Codec;\n/** Versioned envelope for [`HostRequestResourceAllocationError`]. */\nexport type VersionedHostRequestResourceAllocationError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: ResourceAllocationError;\n};\nexport const VersionedHostRequestResourceAllocationError: Codec;\n/** Versioned envelope for [`HostRequestResourceAllocationRequest`]. */\nexport type VersionedHostRequestResourceAllocationRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostRequestResourceAllocationRequest;\n};\nexport const VersionedHostRequestResourceAllocationRequest: Codec;\n/** Versioned envelope for [`HostRequestResourceAllocationResponse`]. */\nexport type VersionedHostRequestResourceAllocationResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostRequestResourceAllocationResponse;\n};\nexport const VersionedHostRequestResourceAllocationResponse: Codec;\n/**\n * Full Substrate extrinsic signing payload with all fields needed for signature\n * generation.\n */\nexport interface HostSignPayloadData {\n /** Reference block hash. */\n blockHash: HexString;\n /** Reference block number. */\n blockNumber: HexString;\n /** Mortality era encoding. */\n era: HexString;\n /** Chain genesis hash. */\n genesisHash: HexString;\n /** SCALE-encoded call data. */\n method: HexString;\n /** Account nonce. */\n nonce: HexString;\n /** Runtime spec version. */\n specVersion: HexString;\n /** Transaction tip. */\n tip: HexString;\n /** Transaction format version. */\n transactionVersion: HexString;\n /** Extension identifiers. */\n signedExtensions: Array;\n /** Extrinsic version. */\n version: number;\n /** For multi-asset tips. */\n assetId?: HexString;\n /** CheckMetadataHash extension. */\n metadataHash?: HexString;\n /** Metadata mode. */\n mode?: number;\n /** Request signed transaction back, encoded as one byte: absent, true, or false. */\n withSignedTransaction?: boolean;\n}\nexport const HostSignPayloadData: Codec;\n/** Versioned envelope for [`HostSignPayloadError`]. */\nexport type VersionedHostSignPayloadError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostSignPayloadError;\n};\nexport const VersionedHostSignPayloadError: Codec;\n/** Versioned envelope for [`HostSignPayloadRequest`]. */\nexport type VersionedHostSignPayloadRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostSignPayloadRequest;\n};\nexport const VersionedHostSignPayloadRequest: Codec;\n/** Versioned envelope for [`HostSignPayloadResponse`]. */\nexport type VersionedHostSignPayloadResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostSignPayloadResponse;\n};\nexport const VersionedHostSignPayloadResponse: Codec;\n/** Versioned envelope for [`HostSignPayloadWithLegacyAccountError`]. */\nexport type VersionedHostSignPayloadWithLegacyAccountError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostSignPayloadError;\n};\nexport const VersionedHostSignPayloadWithLegacyAccountError: Codec;\n/** Versioned envelope for [`HostSignPayloadWithLegacyAccountRequest`]. */\nexport type VersionedHostSignPayloadWithLegacyAccountRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostSignPayloadWithLegacyAccountRequest;\n};\nexport const VersionedHostSignPayloadWithLegacyAccountRequest: Codec;\n/** Versioned envelope for [`HostSignPayloadWithLegacyAccountResponse`]. */\nexport type VersionedHostSignPayloadWithLegacyAccountResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostSignPayloadResponse;\n};\nexport const VersionedHostSignPayloadWithLegacyAccountResponse: Codec;\n/** Versioned envelope for [`HostSignRawError`]. */\nexport type VersionedHostSignRawError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostSignPayloadError;\n};\nexport const VersionedHostSignRawError: Codec;\n/** Versioned envelope for [`HostSignRawRequest`]. */\nexport type VersionedHostSignRawRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostSignRawRequest;\n};\nexport const VersionedHostSignRawRequest: Codec;\n/** Versioned envelope for [`HostSignRawResponse`]. */\nexport type VersionedHostSignRawResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostSignPayloadResponse;\n};\nexport const VersionedHostSignRawResponse: Codec;\n/** Versioned envelope for [`HostSignRawWithLegacyAccountError`]. */\nexport type VersionedHostSignRawWithLegacyAccountError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostSignPayloadError;\n};\nexport const VersionedHostSignRawWithLegacyAccountError: Codec;\n/** Versioned envelope for [`HostSignRawWithLegacyAccountRequest`]. */\nexport type VersionedHostSignRawWithLegacyAccountRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostSignRawWithLegacyAccountRequest;\n};\nexport const VersionedHostSignRawWithLegacyAccountRequest: Codec;\n/** Versioned envelope for [`HostSignRawWithLegacyAccountResponse`]. */\nexport type VersionedHostSignRawWithLegacyAccountResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostSignPayloadResponse;\n};\nexport const VersionedHostSignRawWithLegacyAccountResponse: Codec;\n/** Versioned envelope for [`HostThemeSubscribeError`]. */\nexport type VersionedHostThemeSubscribeError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedHostThemeSubscribeError: Codec;\n/** Versioned envelope for [`HostThemeSubscribeItem`]. */\nexport type VersionedHostThemeSubscribeItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostThemeSubscribeItem;\n};\nexport const VersionedHostThemeSubscribeItem: Codec;\n/** Versioned envelope for [`HostThemeSubscribeRequest`]. */\nexport type VersionedHostThemeSubscribeRequest = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostThemeSubscribeRequest: Codec;\n/** Versioned envelope for [`HostWorkerBeginOperationError`]. */\nexport type VersionedHostWorkerBeginOperationError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostWorkerOperationError;\n};\nexport const VersionedHostWorkerBeginOperationError: Codec;\n/** Versioned envelope for [`HostWorkerBeginOperationRequest`]. */\nexport type VersionedHostWorkerBeginOperationRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostWorkerBeginOperationRequest;\n};\nexport const VersionedHostWorkerBeginOperationRequest: Codec;\n/** Versioned envelope for [`HostWorkerBeginOperationResponse`]. */\nexport type VersionedHostWorkerBeginOperationResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostWorkerBeginOperationResponse;\n};\nexport const VersionedHostWorkerBeginOperationResponse: Codec;\n/** Versioned envelope for [`HostWorkerEndOperationError`]. */\nexport type VersionedHostWorkerEndOperationError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostWorkerOperationError;\n};\nexport const VersionedHostWorkerEndOperationError: Codec;\n/** Versioned envelope for [`HostWorkerEndOperationRequest`]. */\nexport type VersionedHostWorkerEndOperationRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostWorkerEndOperationRequest;\n};\nexport const VersionedHostWorkerEndOperationRequest: Codec;\n/** Versioned envelope for [`HostWorkerEndOperationResponse`]. */\nexport type VersionedHostWorkerEndOperationResponse = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostWorkerEndOperationResponse: Codec;\n/** Pending-operation error. */\nexport type HostWorkerOperationError = \n/**\n * The product is already at the host's per-product limit of open\n * operations.\n */\n{\n tag: \"TooManyOpen\";\n value?: undefined;\n}\n/** Catch-all host failure. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostWorkerOperationError: Codec;\n/** How an image meets the box its modifiers size. */\nexport type ImageFit = \"None\" | \"Fill\" | \"Cover\" | \"Contain\" | \"ScaleDown\";\nexport const ImageFit: Codec;\n/** Properties of an `Image`. */\nexport interface ImageProps {\n /** Where the image bytes come from. */\n source: ImageSource;\n /** Defaults to `Fill`. */\n fit?: ImageFit;\n}\nexport const ImageProps: Codec;\n/** Where image bytes come from. The host fetches them; the tree carries no URL. */\nexport type ImageSource = \n/** A Bulletin chain blob, addressed by its CID. */\n{\n tag: \"Bulletin\";\n value: string;\n}\n/**\n * A file inside the product's executable archive, as a path relative to\n * the archive root.\n */\n | {\n tag: \"Archive\";\n value: string;\n};\nexport const ImageSource: Codec;\n/**\n * A user-imported (legacy) account: public key plus an optional user-chosen\n * display name.\n *\n * Returned by [`HostGetLegacyAccountsResponse`]. Distinct from\n * [`ProductAccount`], which is protocol-derived and never carries a label.\n */\nexport interface LegacyAccount {\n /** The account public key (variable-length bytes). */\n publicKey: HexString;\n /** Optional user-chosen display name. */\n name?: string;\n}\nexport const LegacyAccount: Codec;\n/**\n * Transaction payload for a legacy (non-product) account.\n *\n * Identical to [`ProductAccountTxPayload`] except the signer is a raw\n * 32-byte [`AccountId`].\n */\nexport interface LegacyAccountTxPayload {\n /** Raw 32-byte public key of the legacy account. */\n signer: AccountId;\n /** Chain where the transaction will execute. */\n genesisHash: GenesisHash;\n /** SCALE-encoded Call data. */\n callData: HexString;\n /** Transaction extensions supplied by the caller. */\n extensions: Array;\n /** 0 for Extrinsic V4, runtime-supported value for V5. */\n txExtVersion: number;\n}\nexport const LegacyAccountTxPayload: Codec;\n/** Layout and styling applied to one node. */\nexport type Modifier = \n/** Outer spacing. */\n{\n tag: \"Margin\";\n value: Dimensions;\n}\n/** Inner spacing. */\n | {\n tag: \"Padding\";\n value: Dimensions;\n}\n/** Background fill. */\n | {\n tag: \"Background\";\n value: Background;\n}\n/** Border. */\n | {\n tag: \"Border\";\n value: BorderStyle;\n}\n/** Fixed height. */\n | {\n tag: \"Height\";\n value: Size;\n}\n/** Fixed width. */\n | {\n tag: \"Width\";\n value: Size;\n}\n/** Minimum width. */\n | {\n tag: \"MinWidth\";\n value: Size;\n}\n/** Minimum height. */\n | {\n tag: \"MinHeight\";\n value: Size;\n}\n/** Fill the available width. */\n | {\n tag: \"FillWidth\";\n value: boolean;\n}\n/** Fill the available height. */\n | {\n tag: \"FillHeight\";\n value: boolean;\n}\n/** 0 is transparent, 255 is opaque. */\n | {\n tag: \"Opacity\";\n value: number;\n}\n/** Compositing mode against what is behind the node. */\n | {\n tag: \"BlendingMode\";\n value: BlendingMode;\n};\nexport const Modifier: Codec;\n/** Opaque identifier for a push notification, unique per product. */\nexport type NotificationId = number;\nexport const NotificationId: Codec;\n/** Opaque host-assigned pending-operation identifier, unique per product. */\nexport type OperationId = number;\nexport const OperationId: Codec;\n/** Outcome of starting a chain-head operation. */\nexport type OperationStartedResult = \n/** The operation was accepted; results arrive as follow events. */\n{\n tag: \"Started\";\n value: {\n operationId: string;\n };\n}\n/** Too many operations are in progress; retry after some complete. */\n | {\n tag: \"LimitReached\";\n value?: undefined;\n};\nexport const OperationStartedResult: Codec;\n/**\n * Source for a payment top-up operation.\n *\n * See [RFC 0006].\n *\n * [RFC 0006]: https://github.com/paritytech/triangle-js-sdks/pull/94\n */\nexport type PaymentTopUpSource = \n/** Fund from one of the calling product's scoped accounts. */\n{\n tag: \"ProductAccount\";\n value: {\n derivationIndex: DerivationIndex;\n };\n}\n/**\n * Fund from a one-time account represented by its private key. This is a\n * standard account holding public funds, not a coin key.\n */\n | {\n tag: \"PrivateKey\";\n value: {\n sr25519SecretKey: HexString;\n };\n}\n/**\n * Fund directly from coin secret keys. Each key is an sr25519 secret\n * controlling a single coin.\n */\n | {\n tag: \"Coins\";\n value: {\n sr25519SecretKeys: Array;\n };\n};\nexport const PaymentTopUpSource: Codec;\n/** One of the calling product's Pocket cards. */\nexport interface PocketCard {\n /** Card label declared by the product, unique within the product. */\n cardId: string;\n /** Placed by the host itself; removable by neither the user nor the product. */\n privileged: boolean;\n}\nexport const PocketCard: Codec;\n/** Preimage submission error. */\nexport type PreimageSubmitError = \n/** Catch-all. */\n{\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const PreimageSubmitError: Codec;\n/** A product account: public key only, no display name. */\nexport interface ProductAccount {\n /** The account public key (variable-length bytes). */\n publicKey: HexString;\n}\nexport const ProductAccount: Codec;\n/**\n * Identifies a product-specific account by combining a dotNS domain name with a\n * derivation index.\n */\nexport interface ProductAccountId {\n /** A dotNS domain name identifier (e.g., `\"my-product.dot\"`). */\n dotNsIdentifier: string;\n /** Account selector within the product subtree. */\n derivationIndex: DerivationIndex;\n}\nexport const ProductAccountId: Codec;\n/**\n * Transaction payload for a product account.\n *\n * Contains everything the host needs to construct a signed extrinsic.\n * The signer is a [`ProductAccountId`]; the host resolves the\n * corresponding key pair through its account management layer.\n */\nexport interface ProductAccountTxPayload {\n /** Product account that will sign the transaction. */\n signer: ProductAccountId;\n /** Chain where the transaction will execute. */\n genesisHash: GenesisHash;\n /** SCALE-encoded Call data. */\n callData: HexString;\n /** Transaction extensions supplied by the caller. */\n extensions: Array;\n /** 0 for Extrinsic V4, runtime-supported value for V5. */\n txExtVersion: number;\n}\nexport const ProductAccountTxPayload: Codec;\n/**\n * A product-scoped proof context: a product and a context within it.\n *\n * Hashed (with a `product//` prefix) into the 32-byte context bound\n * to a ring VRF proof, so contexts cannot collide across products and the same\n * member key under different contexts yields unlinkable aliases.\n */\nexport interface ProductProofContext {\n /** dotNS product identifier (e.g. `\"my-product.dot\"`) scoping the context. */\n productId: string;\n /**\n * Selector distinguishing contexts within the product; expands to the\n * same 32-byte derivation index as [`ProductAccountId::derivation_index`].\n */\n suffix: DerivationIndex;\n}\nexport const ProductProofContext: Codec;\n/** Versioned envelope for [`ProductRendererRenderError`]. */\nexport type VersionedProductRendererRenderError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedProductRendererRenderError: Codec;\n/** Versioned envelope for [`ProductRendererRenderItem`]. */\nexport type VersionedProductRendererRenderItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RendererNode;\n};\nexport const VersionedProductRendererRenderItem: Codec;\n/** Versioned envelope for [`ProductRendererRenderRequest`]. */\nexport type VersionedProductRendererRenderRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: ProductRendererRenderRequest;\n};\nexport const VersionedProductRendererRenderRequest: Codec;\n/** Raw data to sign -- either binary bytes or a string message. */\nexport type RawPayload = \n/** Raw binary data to sign. */\n{\n tag: \"Bytes\";\n value: {\n bytes: HexString;\n };\n}\n/** String message to sign. */\n | {\n tag: \"Payload\";\n value: {\n payload: string;\n };\n};\nexport const RawPayload: Codec;\n/** A registered ring-VRF key entry. */\nexport interface RegisteredRingVrfKey {\n /** Stable public name of the key. */\n handle: ProductAccountId;\n /** Rings the owning product declared this key for. */\n rings: Array;\n /** Present when the caller owns the key or requested/granted disclosure. */\n publicKey?: RingVrfPublicKey;\n}\nexport const RegisteredRingVrfKey: Codec;\n/** Versioned envelope for [`RemoteChainHeadBodyError`]. */\nexport type VersionedRemoteChainHeadBodyError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedRemoteChainHeadBodyError: Codec;\n/** Versioned envelope for [`RemoteChainHeadBodyRequest`]. */\nexport type VersionedRemoteChainHeadBodyRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainHeadBodyRequest;\n};\nexport const VersionedRemoteChainHeadBodyRequest: Codec;\n/** Versioned envelope for [`RemoteChainHeadBodyResponse`]. */\nexport type VersionedRemoteChainHeadBodyResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainHeadBodyResponse;\n};\nexport const VersionedRemoteChainHeadBodyResponse: Codec;\n/** Versioned envelope for [`RemoteChainHeadCallError`]. */\nexport type VersionedRemoteChainHeadCallError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedRemoteChainHeadCallError: Codec;\n/** Versioned envelope for [`RemoteChainHeadCallRequest`]. */\nexport type VersionedRemoteChainHeadCallRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainHeadCallRequest;\n};\nexport const VersionedRemoteChainHeadCallRequest: Codec;\n/** Versioned envelope for [`RemoteChainHeadCallResponse`]. */\nexport type VersionedRemoteChainHeadCallResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainHeadCallResponse;\n};\nexport const VersionedRemoteChainHeadCallResponse: Codec;\n/** Versioned envelope for [`RemoteChainHeadContinueError`]. */\nexport type VersionedRemoteChainHeadContinueError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedRemoteChainHeadContinueError: Codec;\n/** Versioned envelope for [`RemoteChainHeadContinueRequest`]. */\nexport type VersionedRemoteChainHeadContinueRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainHeadContinueRequest;\n};\nexport const VersionedRemoteChainHeadContinueRequest: Codec;\n/** Versioned envelope for [`RemoteChainHeadContinueResponse`]. */\nexport type VersionedRemoteChainHeadContinueResponse = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedRemoteChainHeadContinueResponse: Codec;\n/** Versioned envelope for [`RemoteChainHeadFollowError`]. */\nexport type VersionedRemoteChainHeadFollowError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedRemoteChainHeadFollowError: Codec;\n/** Versioned envelope for [`RemoteChainHeadFollowItem`]. */\nexport type VersionedRemoteChainHeadFollowItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainHeadFollowItem;\n};\nexport const VersionedRemoteChainHeadFollowItem: Codec;\n/** Versioned envelope for [`RemoteChainHeadFollowRequest`]. */\nexport type VersionedRemoteChainHeadFollowRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainHeadFollowRequest;\n};\nexport const VersionedRemoteChainHeadFollowRequest: Codec;\n/** Versioned envelope for [`RemoteChainHeadHeaderError`]. */\nexport type VersionedRemoteChainHeadHeaderError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedRemoteChainHeadHeaderError: Codec;\n/** Versioned envelope for [`RemoteChainHeadHeaderRequest`]. */\nexport type VersionedRemoteChainHeadHeaderRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainHeadHeaderRequest;\n};\nexport const VersionedRemoteChainHeadHeaderRequest: Codec;\n/** Versioned envelope for [`RemoteChainHeadHeaderResponse`]. */\nexport type VersionedRemoteChainHeadHeaderResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainHeadHeaderResponse;\n};\nexport const VersionedRemoteChainHeadHeaderResponse: Codec;\n/** Versioned envelope for [`RemoteChainHeadStopOperationError`]. */\nexport type VersionedRemoteChainHeadStopOperationError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedRemoteChainHeadStopOperationError: Codec;\n/** Versioned envelope for [`RemoteChainHeadStopOperationRequest`]. */\nexport type VersionedRemoteChainHeadStopOperationRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainHeadStopOperationRequest;\n};\nexport const VersionedRemoteChainHeadStopOperationRequest: Codec;\n/** Versioned envelope for [`RemoteChainHeadStopOperationResponse`]. */\nexport type VersionedRemoteChainHeadStopOperationResponse = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedRemoteChainHeadStopOperationResponse: Codec;\n/** Versioned envelope for [`RemoteChainHeadStorageError`]. */\nexport type VersionedRemoteChainHeadStorageError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedRemoteChainHeadStorageError: Codec;\n/** Versioned envelope for [`RemoteChainHeadStorageRequest`]. */\nexport type VersionedRemoteChainHeadStorageRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainHeadStorageRequest;\n};\nexport const VersionedRemoteChainHeadStorageRequest: Codec;\n/** Versioned envelope for [`RemoteChainHeadStorageResponse`]. */\nexport type VersionedRemoteChainHeadStorageResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainHeadStorageResponse;\n};\nexport const VersionedRemoteChainHeadStorageResponse: Codec;\n/** Versioned envelope for [`RemoteChainHeadUnpinError`]. */\nexport type VersionedRemoteChainHeadUnpinError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedRemoteChainHeadUnpinError: Codec;\n/** Versioned envelope for [`RemoteChainHeadUnpinRequest`]. */\nexport type VersionedRemoteChainHeadUnpinRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainHeadUnpinRequest;\n};\nexport const VersionedRemoteChainHeadUnpinRequest: Codec;\n/** Versioned envelope for [`RemoteChainHeadUnpinResponse`]. */\nexport type VersionedRemoteChainHeadUnpinResponse = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedRemoteChainHeadUnpinResponse: Codec;\n/** Versioned envelope for [`RemoteChainInfoError`]. */\nexport type VersionedRemoteChainInfoError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainInfoError;\n};\nexport const VersionedRemoteChainInfoError: Codec;\n/** Versioned envelope for [`RemoteChainInfoRequest`]. */\nexport type VersionedRemoteChainInfoRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainInfoRequest;\n};\nexport const VersionedRemoteChainInfoRequest: Codec;\n/** Versioned envelope for [`RemoteChainInfoResponse`]. */\nexport type VersionedRemoteChainInfoResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainInfoResponse;\n};\nexport const VersionedRemoteChainInfoResponse: Codec;\n/** Versioned envelope for [`RemoteChainSpecChainNameError`]. */\nexport type VersionedRemoteChainSpecChainNameError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedRemoteChainSpecChainNameError: Codec;\n/** Versioned envelope for [`RemoteChainSpecChainNameRequest`]. */\nexport type VersionedRemoteChainSpecChainNameRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainSpecChainNameRequest;\n};\nexport const VersionedRemoteChainSpecChainNameRequest: Codec;\n/** Versioned envelope for [`RemoteChainSpecChainNameResponse`]. */\nexport type VersionedRemoteChainSpecChainNameResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainSpecChainNameResponse;\n};\nexport const VersionedRemoteChainSpecChainNameResponse: Codec;\n/** Versioned envelope for [`RemoteChainSpecGenesisHashError`]. */\nexport type VersionedRemoteChainSpecGenesisHashError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedRemoteChainSpecGenesisHashError: Codec;\n/** Versioned envelope for [`RemoteChainSpecGenesisHashRequest`]. */\nexport type VersionedRemoteChainSpecGenesisHashRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainSpecGenesisHashRequest;\n};\nexport const VersionedRemoteChainSpecGenesisHashRequest: Codec;\n/** Versioned envelope for [`RemoteChainSpecGenesisHashResponse`]. */\nexport type VersionedRemoteChainSpecGenesisHashResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainSpecGenesisHashResponse;\n};\nexport const VersionedRemoteChainSpecGenesisHashResponse: Codec;\n/** Versioned envelope for [`RemoteChainSpecPropertiesError`]. */\nexport type VersionedRemoteChainSpecPropertiesError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedRemoteChainSpecPropertiesError: Codec;\n/** Versioned envelope for [`RemoteChainSpecPropertiesRequest`]. */\nexport type VersionedRemoteChainSpecPropertiesRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainSpecPropertiesRequest;\n};\nexport const VersionedRemoteChainSpecPropertiesRequest: Codec;\n/** Versioned envelope for [`RemoteChainSpecPropertiesResponse`]. */\nexport type VersionedRemoteChainSpecPropertiesResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainSpecPropertiesResponse;\n};\nexport const VersionedRemoteChainSpecPropertiesResponse: Codec;\n/** Versioned envelope for [`RemoteChainTransactionBroadcastError`]. */\nexport type VersionedRemoteChainTransactionBroadcastError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedRemoteChainTransactionBroadcastError: Codec;\n/** Versioned envelope for [`RemoteChainTransactionBroadcastRequest`]. */\nexport type VersionedRemoteChainTransactionBroadcastRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainTransactionBroadcastRequest;\n};\nexport const VersionedRemoteChainTransactionBroadcastRequest: Codec;\n/** Versioned envelope for [`RemoteChainTransactionBroadcastResponse`]. */\nexport type VersionedRemoteChainTransactionBroadcastResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainTransactionBroadcastResponse;\n};\nexport const VersionedRemoteChainTransactionBroadcastResponse: Codec;\n/** Versioned envelope for [`RemoteChainTransactionStopError`]. */\nexport type VersionedRemoteChainTransactionStopError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedRemoteChainTransactionStopError: Codec;\n/** Versioned envelope for [`RemoteChainTransactionStopRequest`]. */\nexport type VersionedRemoteChainTransactionStopRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainTransactionStopRequest;\n};\nexport const VersionedRemoteChainTransactionStopRequest: Codec;\n/** Versioned envelope for [`RemoteChainTransactionStopResponse`]. */\nexport type VersionedRemoteChainTransactionStopResponse = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedRemoteChainTransactionStopResponse: Codec;\n/**\n * One remote-operation permission requested by the product (RFC 0002).\n *\n * `ChainSubmit`, `PreimageSubmit`, and `StatementSubmit` are also triggered\n * implicitly by the corresponding business calls when not yet granted.\n */\nexport type RemotePermission = \n/**\n * Outbound HTTP/WebSocket access to a set of domains. External navigation\n * uses [`HostDevicePermissionRequest::OpenUrl`] instead.\n */\n{\n tag: \"Remote\";\n value: {\n domains: Array;\n };\n}\n/**\n * WebRTC access.\n *\n * The container authorizes each peer connection through Rust before its\n * first network method. Later methods on that connection share the same\n * decision, so a one-use grant permits one connection. New connections\n * check current permissions without requiring a page reload.\n *\n * Camera and microphone capture is gated by the OS permission prompts and\n * [`HostDevicePermissionRequest`], not by this permission.\n */\n | {\n tag: \"WebRtc\";\n value?: undefined;\n}\n/** Submitting transactions on behalf of the user via `remote_chain_transaction_broadcast`. */\n | {\n tag: \"ChainSubmit\";\n value?: undefined;\n}\n/** Submitting preimages on behalf of the user via `remote_preimage_submit`. */\n | {\n tag: \"PreimageSubmit\";\n value?: undefined;\n}\n/** Submitting statements on behalf of the user via `remote_statement_store_submit`. */\n | {\n tag: \"StatementSubmit\";\n value?: undefined;\n};\nexport const RemotePermission: Codec;\n/** Versioned envelope for [`RemotePermissionError`]. */\nexport type VersionedRemotePermissionError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedRemotePermissionError: Codec;\n/** Versioned envelope for [`RemotePermissionRequest`]. */\nexport type VersionedRemotePermissionRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemotePermissionRequest;\n};\nexport const VersionedRemotePermissionRequest: Codec;\n/** Versioned envelope for [`RemotePermissionResponse`]. */\nexport type VersionedRemotePermissionResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemotePermissionResponse;\n};\nexport const VersionedRemotePermissionResponse: Codec;\n/** Versioned envelope for [`RemotePreimageLookupSubscribeError`]. */\nexport type VersionedRemotePreimageLookupSubscribeError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedRemotePreimageLookupSubscribeError: Codec;\n/** Versioned envelope for [`RemotePreimageLookupSubscribeItem`]. */\nexport type VersionedRemotePreimageLookupSubscribeItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemotePreimageLookupSubscribeItem;\n};\nexport const VersionedRemotePreimageLookupSubscribeItem: Codec;\n/** Versioned envelope for [`RemotePreimageLookupSubscribeRequest`]. */\nexport type VersionedRemotePreimageLookupSubscribeRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemotePreimageLookupSubscribeRequest;\n};\nexport const VersionedRemotePreimageLookupSubscribeRequest: Codec;\n/** Versioned envelope for [`RemotePreimageSubmitError`]. */\nexport type VersionedRemotePreimageSubmitError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: PreimageSubmitError;\n};\nexport const VersionedRemotePreimageSubmitError: Codec;\n/** Versioned envelope for [`RemotePreimageSubmitRequest`]. */\nexport type VersionedRemotePreimageSubmitRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HexString;\n};\nexport const VersionedRemotePreimageSubmitRequest: Codec;\n/** Versioned envelope for [`RemotePreimageSubmitResponse`]. */\nexport type VersionedRemotePreimageSubmitResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HexString;\n};\nexport const VersionedRemotePreimageSubmitResponse: Codec;\n/** Versioned envelope for [`RemoteStatementStoreCreateProofAuthorizedError`]. */\nexport type VersionedRemoteStatementStoreCreateProofAuthorizedError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteStatementStoreCreateProofError;\n};\nexport const VersionedRemoteStatementStoreCreateProofAuthorizedError: Codec;\n/** Versioned envelope for [`RemoteStatementStoreCreateProofAuthorizedRequest`]. */\nexport type VersionedRemoteStatementStoreCreateProofAuthorizedRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: Statement;\n};\nexport const VersionedRemoteStatementStoreCreateProofAuthorizedRequest: Codec;\n/** Versioned envelope for [`RemoteStatementStoreCreateProofAuthorizedResponse`]. */\nexport type VersionedRemoteStatementStoreCreateProofAuthorizedResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteStatementStoreCreateProofResponse;\n};\nexport const VersionedRemoteStatementStoreCreateProofAuthorizedResponse: Codec;\n/** Versioned envelope for [`RemoteStatementStoreCreateProofError`]. */\nexport type VersionedRemoteStatementStoreCreateProofError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteStatementStoreCreateProofError;\n};\nexport const VersionedRemoteStatementStoreCreateProofError: Codec;\n/** Versioned envelope for [`RemoteStatementStoreCreateProofRequest`]. */\nexport type VersionedRemoteStatementStoreCreateProofRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteStatementStoreCreateProofRequest;\n};\nexport const VersionedRemoteStatementStoreCreateProofRequest: Codec;\n/** Versioned envelope for [`RemoteStatementStoreCreateProofResponse`]. */\nexport type VersionedRemoteStatementStoreCreateProofResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteStatementStoreCreateProofResponse;\n};\nexport const VersionedRemoteStatementStoreCreateProofResponse: Codec;\n/** Versioned envelope for [`RemoteStatementStoreSubmitError`]. */\nexport type VersionedRemoteStatementStoreSubmitError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedRemoteStatementStoreSubmitError: Codec;\n/** Versioned envelope for [`RemoteStatementStoreSubmitRequest`]. */\nexport type VersionedRemoteStatementStoreSubmitRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: SignedStatement;\n};\nexport const VersionedRemoteStatementStoreSubmitRequest: Codec;\n/** Versioned envelope for [`RemoteStatementStoreSubmitResponse`]. */\nexport type VersionedRemoteStatementStoreSubmitResponse = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedRemoteStatementStoreSubmitResponse: Codec;\n/** Versioned envelope for [`RemoteStatementStoreSubscribeError`]. */\nexport type VersionedRemoteStatementStoreSubscribeError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedRemoteStatementStoreSubscribeError: Codec;\n/** Versioned envelope for [`RemoteStatementStoreSubscribeItem`]. */\nexport type VersionedRemoteStatementStoreSubscribeItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteStatementStoreSubscribeItem;\n};\nexport const VersionedRemoteStatementStoreSubscribeItem: Codec;\n/** Versioned envelope for [`RemoteStatementStoreSubscribeRequest`]. */\nexport type VersionedRemoteStatementStoreSubscribeRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteStatementStoreSubscribeRequest;\n};\nexport const VersionedRemoteStatementStoreSubscribeRequest: Codec;\n/** Where a product-rendered body lives, and the id that names it there. */\nexport type RenderContext = \n/** A message in a chat room. */\n{\n tag: \"ChatMessage\";\n value: {\n roomId: string;\n messageId: string;\n messageType: string;\n };\n}\n/** A candidate answered to an input query. */\n | {\n tag: \"InputWidget\";\n value: {\n candidateId: string;\n };\n}\n/** A card face in the host's Pocket collection. */\n | {\n tag: \"PocketCard\";\n value: {\n cardId: string;\n };\n};\nexport const RenderContext: Codec;\n/**\n * A node in a product-rendered tree. Container variants recurse through\n * `children`.\n */\nexport type RendererNode = \n/** Draws nothing. */\n{\n tag: \"Nil\";\n value?: undefined;\n}\n/** A text run. */\n | {\n tag: \"String\";\n value: {\n text: string;\n };\n}\n/** Generic container. */\n | {\n tag: \"Box\";\n value: {\n modifiers: Array;\n props: BoxProps;\n children: Array;\n };\n}\n/** Vertical layout. */\n | {\n tag: \"Column\";\n value: {\n modifiers: Array;\n props: ColumnProps;\n children: Array;\n };\n}\n/** Horizontal layout. */\n | {\n tag: \"Row\";\n value: {\n modifiers: Array;\n props: RowProps;\n children: Array;\n };\n}\n/** Flexible space. */\n | {\n tag: \"Spacer\";\n value: {\n modifiers: Array;\n };\n}\n/** Styled text. */\n | {\n tag: \"Text\";\n value: {\n modifiers: Array;\n props: TextProps;\n children: Array;\n };\n}\n/** Interactive button. */\n | {\n tag: \"Button\";\n value: {\n modifiers: Array;\n props: ButtonProps;\n children: Array;\n };\n}\n/** Single-line text input. */\n | {\n tag: \"TextField\";\n value: {\n modifiers: Array;\n props: TextFieldProps;\n };\n}\n/** Image, sized by modifiers. */\n | {\n tag: \"Image\";\n value: {\n modifiers: Array;\n props: ImageProps;\n };\n}\n/** Applies its effect to its children. */\n | {\n tag: \"Effect\";\n value: {\n props: EffectProps;\n children: Array;\n };\n};\nexport const RendererNode: Codec;\n/** Error from [`crate::api::ResourceAllocation::request`]. */\nexport type ResourceAllocationError = \n/** Catch-all. */\n{\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const ResourceAllocationError: Codec;\n/**\n * Locates a ring for ring VRF operations using only identifiers that are\n * stable across membership changes.\n */\nexport interface RingLocation {\n /** Genesis hash of the chain hosting the ring. */\n chainId: GenesisHash;\n /** Path addressing the ring within the chain. */\n junctions: Array;\n}\nexport const RingLocation: Codec;\n/** A single step in a [`RingLocation`] path, addressing a ring within a chain. */\nexport type RingLocationJunction = \n/** Pallet instance hosting the ring collection. */\n{\n tag: \"PalletInstance\";\n value: number;\n}\n/** Ring collection identifier within the pallet. */\n | {\n tag: \"CollectionId\";\n value: HexString;\n};\nexport const RingLocationJunction: Codec;\n/** How much of a registry entry the caller asks for. */\nexport type RingVrfKeyDisclosure = \"Anonymized\" | \"PublicKey\";\nexport const RingVrfKeyDisclosure: Codec;\n/** Ring-VRF member public key. */\nexport type RingVrfPublicKey = HexString;\nexport const RingVrfPublicKey: Codec;\n/** Properties of a `Row`. */\nexport interface RowProps {\n /** Cross-axis alignment of children. */\n verticalAlignment?: VerticalAlignment;\n /** Main-axis distribution of children. */\n horizontalArrangement?: Arrangement;\n}\nexport const RowProps: Codec;\n/** One entry of a runtime's supported API list. */\nexport interface RuntimeApi {\n /** Runtime API name. */\n name: string;\n /** Runtime API version. */\n version: number;\n}\nexport const RuntimeApi: Codec;\n/** Runtime version information for a block's runtime. */\nexport interface RuntimeSpec {\n /** Specification name. */\n specName: string;\n /** Implementation name. */\n implName: string;\n /** Spec version number. */\n specVersion: number;\n /** Implementation version. */\n implVersion: number;\n /** Transaction format version. */\n transactionVersion?: number;\n /** Supported runtime APIs. */\n apis: Array;\n}\nexport const RuntimeSpec: Codec;\n/** Runtime attached to follow events, either a decoded spec or a decode error. */\nexport type RuntimeType = \n/** Runtime spec decoded successfully. */\n{\n tag: \"Valid\";\n value: RuntimeSpec;\n}\n/** The runtime could not be decoded. */\n | {\n tag: \"Invalid\";\n value: {\n error: string;\n };\n};\nexport const RuntimeType: Codec;\n/** Outline of a background or border. */\nexport type Shape = \n/** Rounded corners with the given radius. */\n{\n tag: \"Rounded\";\n value: Size;\n}\n/** Circular shape. */\n | {\n tag: \"Circle\";\n value?: undefined;\n}\n/** Square corners. */\n | {\n tag: \"Square\";\n value?: undefined;\n};\nexport const Shape: Codec;\n/** A statement with a required (not optional) proof. */\nexport interface SignedStatement {\n /** Required cryptographic proof. */\n proof: StatementProof;\n /** Optional decryption key. */\n decryptionKey?: HexString;\n /** Optional Unix timestamp expiry. */\n expiry?: bigint;\n /** Optional channel. */\n channel?: HexString;\n /** [u8; 32] tags. */\n topics: Array;\n /** Optional data payload. */\n data?: HexString;\n}\nexport const SignedStatement: Codec;\n/** A size in logical pixels, SCALE-encoded as `Compact`. */\nexport type Size = number | bigint;\nexport const Size: Codec;\n/** A statement with optional proof and metadata. */\nexport interface Statement {\n /** Optional cryptographic proof. */\n proof?: StatementProof;\n /** Optional decryption key. */\n decryptionKey?: HexString;\n /** Optional Unix timestamp expiry. */\n expiry?: bigint;\n /** Optional channel. */\n channel?: HexString;\n /** [u8; 32] tags. */\n topics: Array;\n /** Optional data payload. */\n data?: HexString;\n}\nexport const Statement: Codec;\n/** Cryptographic proof for a statement. */\nexport type StatementProof = \n/** Sr25519 signature proof. */\n{\n tag: \"Sr25519\";\n value: {\n signature: HexString;\n signer: HexString;\n };\n}\n/** Ed25519 signature proof. */\n | {\n tag: \"Ed25519\";\n value: {\n signature: HexString;\n signer: HexString;\n };\n}\n/** ECDSA signature proof. */\n | {\n tag: \"Ecdsa\";\n value: {\n signature: HexString;\n signer: HexString;\n };\n}\n/** On-chain event proof. */\n | {\n tag: \"OnChain\";\n value: {\n who: HexString;\n blockHash: HexString;\n event: bigint;\n };\n};\nexport const StatementProof: Codec;\n/** A single key query within a chain-head storage request. */\nexport interface StorageQueryItem {\n /** Storage key to query. */\n key: HexString;\n /** What to return. */\n queryType: StorageQueryType;\n}\nexport const StorageQueryItem: Codec;\n/** What a chain-head storage query returns for a key. */\nexport type StorageQueryType = \"Value\" | \"Hash\" | \"ClosestDescendantMerkleValue\" | \"DescendantsValues\" | \"DescendantsHashes\";\nexport const StorageQueryType: Codec;\n/** Result for one queried storage key. */\nexport interface StorageResultItem {\n /** The queried key. */\n key: HexString;\n /** Value, if requested. */\n value?: HexString;\n /** Hash, if requested. */\n hash?: HexString;\n /** Merkle value, if requested. */\n closestDescendantMerkleValue?: HexString;\n}\nexport const StorageResultItem: Codec;\n/** Properties of a `TextField`. */\nexport interface TextFieldProps {\n /** Current value. */\n text: string;\n /** Shown when the value is empty. */\n placeholder?: string;\n /** Field label. */\n label?: string;\n /** Whether the field accepts input. Absent leaves the default to the host. */\n enabled?: boolean;\n /**\n * Action triggered on every value change. The action carries the new\n * value as UTF-8 bytes, with no length prefix.\n */\n valueChangeAction?: string;\n}\nexport const TextFieldProps: Codec;\n/** Properties of a `Text`. */\nexport interface TextProps {\n /** Typography preset. */\n style?: TypographyStyle;\n /** Text color. */\n color?: ColorToken;\n}\nexport const TextProps: Codec;\n/** Identifies a named theme. */\nexport type ThemeName = \n/** A custom named theme. */\n{\n tag: \"Custom\";\n value: string;\n}\n/** The host's default theme. */\n | {\n tag: \"Default\";\n value?: undefined;\n};\nexport const ThemeName: Codec;\n/** Light or dark variant. */\nexport type ThemeVariant = \"Light\" | \"Dark\";\nexport const ThemeVariant: Codec;\n/** 32-byte statement topic. */\nexport type Topic = HexString;\nexport const Topic: Codec;\n/** A signed extension for a transaction payload. */\nexport interface TxPayloadExtension {\n /** Extension name (e.g., `\"CheckSpecVersion\"`). */\n id: string;\n /** SCALE-encoded extra data (in extrinsic body). */\n extra: HexString;\n /** SCALE-encoded implicit data (signed, not in body). */\n additionalSigned: HexString;\n}\nexport const TxPayloadExtension: Codec;\n/** Typography presets, resolved by the host's design system. */\nexport type TypographyStyle = \"HeadlineLarge\" | \"TitleMediumRegular\" | \"BodyLargeRegular\" | \"BodyMediumRegular\" | \"BodySmallRegular\";\nexport const TypographyStyle: Codec;\n/** User's authentication state. */\nexport type HostAccountConnectionStatusSubscribeItem = \"Disconnected\" | \"Connected\";\nexport const HostAccountConnectionStatusSubscribeItem: Codec;\n/** Error returned when ring VRF proof creation fails. */\nexport type HostAccountCreateProofError = \n/** Ring not available at the specified location. */\n{\n tag: \"RingNotFound\";\n value?: undefined;\n}\n/** The registered member key is not a member of the requested ring. */\n | {\n tag: \"NotMember\";\n value?: undefined;\n}\n/** The key handle is not registered. */\n | {\n tag: \"KeyNotRegistered\";\n value?: undefined;\n}\n/** The key handle is not registered for the requested ring. */\n | {\n tag: \"KeyNotInRing\";\n value?: undefined;\n}\n/** The foreign key owner has not allowlisted the caller. */\n | {\n tag: \"NotAllowlisted\";\n value?: undefined;\n}\n/** User or host rejected. */\n | {\n tag: \"Rejected\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostAccountCreateProofError: Codec;\n/** Request to create a ring VRF proof. */\nexport interface HostAccountCreateProofRequest {\n /** Ring-VRF key handle naming the member key to use. */\n keyHandle: ProductAccountId;\n /** Product-scoped context the derived alias is bound to. */\n context: ProductProofContext;\n /** Ring to generate the proof against. */\n ringLocation: RingLocation;\n /** Opaque message bound into the proof. */\n message: HexString;\n}\nexport const HostAccountCreateProofRequest: Codec;\n/**\n * Response containing a ring VRF proof and the values needed to verify it\n * against a downstream precompile.\n */\nexport interface HostAccountCreateProofResponse {\n /** Variable-length ring VRF proof bytes. */\n proof: HexString;\n /** Alias derived for the request's context. */\n contextualAlias: ContextualAlias;\n /** Index of the selected member key within the ring. */\n ringIndex: number;\n /** Ring revision the proof was generated against. */\n ringRevision: number;\n}\nexport const HostAccountCreateProofResponse: Codec;\n/** Error returned when contextual alias derivation fails. */\nexport type HostAccountGetAliasError = \n/** Ring not available at the specified location. */\n{\n tag: \"RingNotFound\";\n value?: undefined;\n}\n/** The registered member key is not a member of the requested ring. */\n | {\n tag: \"NotMember\";\n value?: undefined;\n}\n/** The key handle is not registered. */\n | {\n tag: \"KeyNotRegistered\";\n value?: undefined;\n}\n/** The key handle is not registered for the requested ring. */\n | {\n tag: \"KeyNotInRing\";\n value?: undefined;\n}\n/** User or host rejected. */\n | {\n tag: \"Rejected\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostAccountGetAliasError: Codec;\n/** Request to retrieve the contextual alias for a context and ring. */\nexport interface HostAccountGetAliasRequest {\n /** Ring-VRF key handle naming the member key to use. */\n keyHandle: ProductAccountId;\n /** Product-scoped context to derive the alias for. */\n context: ProductProofContext;\n /** Ring whose member key the host should use; matches `create_proof`. */\n ringLocation: RingLocation;\n}\nexport const HostAccountGetAliasRequest: Codec;\n/** Error returned when credential/account requests fail. */\nexport type HostAccountGetError = \n/** User is not logged in. */\n{\n tag: \"NotConnected\";\n value?: undefined;\n}\n/** User or host rejected the request. */\n | {\n tag: \"Rejected\";\n value?: undefined;\n}\n/** Domain identifier is invalid. */\n | {\n tag: \"DomainNotValid\";\n value?: undefined;\n}\n/** Catch-all error with reason. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostAccountGetError: Codec;\n/** Request to retrieve a product-scoped account. */\nexport interface HostAccountGetRequest {\n /** Product account to retrieve. */\n productAccountId: ProductAccountId;\n}\nexport const HostAccountGetRequest: Codec;\n/** Response containing a product-scoped account. */\nexport interface HostAccountGetResponse {\n /** Retrieved product account. */\n account: ProductAccount;\n}\nexport const HostAccountGetResponse: Codec;\n/** Error returned when listing ring-VRF keys fails. */\nexport type HostAccountListRingVrfKeysError = \n/** User is not logged in. */\n{\n tag: \"NotConnected\";\n value?: undefined;\n}\n/** User or host rejected. */\n | {\n tag: \"Rejected\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostAccountListRingVrfKeysError: Codec;\n/** Request to list registered ring-VRF keys for an owner product. */\nexport interface HostAccountListRingVrfKeysRequest {\n /** Product whose registry entries should be listed. */\n owner: string;\n /** Disclosure level requested by the caller. */\n disclosure: RingVrfKeyDisclosure;\n}\nexport const HostAccountListRingVrfKeysRequest: Codec;\n/** Error returned when ring-VRF key registration fails. */\nexport type HostAccountRegisterRingVrfKeyError = \n/** User is not logged in. */\n{\n tag: \"NotConnected\";\n value?: undefined;\n}\n/** Ring not available at the specified location. */\n | {\n tag: \"RingNotFound\";\n value?: undefined;\n}\n/** User or host rejected. */\n | {\n tag: \"Rejected\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostAccountRegisterRingVrfKeyError: Codec;\n/** Request to register a ring-VRF key owned by the calling product. */\nexport interface HostAccountRegisterRingVrfKeyRequest {\n /** Key derivation index within the caller's ring-VRF domain. */\n index: DerivationIndex;\n /** Ring this key is declared for. */\n ring: RingLocation;\n}\nexport const HostAccountRegisterRingVrfKeyRequest: Codec;\n/** Error returned when direct ring-VRF key signing fails. */\nexport type HostAccountRingVrfSignError = \n/** User is not logged in. */\n{\n tag: \"NotConnected\";\n value?: undefined;\n}\n/** The key handle is not registered. */\n | {\n tag: \"KeyNotRegistered\";\n value?: undefined;\n}\n/** The foreign key owner has not allowlisted the caller. */\n | {\n tag: \"NotAllowlisted\";\n value?: undefined;\n}\n/** User or host rejected. */\n | {\n tag: \"Rejected\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostAccountRingVrfSignError: Codec;\n/** Request to sign bytes with a registered ring-VRF key. */\nexport interface HostAccountRingVrfSignRequest {\n /** Registered key handle. */\n keyHandle: ProductAccountId;\n /** Opaque message to sign. */\n message: HexString;\n}\nexport const HostAccountRingVrfSignRequest: Codec;\n/** Error returned when VRF signing fails. */\nexport type HostAccountSignVrfError = \n/** User is not logged in. */\n{\n tag: \"NotConnected\";\n value?: undefined;\n}\n/** User or host rejected the signing confirmation. */\n | {\n tag: \"Rejected\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostAccountSignVrfError: Codec;\n/**\n * Request to produce an sr25519 VRF signature from a product account over a\n * caller-supplied Merlin transcript.\n */\nexport interface HostAccountSignVrfRequest {\n /** Account whose key signs the VRF. */\n account: ProductAccountId;\n /** Root domain-separation label: `Transcript::new(transcript_label)`. */\n transcriptLabel: HexString;\n /** Transcript items replayed in order as `append_message(label, value)`. */\n items: Array;\n}\nexport const HostAccountSignVrfRequest: Codec;\n/** A chat action received from the host. */\nexport interface HostChatActionSubscribeItem {\n /** Room where the action occurred. */\n roomId: string;\n /** Peer who initiated the action. */\n peer: string;\n /** The action payload. */\n payload: ChatActionPayload;\n}\nexport const HostChatActionSubscribeItem: Codec;\n/** Chat room registration error. */\nexport type HostChatCreateRoomError = \n/** Not allowed. */\n{\n tag: \"PermissionDenied\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostChatCreateRoomError: Codec;\n/** Request to create a chat room. */\nexport interface HostChatCreateRoomRequest {\n /** Unique room identifier. */\n roomId: string;\n /** Room display name. */\n name: string;\n /** URL or base64 image. */\n icon: string;\n}\nexport const HostChatCreateRoomRequest: Codec;\n/** Result of a room registration. */\nexport interface HostChatCreateRoomResponse {\n /** `New` or `Exists`. */\n status: ChatRoomRegistrationStatus;\n}\nexport const HostChatCreateRoomResponse: Codec;\n/** Item containing the current chat rooms. */\nexport interface HostChatListSubscribeItem {\n /** Chat rooms the product participates in. */\n rooms: Array;\n}\nexport const HostChatListSubscribeItem: Codec;\n/** Chat message posting error. */\nexport type HostChatPostMessageError = \n/** Message exceeded size limit. */\n{\n tag: \"MessageTooLarge\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostChatPostMessageError: Codec;\n/** Request to post a message to a chat room. */\nexport interface HostChatPostMessageRequest {\n /** Room to post to. */\n roomId: string;\n /** Message content. */\n payload: ChatMessageContent;\n}\nexport const HostChatPostMessageRequest: Codec;\n/** Result of posting a message. */\nexport interface HostChatPostMessageResponse {\n /**\n * Host-assigned message id, and the correlation key for any action the\n * message carries: a trigger names it in [`ActionTrigger::message_id`].\n */\n messageId: string;\n}\nexport const HostChatPostMessageResponse: Codec;\n/** Chat bot registration error. */\nexport type HostChatRegisterBotError = \n/** Not allowed. */\n{\n tag: \"PermissionDenied\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostChatRegisterBotError: Codec;\n/** Request to register a chat bot. */\nexport interface HostChatRegisterBotRequest {\n /** Unique bot identifier. */\n botId: string;\n /** Bot display name. */\n name: string;\n /** URL or base64 image. */\n icon: string;\n}\nexport const HostChatRegisterBotRequest: Codec;\n/** Result of a bot registration. */\nexport interface HostChatRegisterBotResponse {\n /** `New` or `Exists`. */\n status: ChatBotRegistrationStatus;\n}\nexport const HostChatRegisterBotResponse: Codec;\n/** Request to create a cheque from a local purse to a receivable. */\nexport interface HostCoinPaymentCreateChequeRequest {\n /** Source purse. */\n from: CoinPaymentPurseId;\n /** Destination receivable. */\n to: CoinPaymentReceivable;\n /** Payment amount. */\n amount: CoinPaymentBalance;\n}\nexport const HostCoinPaymentCreateChequeRequest: Codec;\n/** Created cheque response. */\nexport interface HostCoinPaymentCreateChequeResponse {\n /** Encrypted cheque. */\n cheque: CoinPaymentCheque;\n}\nexport const HostCoinPaymentCreateChequeResponse: Codec;\n/** Request to create a new firewalled CoinPayment purse. */\nexport interface HostCoinPaymentCreatePurseRequest {\n /** Human-readable purse name. */\n name: string;\n}\nexport const HostCoinPaymentCreatePurseRequest: Codec;\n/** Created purse identifier. */\nexport interface HostCoinPaymentCreatePurseResponse {\n /** Assigned purse identifier. */\n purse: CoinPaymentPurseId;\n}\nexport const HostCoinPaymentCreatePurseResponse: Codec;\n/** Request to create a fresh receivable for a purse. */\nexport interface HostCoinPaymentCreateReceivableRequest {\n /** Target purse for future deposits. */\n into: CoinPaymentPurseId;\n}\nexport const HostCoinPaymentCreateReceivableRequest: Codec;\n/** Created receivable response. */\nexport interface HostCoinPaymentCreateReceivableResponse {\n /** Receivable public key. */\n receivable: CoinPaymentReceivable;\n}\nexport const HostCoinPaymentCreateReceivableResponse: Codec;\n/** Request to delete a purse after draining its balance. */\nexport interface HostCoinPaymentDeletePurseRequest {\n /** Purse to delete. */\n target: CoinPaymentPurseId;\n /** Purse that receives drained funds. */\n drainInto: CoinPaymentPurseId;\n}\nexport const HostCoinPaymentDeletePurseRequest: Codec;\n/** Request to deposit a cheque into the purse associated with its receivable. */\nexport interface HostCoinPaymentDepositRequest {\n /** Cheque to deposit. */\n cheque: CoinPaymentCheque;\n}\nexport const HostCoinPaymentDepositRequest: Codec;\n/** Stream item for `host_coin_payment_listen_for`. */\nexport type HostCoinPaymentListenForItem = \n/** Handoff channel suitable for inclusion in an invoice. */\n{\n tag: \"Channel\";\n value: CoinPaymentTransmissionChannel;\n}\n/** Cheque received through the handoff channel. */\n | {\n tag: \"Cheque\";\n value: CoinPaymentCheque;\n};\nexport const HostCoinPaymentListenForItem: Codec;\n/** Request to listen for a cheque delivered to a receivable. */\nexport interface HostCoinPaymentListenForRequest {\n /** Receivable to listen for. */\n receivable: CoinPaymentReceivable;\n}\nexport const HostCoinPaymentListenForRequest: Codec;\n/** Request to query product-visible purse metadata. */\nexport interface HostCoinPaymentQueryPurseRequest {\n /** Purse to query. */\n purse: CoinPaymentPurseId;\n}\nexport const HostCoinPaymentQueryPurseRequest: Codec;\n/** Product-visible purse metadata response. */\nexport interface HostCoinPaymentQueryPurseResponse {\n /** Purse information. */\n info: CoinPaymentPurseInfo;\n}\nexport const HostCoinPaymentQueryPurseResponse: Codec;\n/** Request to transfer balance between local purses. */\nexport interface HostCoinPaymentRebalancePurseRequest {\n /** Source purse. */\n from: CoinPaymentPurseId;\n /** Destination purse. */\n to: CoinPaymentPurseId;\n /** Amount to move. */\n amount: CoinPaymentBalance;\n}\nexport const HostCoinPaymentRebalancePurseRequest: Codec;\n/** Request to refund coins associated with a receivable. */\nexport interface HostCoinPaymentRefundRequest {\n /** Receivable to refund. */\n receivable: CoinPaymentReceivable;\n}\nexport const HostCoinPaymentRefundRequest: Codec;\n/** Transaction creation error. */\nexport type HostCreateTransactionError = \n/** Payload could not be deserialized. */\n{\n tag: \"FailedToDecode\";\n value?: undefined;\n}\n/** User rejected. */\n | {\n tag: \"Rejected\";\n value?: undefined;\n}\n/** Unsupported payload version or extension. */\n | {\n tag: \"NotSupported\";\n value: {\n reason: string;\n };\n}\n/** Not authenticated. */\n | {\n tag: \"PermissionDenied\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostCreateTransactionError: Codec;\n/** Response containing a created transaction. */\nexport interface HostCreateTransactionResponse {\n /**\n * SCALE-encoded transaction, signed unless the request supplied its own\n * V5 `VerifyMultiSignature` extension.\n */\n transaction: HexString;\n}\nexport const HostCreateTransactionResponse: Codec;\n/** Response containing a transaction created with a non-product account. */\nexport interface HostCreateTransactionWithLegacyAccountResponse {\n /**\n * SCALE-encoded transaction, signed unless the request supplied its own\n * V5 `VerifyMultiSignature` extension.\n */\n transaction: HexString;\n}\nexport const HostCreateTransactionWithLegacyAccountResponse: Codec;\n/** Error from [`crate::api::Entropy::derive`] (RFC 0007). */\nexport type HostDeriveEntropyError = \n/** Catch-all. */\n{\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostDeriveEntropyError: Codec;\n/**\n * Request to derive deterministic per-product entropy (RFC 0007).\n *\n * The host derives 32 bytes from product-scoped seed material and `context`.\n * Repeated calls with the same `context` for the same product yield the same\n * entropy.\n */\nexport interface HostDeriveEntropyRequest {\n /** Domain-separated derivation context. */\n context: HexString;\n}\nexport const HostDeriveEntropyRequest: Codec;\n/** Response carrying 32 bytes of deterministically derived entropy. */\nexport interface HostDeriveEntropyResponse {\n /** 32 bytes of derived entropy. */\n entropy: HexString;\n}\nexport const HostDeriveEntropyResponse: Codec;\n/**\n * Device-capability permission requested from the host (RFC 0002).\n *\n * Lasting grants and denials survive app restarts. A host may also offer a\n * one-use grant, held in memory until a permission-gated operation consumes it.\n *\n * That decision is about this product. The OS grant behind it belongs to the\n * host application and can move independently, so a host that can read OS\n * state has the capability resolve only while both allow it: a stored grant\n * whose OS grant was revoked answers `granted: false` without a prompt. An OS\n * grant that is merely undetermined does not change the answer, because the OS\n * resolves its own gate when the capability is used.\n */\nexport type HostDevicePermissionRequest = \"Notifications\" | \"Camera\" | \"Microphone\" | \"Bluetooth\" | \"NFC\" | \"Location\" | \"Clipboard\" | \"OpenUrl\" | \"Biometrics\";\nexport const HostDevicePermissionRequest: Codec;\n/** Outcome of a device-permission request. */\nexport interface HostDevicePermissionResponse {\n /** Whether the permission was granted. */\n granted: boolean;\n}\nexport const HostDevicePermissionResponse: Codec;\n/** Request to query whether a feature is supported by the host. */\nexport type HostFeatureSupportedRequest = \n/** Ask whether the host can interact with the chain identified by genesis hash. */\n{\n tag: \"Chain\";\n value: {\n genesisHash: HexString;\n };\n};\nexport const HostFeatureSupportedRequest: Codec;\n/** Response to a feature-support query. */\nexport interface HostFeatureSupportedResponse {\n /** Whether the feature is supported. */\n supported: boolean;\n}\nexport const HostFeatureSupportedResponse: Codec;\n/** Response containing all legacy (user-imported) accounts owned by the user. */\nexport interface HostGetLegacyAccountsResponse {\n /** Legacy accounts. */\n accounts: Array;\n}\nexport const HostGetLegacyAccountsResponse: Codec;\n/** Response containing the product context bound to the current host runtime. */\nexport interface HostGetProductContextResponse {\n /** Full canonical identifier used for authorization and account derivation. */\n productId: string;\n}\nexport const HostGetProductContextResponse: Codec;\n/** Error from [`crate::api::Account::get_user_id`]. */\nexport type HostGetUserIdError = \n/** User denied the identity disclosure request. */\n{\n tag: \"PermissionDenied\";\n value?: undefined;\n}\n/** User is not logged in. */\n | {\n tag: \"NotConnected\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostGetUserIdError: Codec;\n/** The user's primary DotNS account identity. */\nexport interface HostGetUserIdResponse {\n /** The user's primary DotNS username. */\n primaryUsername: string;\n}\nexport const HostGetUserIdResponse: Codec;\n/**\n * Error from [`crate::api::System::handshake`] (RFC 0009).\n *\n * The handshake is the first call on a fresh connection; it does not require\n * user authentication and is used to negotiate the wire codec version.\n */\nexport type HostHandshakeError = \n/** Host did not complete the handshake in time. */\n{\n tag: \"Timeout\";\n value?: undefined;\n}\n/** Host does not speak the codec version requested by the product. */\n | {\n tag: \"UnsupportedProtocolVersion\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: GenericError;\n};\nexport const HostHandshakeError: Codec;\n/** Wire-codec negotiation payload sent by the product (RFC 0009). */\nexport interface HostHandshakeRequest {\n /** Wire codec version requested by the product. */\n codecVersion: number;\n}\nexport const HostHandshakeRequest: Codec;\n/** A change to a subscribed storage key, pushed to the subscriber. */\nexport interface HostLocalStorageChangeItem {\n /** Value after the change. `Some` on write, `None` after clear. */\n value?: HexString;\n}\nexport const HostLocalStorageChangeItem: Codec;\n/** Request to clear a local storage key. */\nexport interface HostLocalStorageClearRequest {\n /** Storage key to clear. */\n key: string;\n}\nexport const HostLocalStorageClearRequest: Codec;\n/** Local storage operation error. */\nexport type V01HostLocalStorageReadError = \n/** Storage quota exceeded. */\n{\n tag: \"Full\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const V01HostLocalStorageReadError: Codec;\n/** Request to read a local storage value. */\nexport interface V01HostLocalStorageReadRequest {\n /** Storage key to read. */\n key: string;\n}\nexport const V01HostLocalStorageReadRequest: Codec;\n/** Response containing an optional local storage value. */\nexport interface HostLocalStorageReadResponse {\n /** Stored value, if present. */\n value?: HexString;\n}\nexport const HostLocalStorageReadResponse: Codec;\n/** Request to subscribe to changes of one local storage key. */\nexport interface HostLocalStorageSubscribeRequest {\n /** Storage key to observe. */\n key: string;\n}\nexport const HostLocalStorageSubscribeRequest: Codec;\n/** Request to write a value into local storage. */\nexport interface HostLocalStorageWriteRequest {\n /** Storage key to write. */\n key: string;\n /** Value to store at the key. */\n value: HexString;\n}\nexport const HostLocalStorageWriteRequest: Codec;\n/** Locale the host currently presents its interface in, pushed to subscribers. */\nexport interface HostLocaleSubscribeItem {\n /**\n * BCP 47 language tag, such as `en`, `pt-BR` or `zh-Hans`. The set is\n * open: a product that does not ship the tag chooses its own fallback.\n */\n languageTag: string;\n}\nexport const HostLocaleSubscribeItem: Codec;\n/** Error from [`crate::api::System::navigate_to`]. */\nexport type HostNavigateToError = \n/**\n * The target host is not authorized for outbound access: the user answered\n * no to the prompt, a stored decision already refused it, or no prompt\n * could be put to the user.\n */\n{\n tag: \"PermissionDenied\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostNavigateToError: Codec;\n/** Request to navigate the host to an external URL. */\nexport interface HostNavigateToRequest {\n /** URL to open. */\n url: string;\n}\nexport const HostNavigateToRequest: Codec;\n/**\n * Error from [`crate::api::Payment::balance_subscribe`].\n *\n * See [RFC 0006].\n *\n * [RFC 0006]: https://github.com/paritytech/triangle-js-sdks/pull/94\n */\nexport type HostPaymentBalanceSubscribeError = \n/** User denied the balance disclosure request. */\n{\n tag: \"PermissionDenied\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostPaymentBalanceSubscribeError: Codec;\n/**\n * Current payment balance state pushed to subscribers.\n *\n * See [RFC 0006].\n *\n * [RFC 0006]: https://github.com/paritytech/triangle-js-sdks/pull/94\n */\nexport interface HostPaymentBalanceSubscribeItem {\n /** Balance that can be spent right now. */\n available: Balance;\n}\nexport const HostPaymentBalanceSubscribeItem: Codec;\n/** Request to subscribe to payment balance updates. */\nexport interface HostPaymentBalanceSubscribeRequest {\n /** Optional purse selector. `None` means MAIN_PURSE. */\n purse?: CoinPaymentPurseId;\n}\nexport const HostPaymentBalanceSubscribeRequest: Codec;\n/**\n * Error from [`crate::api::Payment::request`].\n *\n * See [RFC 0006].\n *\n * [RFC 0006]: https://github.com/paritytech/triangle-js-sdks/pull/94\n */\nexport type HostPaymentError = \n/** User rejected the payment request. */\n{\n tag: \"Rejected\";\n value?: undefined;\n}\n/** User's available balance is not sufficient for the requested amount. */\n | {\n tag: \"InsufficientBalance\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostPaymentError: Codec;\n/** Request to initiate a payment to another account. */\nexport interface HostPaymentRequest {\n /** Optional purse selector. `None` means MAIN_PURSE. */\n from?: CoinPaymentPurseId;\n /** Amount to pay. */\n amount: Balance;\n /** Destination account. */\n destination: HexString;\n}\nexport const HostPaymentRequest: Codec;\n/**\n * Receipt returned after a successful payment request.\n *\n * See [RFC 0006].\n *\n * [RFC 0006]: https://github.com/paritytech/triangle-js-sdks/pull/94\n */\nexport interface HostPaymentResponse {\n /** The assigned payment identifier. */\n id: string;\n}\nexport const HostPaymentResponse: Codec;\n/**\n * Error from [`crate::api::Payment::status_subscribe`].\n *\n * See [RFC 0006].\n *\n * [RFC 0006]: https://github.com/paritytech/triangle-js-sdks/pull/94\n */\nexport type HostPaymentStatusSubscribeError = \n/** Payment ID was not found or does not belong to the current product. */\n{\n tag: \"PaymentNotFound\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostPaymentStatusSubscribeError: Codec;\n/**\n * Payment lifecycle status pushed to subscribers.\n *\n * Once a terminal state (`Completed` or `Failed`) is reached, the host\n * delivers it and may close the subscription.\n *\n * See [RFC 0006].\n *\n * [RFC 0006]: https://github.com/paritytech/triangle-js-sdks/pull/94\n */\nexport type HostPaymentStatusSubscribeItem = \n/** Payment is being processed. */\n{\n tag: \"Processing\";\n value?: undefined;\n}\n/** Payment has been settled successfully. */\n | {\n tag: \"Completed\";\n value?: undefined;\n}\n/** Payment has failed. */\n | {\n tag: \"Failed\";\n value: {\n reason: string;\n };\n};\nexport const HostPaymentStatusSubscribeItem: Codec;\n/** Request to subscribe to a payment status. */\nexport interface HostPaymentStatusSubscribeRequest {\n /** Payment identifier to watch. */\n paymentId: string;\n}\nexport const HostPaymentStatusSubscribeRequest: Codec;\n/**\n * Error from [`crate::api::Payment::top_up`].\n *\n * See [RFC 0006].\n *\n * [RFC 0006]: https://github.com/paritytech/triangle-js-sdks/pull/94\n */\nexport type HostPaymentTopUpError = \n/** The source account does not hold sufficient funds. */\n{\n tag: \"InsufficientFunds\";\n value?: undefined;\n}\n/** The source account was not found or is invalid. */\n | {\n tag: \"InvalidSource\";\n value?: undefined;\n}\n/** Some coins were claimed but the total fell short of the requested amount. */\n | {\n tag: \"PartialPayment\";\n value: {\n credited: Balance;\n };\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostPaymentTopUpError: Codec;\n/** Request to top up the product payment balance. */\nexport interface HostPaymentTopUpRequest {\n /** Optional purse selector. `None` means MAIN_PURSE. */\n into?: CoinPaymentPurseId;\n /** Amount to top up. */\n amount: Balance;\n /** Funding source for the top-up. */\n source: PaymentTopUpSource;\n}\nexport const HostPaymentTopUpRequest: Codec;\n/** The calling product's cards: the whole set on subscribe and after every change. */\nexport interface HostPocketListSubscribeItem {\n /** Cards currently in Pocket for the calling product. */\n cards: Array;\n}\nexport const HostPocketListSubscribeItem: Codec;\n/** Card removal failure. */\nexport type HostPocketRemoveCardError = \n/** The card is privileged and stays in Pocket. */\n{\n tag: \"Privileged\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostPocketRemoveCardError: Codec;\n/** Request to remove one of the calling product's cards. */\nexport interface HostPocketRemoveCardRequest {\n /** Card to remove. A card that is not present is already removed. */\n cardId: string;\n}\nexport const HostPocketRemoveCardRequest: Codec;\n/** Profile presentation failure. */\nexport type HostProfilePresentError = \n/** The reference is malformed or names a format this host cannot open. */\n{\n tag: \"InvalidReference\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostProfilePresentError: Codec;\n/**\n * Request to show a profile the calling product references in host-owned UI.\n *\n * The reference is a bearer capability: whoever holds it can read the profile\n * it names. The host resolves and renders it itself, so profile bytes, the\n * avatar image included, never reach the product.\n */\nexport interface HostProfilePresentRequest {\n /** Opaque profile reference, e.g. a Seity `#` blob reference. */\n reference: string;\n}\nexport const HostProfilePresentRequest: Codec;\n/** Request to cancel a previously scheduled notification. */\nexport interface HostPushNotificationCancelRequest {\n /** The notification identifier returned by [`HostPushNotificationResponse`]. */\n id: NotificationId;\n}\nexport const HostPushNotificationCancelRequest: Codec;\n/** Push notification error. */\nexport type HostPushNotificationError = \n/** The host-wide queue of pending scheduled notifications is full. */\n{\n tag: \"ScheduleLimitReached\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostPushNotificationError: Codec;\n/**\n * Push notification payload.\n *\n * When `scheduled_at` is `Some`, the notification is deferred to the given\n * wall-clock instant (Unix milliseconds UTC). `None` fires immediately,\n * preserving prior behaviour. See [RFC 0019].\n *\n * [RFC 0019]: https://github.com/paritytech/host-rust-core/blob/main/docs/rfcs/0019-scheduled-notifications.md\n */\nexport interface HostPushNotificationRequest {\n /** Notification text. */\n text: string;\n /** Optional URL to open on tap. */\n deeplink?: string;\n /**\n * Optional Unix timestamp in milliseconds (UTC) at which the notification\n * should fire. `None` fires immediately.\n */\n scheduledAt?: bigint;\n}\nexport const HostPushNotificationRequest: Codec;\n/** Successful push notification response carrying the assigned id. */\nexport interface HostPushNotificationResponse {\n /** Host-assigned notification identifier. */\n id: NotificationId;\n}\nexport const HostPushNotificationResponse: Codec;\n/** An action triggered inside a product-rendered body. */\nexport interface HostRendererActionSubscribeItem {\n /** Where the body lives. */\n context: RenderContext;\n /** Which action was triggered, as named in the renderer tree. */\n actionId: string;\n /**\n * Data the node attached to the action. A `Button` press carries an\n * empty payload; a `TextField` value change carries the UTF-8 bytes of\n * the new value, with no length prefix.\n */\n payload: HexString;\n}\nexport const HostRendererActionSubscribeItem: Codec;\n/** Login request error. */\nexport type HostRequestLoginError = \n/** Catch-all. */\n{\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostRequestLoginError: Codec;\n/** Request to present the host login flow. */\nexport interface HostRequestLoginRequest {\n /** Optional human-readable reason shown in the login UI. */\n reason?: string;\n}\nexport const HostRequestLoginRequest: Codec;\n/** Result of a login request. */\nexport type HostRequestLoginResponse = \"Success\" | \"AlreadyConnected\" | \"Rejected\";\nexport const HostRequestLoginResponse: Codec;\n/** Batched resource pre-allocation request (RFC 0010). */\nexport interface HostRequestResourceAllocationRequest {\n /** Resources to allocate. */\n resources: Array;\n}\nexport const HostRequestResourceAllocationRequest: Codec;\n/** Per-resource outcomes for a batched allocation request (RFC 0010). */\nexport interface HostRequestResourceAllocationResponse {\n /** Per-resource allocation outcomes, in the same order as the request. */\n outcomes: Array;\n}\nexport const HostRequestResourceAllocationResponse: Codec;\n/** Signing operation error. */\nexport type HostSignPayloadError = \n/** Payload could not be deserialized. */\n{\n tag: \"FailedToDecode\";\n value?: undefined;\n}\n/** User rejected signing. */\n | {\n tag: \"Rejected\";\n value?: undefined;\n}\n/** Not authenticated. */\n | {\n tag: \"PermissionDenied\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostSignPayloadError: Codec;\n/** Request to sign an extrinsic payload with a product account. */\nexport interface HostSignPayloadRequest {\n /** Product account that will sign this payload. */\n account: ProductAccountId;\n /** The extrinsic payload to sign. */\n payload: HostSignPayloadData;\n}\nexport const HostSignPayloadRequest: Codec;\n/** Result of a signing operation. */\nexport interface HostSignPayloadResponse {\n /** The cryptographic signature. */\n signature: HexString;\n /** Full signed transaction, if requested. */\n signedTransaction?: HexString;\n}\nexport const HostSignPayloadResponse: Codec;\n/**\n * Sign a Substrate extrinsic payload with a non-product (legacy) account.\n * Contains the same fields as [`HostSignPayloadRequest`] minus `address`\n * (replaced by `signer`).\n */\nexport interface HostSignPayloadWithLegacyAccountRequest {\n /** Signer address (SS58 or hex) of the legacy account. */\n signer: string;\n /** The extrinsic payload to sign. */\n payload: HostSignPayloadData;\n}\nexport const HostSignPayloadWithLegacyAccountRequest: Codec;\n/** A raw signing request pairing an account with the payload to sign. */\nexport interface HostSignRawRequest {\n /** Product account that will sign this payload. */\n account: ProductAccountId;\n /** The payload to sign. */\n payload: RawPayload;\n}\nexport const HostSignRawRequest: Codec;\n/**\n * Sign raw bytes with a non-product (legacy) account. The signer field\n * identifies which legacy account to use.\n */\nexport interface HostSignRawWithLegacyAccountRequest {\n /** Signer address (SS58 or hex) of the legacy account. */\n signer: string;\n /** The data to sign. */\n payload: RawPayload;\n}\nexport const HostSignRawWithLegacyAccountRequest: Codec;\n/** Current theme state pushed to subscribers. */\nexport interface HostThemeSubscribeItem {\n /** Theme name. */\n name: ThemeName;\n /** Light or dark variant. */\n variant: ThemeVariant;\n}\nexport const HostThemeSubscribeItem: Codec;\n/** Request to begin a pending operation. */\nexport interface HostWorkerBeginOperationRequest {\n /** Optional label for host logs and UI. */\n label?: string;\n}\nexport const HostWorkerBeginOperationRequest: Codec;\n/** Response carrying the id of a newly begun operation. */\nexport interface HostWorkerBeginOperationResponse {\n /** Id to pass to `end_operation`. */\n id: OperationId;\n}\nexport const HostWorkerBeginOperationResponse: Codec;\n/** Request to end a pending operation. */\nexport interface HostWorkerEndOperationRequest {\n /** Id returned by `begin_operation`. */\n id: OperationId;\n}\nexport const HostWorkerEndOperationRequest: Codec;\n/** A body the host needs drawn. */\nexport interface ProductRendererRenderRequest {\n /** Where the body lives. */\n context: RenderContext;\n /** Product-defined payload, opaque to the host. */\n payload: HexString;\n}\nexport const ProductRendererRenderRequest: Codec;\n/** Request to fetch the body of a pinned block. */\nexport interface RemoteChainHeadBodyRequest {\n /** Chain genesis hash. */\n genesisHash: HexString;\n /** Follow subscription identifier. */\n followSubscriptionId: string;\n /** Block hash. */\n hash: HexString;\n}\nexport const RemoteChainHeadBodyRequest: Codec;\n/** Response to a body request; results arrive as follow events. */\nexport interface RemoteChainHeadBodyResponse {\n /** Started operation result. */\n operation: OperationStartedResult;\n}\nexport const RemoteChainHeadBodyResponse: Codec;\n/** Request to invoke a runtime call at a pinned block. */\nexport interface RemoteChainHeadCallRequest {\n /** Chain genesis hash. */\n genesisHash: HexString;\n /** Follow subscription identifier. */\n followSubscriptionId: string;\n /** Block hash. */\n hash: HexString;\n /** Runtime API function name. */\n function: string;\n /** SCALE-encoded call parameters. */\n callParameters: HexString;\n}\nexport const RemoteChainHeadCallRequest: Codec;\n/** Response to a runtime call request; the output arrives as a follow event. */\nexport interface RemoteChainHeadCallResponse {\n /** Started operation result. */\n operation: OperationStartedResult;\n}\nexport const RemoteChainHeadCallResponse: Codec;\n/** Request to continue a paused chain-head operation. */\nexport interface RemoteChainHeadContinueRequest {\n /** Chain genesis hash. */\n genesisHash: HexString;\n /** Follow subscription identifier. */\n followSubscriptionId: string;\n /** Operation identifier. */\n operationId: string;\n}\nexport const RemoteChainHeadContinueRequest: Codec;\n/** Event emitted on a chain-head follow subscription. */\nexport type RemoteChainHeadFollowItem = \n/** First event of the subscription, describing the current finalized blocks. */\n{\n tag: \"Initialized\";\n value: {\n finalizedBlockHashes: Array;\n finalizedBlockRuntime?: RuntimeType;\n };\n}\n/** A new non-finalized block was announced. */\n | {\n tag: \"NewBlock\";\n value: {\n blockHash: HexString;\n parentBlockHash: HexString;\n newRuntime?: RuntimeType;\n };\n}\n/** The best block has changed. */\n | {\n tag: \"BestBlockChanged\";\n value: {\n bestBlockHash: HexString;\n };\n}\n/** One or more blocks were finalized. */\n | {\n tag: \"Finalized\";\n value: {\n finalizedBlockHashes: Array;\n prunedBlockHashes: Array;\n };\n}\n/** A body operation completed. */\n | {\n tag: \"OperationBodyDone\";\n value: {\n operationId: string;\n value: Array;\n };\n}\n/** A runtime call operation completed. */\n | {\n tag: \"OperationCallDone\";\n value: {\n operationId: string;\n output: HexString;\n };\n}\n/** A storage operation produced a batch of results. */\n | {\n tag: \"OperationStorageItems\";\n value: {\n operationId: string;\n items: Array;\n };\n}\n/** A storage operation finished emitting results. */\n | {\n tag: \"OperationStorageDone\";\n value: {\n operationId: string;\n };\n}\n/** A storage operation is paused until the product requests continuation. */\n | {\n tag: \"OperationWaitingForContinue\";\n value: {\n operationId: string;\n };\n}\n/** The operation failed because the required data was not accessible; it can be retried. */\n | {\n tag: \"OperationInaccessible\";\n value: {\n operationId: string;\n };\n}\n/** The operation failed with an error. */\n | {\n tag: \"OperationError\";\n value: {\n operationId: string;\n error: string;\n };\n}\n/** The subscription was stopped by the host and is no longer valid. */\n | {\n tag: \"Stop\";\n value?: undefined;\n};\nexport const RemoteChainHeadFollowItem: Codec;\n/** Request to start a chain-head follow subscription. */\nexport interface RemoteChainHeadFollowRequest {\n /** Chain genesis hash. */\n genesisHash: HexString;\n /** Whether to include runtime information in events. */\n withRuntime: boolean;\n}\nexport const RemoteChainHeadFollowRequest: Codec;\n/** Request to fetch the header of a pinned block. */\nexport interface RemoteChainHeadHeaderRequest {\n /** Chain genesis hash. */\n genesisHash: HexString;\n /** Follow subscription identifier. */\n followSubscriptionId: string;\n /** Block hash. */\n hash: HexString;\n}\nexport const RemoteChainHeadHeaderRequest: Codec;\n/** Response containing the requested block header. */\nexport interface RemoteChainHeadHeaderResponse {\n /** SCALE-encoded block header. */\n header?: HexString;\n}\nexport const RemoteChainHeadHeaderResponse: Codec;\n/** Request to stop an in-progress chain-head operation. */\nexport interface RemoteChainHeadStopOperationRequest {\n /** Chain genesis hash. */\n genesisHash: HexString;\n /** Follow subscription identifier. */\n followSubscriptionId: string;\n /** Operation identifier. */\n operationId: string;\n}\nexport const RemoteChainHeadStopOperationRequest: Codec;\n/** Request to query storage at a pinned block. */\nexport interface RemoteChainHeadStorageRequest {\n /** Chain genesis hash. */\n genesisHash: HexString;\n /** Follow subscription identifier. */\n followSubscriptionId: string;\n /** Block hash. */\n hash: HexString;\n /** Storage items to query. */\n items: Array;\n /** Optional child trie. */\n childTrie?: HexString;\n}\nexport const RemoteChainHeadStorageRequest: Codec;\n/** Response to a storage request; results arrive as follow events. */\nexport interface RemoteChainHeadStorageResponse {\n /** Started operation result. */\n operation: OperationStartedResult;\n}\nexport const RemoteChainHeadStorageResponse: Codec;\n/** Request to release pinned blocks. */\nexport interface RemoteChainHeadUnpinRequest {\n /** Chain genesis hash. */\n genesisHash: HexString;\n /** Follow subscription identifier. */\n followSubscriptionId: string;\n /** Block hashes to unpin. */\n hashes: Array;\n}\nexport const RemoteChainHeadUnpinRequest: Codec;\n/** Error from [`crate::api::Chain::get_chain_info`]. */\nexport type RemoteChainInfoError = \n/** The host does not serve the requested chain. */\n{\n tag: \"NotSupported\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: GenericError;\n};\nexport const RemoteChainInfoError: Codec;\n/** Request to resolve one chain identifier against the host's environment. */\nexport interface RemoteChainInfoRequest {\n /** Chain to resolve. */\n chain: ChainIdentifier;\n}\nexport const RemoteChainInfoRequest: Codec;\n/** Response carrying the resolved chain data. */\nexport interface RemoteChainInfoResponse {\n /** Ecosystem the host is configured for, e.g. \"polkadot\", \"kusama\", \"paseo\". */\n network: string;\n /** Chain this response resolves, echoed from the request. */\n chain: ChainIdentifier;\n /** Genesis hash identifying the chain in all chain-scoped calls. */\n genesisHash: HexString;\n}\nexport const RemoteChainInfoResponse: Codec;\n/** Request for the display name of a chain. */\nexport interface RemoteChainSpecChainNameRequest {\n /** Chain genesis hash. */\n genesisHash: HexString;\n}\nexport const RemoteChainSpecChainNameRequest: Codec;\n/** Response containing the chain display name. */\nexport interface RemoteChainSpecChainNameResponse {\n /** Chain display name. */\n chainName: string;\n}\nexport const RemoteChainSpecChainNameResponse: Codec;\n/** Request for the canonical genesis hash of a chain. */\nexport interface RemoteChainSpecGenesisHashRequest {\n /** Chain genesis hash requested by the product. */\n genesisHash: HexString;\n}\nexport const RemoteChainSpecGenesisHashRequest: Codec;\n/** Response containing the canonical genesis hash. */\nexport interface RemoteChainSpecGenesisHashResponse {\n /** Chain genesis hash. */\n genesisHash: HexString;\n}\nexport const RemoteChainSpecGenesisHashResponse: Codec;\n/** Request for the JSON-encoded properties of a chain. */\nexport interface RemoteChainSpecPropertiesRequest {\n /** Chain genesis hash. */\n genesisHash: HexString;\n}\nexport const RemoteChainSpecPropertiesRequest: Codec;\n/** Response containing the chain properties. */\nexport interface RemoteChainSpecPropertiesResponse {\n /** JSON-encoded properties. */\n properties: string;\n}\nexport const RemoteChainSpecPropertiesResponse: Codec;\n/** Request to broadcast a signed transaction. */\nexport interface RemoteChainTransactionBroadcastRequest {\n /** Chain genesis hash. */\n genesisHash: HexString;\n /** Signed transaction bytes. */\n transaction: HexString;\n}\nexport const RemoteChainTransactionBroadcastRequest: Codec;\n/** Response to a transaction broadcast request. */\nexport interface RemoteChainTransactionBroadcastResponse {\n /** Broadcast operation identifier, if available. */\n operationId?: string;\n}\nexport const RemoteChainTransactionBroadcastResponse: Codec;\n/** Request to stop broadcasting a transaction. */\nexport interface RemoteChainTransactionStopRequest {\n /** Chain genesis hash. */\n genesisHash: HexString;\n /** Operation identifier of the broadcast to stop. */\n operationId: string;\n}\nexport const RemoteChainTransactionStopRequest: Codec;\n/** remote-permission request (RFC 0002). */\nexport interface RemotePermissionRequest {\n /** Permission requested by the product. */\n permission: RemotePermission;\n}\nexport const RemotePermissionRequest: Codec;\n/** Outcome of a remote-permission request. */\nexport interface RemotePermissionResponse {\n /** Whether the permission was granted. */\n granted: boolean;\n}\nexport const RemotePermissionResponse: Codec;\n/** Item containing an optional preimage lookup result. */\nexport interface RemotePreimageLookupSubscribeItem {\n /** Preimage data, if found. */\n value?: HexString;\n}\nexport const RemotePreimageLookupSubscribeItem: Codec;\n/** Request to subscribe to preimage lookup results. */\nexport interface RemotePreimageLookupSubscribeRequest {\n /** Hash of the preimage. */\n key: HexString;\n}\nexport const RemotePreimageLookupSubscribeRequest: Codec;\n/** Statement proof creation error. */\nexport type RemoteStatementStoreCreateProofError = \n/** Signing operation failed. */\n{\n tag: \"UnableToSign\";\n value?: undefined;\n}\n/** Account not recognized. */\n | {\n tag: \"UnknownAccount\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const RemoteStatementStoreCreateProofError: Codec;\n/** Request to create a cryptographic proof for a statement. */\nexport interface RemoteStatementStoreCreateProofRequest {\n /** Product account that should create the proof. */\n productAccountId: ProductAccountId;\n /** Statement to prove. */\n statement: Statement;\n}\nexport const RemoteStatementStoreCreateProofRequest: Codec;\n/** Response containing a statement proof. */\nexport interface RemoteStatementStoreCreateProofResponse {\n /** Created statement proof. */\n proof: StatementProof;\n}\nexport const RemoteStatementStoreCreateProofResponse: Codec;\n/**\n * Page of signed statements delivered by the statement store subscription\n * (RFC 0008). The `is_complete` flag distinguishes the historical-dump phase\n * (`false`) from the live-update phase (`true`).\n */\nexport interface RemoteStatementStoreSubscribeItem {\n /** Signed statements matching the subscription. */\n statements: Array;\n /**\n * `false` while the host is still streaming the historical dump (more\n * pages to follow). `true` once the dump is complete; all subsequent\n * pages are also `true` and carry only newly-arrived statements.\n */\n isComplete: boolean;\n}\nexport const RemoteStatementStoreSubscribeItem: Codec;\n/** Request to subscribe to statements via a topic filter (RFC 0008). */\nexport type RemoteStatementStoreSubscribeRequest = \n/** AND: statement must contain every listed topic. */\n{\n tag: \"MatchAll\";\n value: Array;\n}\n/** OR: statement must contain at least one listed topic. */\n | {\n tag: \"MatchAny\";\n value: Array;\n};\nexport const RemoteStatementStoreSubscribeRequest: Codec;\n/** Local storage read failure. */\nexport type HostLocalStorageReadError = \n/** Storage quota exceeded. */\n{\n tag: \"Full\";\n value?: undefined;\n}\n/**\n * The addressed storage belongs to another product that has not granted\n * this caller the `storage` scope.\n *\n * One variant answers every reason: the product does not resolve, it\n * published no manifest, or its manifest grants this caller nothing.\n * Distinguishing them would make the call a probe for which products exist\n * and which hold data.\n */\n | {\n tag: \"AccessNotGranted\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostLocalStorageReadError: Codec;\n/**\n * Request to read a local storage value.\n *\n * Storage is private by default: `product: None` addresses the caller's own\n * storage, which is what every v0.1 read resolved to. Naming another product\n * reads that product's storage instead, and succeeds only if that product's\n * manifest grants this caller the `storage` scope.\n */\nexport interface HostLocalStorageReadRequest {\n /**\n * Product whose storage is read. `None`, or the caller's own id, means the\n * caller, and consults no grant.\n */\n product?: string;\n /** Storage key to read. */\n key: string;\n}\nexport const HostLocalStorageReadRequest: Codec;\n/** Failure of a Host-owned Chat operation before a public update is available. */\nexport type HostProductDeviceChatError = \"NotConnected\" | \"AccessNotGranted\" | \"UserRejected\" | \"AllowanceRequired\" | \"PeerNotReady\" | \"OperationConflict\" | \"InvalidRequest\" | \"InvalidStatement\" | \"RecipientNotFound\" | \"InsufficientBalance\" | \"StorageUnavailable\" | \"NetworkUnavailable\" | \"OperationNotFound\" | \"AttachmentsUnavailable\";\nexport const HostProductDeviceChatError: Codec;\n/** An operation on the calling product's Host-owned native Chat device. */\nexport type V02HostProductDeviceChatRequest = \n/** Restore the installation's public device and durable conversation state. */\n{\n tag: \"Initialize\";\n value?: undefined;\n}\n/** Resolve a username in the configured network and send a fresh invitation. */\n | {\n tag: \"Invite\";\n value: {\n username: string;\n text: string;\n };\n}\n/** Authenticate, decrypt and durably process a native statement. */\n | {\n tag: \"Receive\";\n value: {\n statement: SignedStatement;\n };\n}\n/** Accept an invitation previously authenticated and retained by the Host. */\n | {\n tag: \"AcceptInvitation\";\n value: {\n invitationId: HexString;\n };\n}\n/** Reject an invitation previously authenticated and retained by the Host. */\n | {\n tag: \"RejectInvitation\";\n value: {\n invitationId: HexString;\n };\n}\n/** Send ordinary messages to an established, Host-authenticated peer roster. */\n | {\n tag: \"Send\";\n value: {\n peerIdentity: HexString;\n requestId: string;\n messages: Array;\n };\n}\n/** Propose one main-purse payment; this operation always requires Host review. */\n | {\n tag: \"SendPayment\";\n value: {\n peerIdentity: HexString;\n requestId: string;\n amountCents: bigint;\n };\n}\n/** Read a payment's durable status without authorizing another spend. */\n | {\n tag: \"PaymentStatus\";\n value: {\n operationId: HexString;\n };\n}\n/** Resume durable transport work and return newly available public views. */\n | {\n tag: \"Reconcile\";\n value?: undefined;\n}\n/** Select immutable files in trusted Host UI and send native rich content. */\n | {\n tag: \"SendAttachments\";\n value: {\n peerIdentity: HexString;\n requestId: string;\n text?: string;\n };\n}\n/** Resume a private download and present or export through trusted Host UI. */\n | {\n tag: \"OpenAttachment\";\n value: {\n attachmentId: HexString;\n };\n};\nexport const V02HostProductDeviceChatRequest: Codec;\n/** Public updates from a Host-owned Chat operation. */\nexport interface V02HostProductDeviceChatResponse {\n /** Public local device metadata, including its allowance account. */\n device: HostNativeChatDevice;\n /** Current authenticated peers and subscription channels. */\n peers: Array;\n /** Invitations still awaiting a user decision. */\n invitations: Array;\n /** Newly processed safe ordinary messages. */\n messages: Array;\n /** Newly processed native delivery acknowledgments. */\n acknowledgments: Array;\n /** Current public payment statuses belonging to the calling product. */\n payments: Array;\n /** Safe rich-content views and their current private-transfer progress. */\n richMessages: Array;\n}\nexport const V02HostProductDeviceChatResponse: Codec;\n/** An operation using the calling product's non-exportable Host Chat device. */\nexport type HostProductDeviceChatRequest = \n/** Restore public metadata, pending ciphertext, and private file-transfer progress. */\n{\n tag: \"Initialize\";\n value?: undefined;\n}\n/** Independently resolve and bind a peer on the trusted network. */\n | {\n tag: \"Bind\";\n value: {\n username: string;\n };\n}\n/** Validate native plaintext and return signed ciphertext for product delivery. */\n | {\n tag: \"Prepare\";\n value: {\n peerIdentity: HexString;\n route: HostNativeChatRoute;\n plaintext: HexString;\n };\n}\n/** Authenticate and decrypt a complete external native statement, never own output. */\n | {\n tag: \"Open\";\n value: {\n statement: SignedStatement;\n };\n}\n/** Propose one main-purse payment; this operation requires trusted Host review. */\n | {\n tag: \"SendPayment\";\n value: {\n peerIdentity: HexString;\n requestId: string;\n amountCents: bigint;\n };\n}\n/** Read durable payment status without authorizing another spend. */\n | {\n tag: \"PaymentStatus\";\n value: {\n operationId: HexString;\n };\n}\n/** Reconcile payment custody and return opaque statements for product delivery. */\n | {\n tag: \"ReconcilePayments\";\n value?: undefined;\n}\n/** Select files in trusted Host UI and prepare native rich content without delivery. */\n | {\n tag: \"PrepareAttachments\";\n value: {\n peerIdentity: HexString;\n requestId: string;\n text?: string;\n };\n}\n/** Resume a private download and present or export through trusted Host UI. */\n | {\n tag: \"OpenAttachment\";\n value: {\n attachmentId: HexString;\n };\n}\n/** Acknowledge durable product storage of the legacy view and ordinary ciphertext. */\n | {\n tag: \"CommitMigration\";\n value: {\n migrationId: HexString;\n };\n}\n/** Continue a Host-authenticated incoming batch without supplying new ciphertext. */\n | {\n tag: \"ContinueOpen\";\n value: {\n openId: HexString;\n cursor: number;\n };\n}\n/** Continue a bounded snapshot of custody metadata and pending prepared statements. */\n | {\n tag: \"ContinueState\";\n value: {\n stateId: HexString;\n cursor: number;\n };\n}\n/** Read configured raw chain units per native Coinage cent, without spending. */\n | {\n tag: \"PaymentDenomination\";\n value?: undefined;\n};\nexport const HostProductDeviceChatRequest: Codec;\n/** Cryptographic results and custody metadata; products drive delivery and import. */\nexport interface HostProductDeviceChatResponse {\n /** Public local device metadata, including its allowance account. */\n device: HostNativeChatDevice;\n /** Host-authenticated peer and device metadata. */\n peers: Array;\n /** Newly resolved peer binding, when requested. */\n binding?: HostNativeChatBinding;\n /** Authenticated incoming plaintext; incoming payment import is product-owned. */\n opened: Array;\n /** Signed ciphertext for product submission and exact-identity retries. */\n prepared: Array;\n /** Durable public payment status, never outgoing bearer secrets. */\n payments: Array;\n /** Rich-content metadata and trusted private-transfer progress. */\n richMessages: Array;\n /** Legacy public view retained until the product durably commits migration. */\n migration?: V02HostProductDeviceChatResponse;\n /** Snapshot identifier to acknowledge only after persisting its view and ciphertext. */\n migrationId?: HexString;\n /** Continuation of an authenticated incoming batch, when opening is paginated. */\n openPage?: HostNativeChatOpenPage;\n /** Native request identities for invitations in the legacy migration view. */\n migrationInvitations: Array;\n /** Continuation of a bounded public state snapshot, when metadata is paginated. */\n statePage?: HostNativeChatStatePage;\n /**\n * Configured raw chain units per native Coinage cent, only when requested.\n * This is positive denomination metadata, never a balance or fiat price.\n */\n coinageCentsUnit?: bigint;\n}\nexport const HostProductDeviceChatResponse: Codec;\n/** Cross-axis alignment of `Row` children. */\nexport type VerticalAlignment = \"Top\" | \"Center\" | \"Bottom\";\nexport const VerticalAlignment: Codec;\n/** An sr25519 (schnorrkel) VRF signature: the VRF pre-output and its proof. */\nexport interface VrfSignature {\n /** schnorrkel `VRFPreOut` \u2014 the 32-byte VRF output point. */\n preOutput: HexString;\n /** schnorrkel `VRFProof` \u2014 the 64-byte DLEQ proof. */\n proof: HexString;\n}\nexport const VrfSignature: Codec;\n/** One `append_message` call replayed against the signing transcript. */\nexport interface VrfTranscriptItem {\n /** Merlin `append_message` label. */\n label: HexString;\n /** Merlin `append_message` value. */\n value: HexString;\n}\nexport const VrfTranscriptItem: Codec;\n\n}\n\n\n// re-export namespace T at module top level (mirrors index.d.ts `export *`)\n\nexport import AccountId = T.AccountId;\nexport import ActionTrigger = T.ActionTrigger;\nexport import AllocatableResource = T.AllocatableResource;\nexport import AllocationOutcome = T.AllocationOutcome;\nexport import Arrangement = T.Arrangement;\nexport import Background = T.Background;\nexport import Balance = T.Balance;\nexport import BlendingMode = T.BlendingMode;\nexport import BorderStyle = T.BorderStyle;\nexport import BoxProps = T.BoxProps;\nexport import ButtonProps = T.ButtonProps;\nexport import ButtonVariant = T.ButtonVariant;\nexport import Bytes32 = T.Bytes32;\nexport import ChainIdentifier = T.ChainIdentifier;\nexport import ChatAction = T.ChatAction;\nexport import ChatActionLayout = T.ChatActionLayout;\nexport import ChatActionPayload = T.ChatActionPayload;\nexport import ChatActions = T.ChatActions;\nexport import ChatBotRegistrationStatus = T.ChatBotRegistrationStatus;\nexport import ChatCommand = T.ChatCommand;\nexport import ChatCustomMessage = T.ChatCustomMessage;\nexport import ChatFile = T.ChatFile;\nexport import ChatMedia = T.ChatMedia;\nexport import ChatMessageContent = T.ChatMessageContent;\nexport import ChatReaction = T.ChatReaction;\nexport import ChatRichText = T.ChatRichText;\nexport import ChatRoom = T.ChatRoom;\nexport import ChatRoomParticipation = T.ChatRoomParticipation;\nexport import ChatRoomRegistrationStatus = T.ChatRoomRegistrationStatus;\nexport import CoinPaymentBalance = T.CoinPaymentBalance;\nexport import CoinPaymentCheque = T.CoinPaymentCheque;\nexport import CoinPaymentClearingReference = T.CoinPaymentClearingReference;\nexport import CoinPaymentCoinagePubKey = T.CoinPaymentCoinagePubKey;\nexport import CoinPaymentError = T.CoinPaymentError;\nexport import CoinPaymentMerkleRoot = T.CoinPaymentMerkleRoot;\nexport import CoinPaymentProductId = T.CoinPaymentProductId;\nexport import CoinPaymentPurseId = T.CoinPaymentPurseId;\nexport import CoinPaymentPurseInfo = T.CoinPaymentPurseInfo;\nexport import CoinPaymentReceivable = T.CoinPaymentReceivable;\nexport import CoinPaymentStatus = T.CoinPaymentStatus;\nexport import CoinPaymentTimestamp = T.CoinPaymentTimestamp;\nexport import CoinPaymentTransactionHash = T.CoinPaymentTransactionHash;\nexport import CoinPaymentTransmissionChannel = T.CoinPaymentTransmissionChannel;\nexport import ColorToken = T.ColorToken;\nexport import ColumnProps = T.ColumnProps;\nexport import ContentAlignment = T.ContentAlignment;\nexport import ContextualAlias = T.ContextualAlias;\nexport import DerivationIndex = T.DerivationIndex;\nexport import Dimensions = T.Dimensions;\nexport import Effect = T.Effect;\nexport import EffectProps = T.EffectProps;\nexport import GenericError = T.GenericError;\nexport import GenesisHash = T.GenesisHash;\nexport import HorizontalAlignment = T.HorizontalAlignment;\nexport import VersionedHostAccountConnectionStatusSubscribeError = T.VersionedHostAccountConnectionStatusSubscribeError;\nexport import VersionedHostAccountConnectionStatusSubscribeItem = T.VersionedHostAccountConnectionStatusSubscribeItem;\nexport import VersionedHostAccountConnectionStatusSubscribeRequest = T.VersionedHostAccountConnectionStatusSubscribeRequest;\nexport import VersionedHostAccountCreateProofError = T.VersionedHostAccountCreateProofError;\nexport import VersionedHostAccountCreateProofRequest = T.VersionedHostAccountCreateProofRequest;\nexport import VersionedHostAccountCreateProofResponse = T.VersionedHostAccountCreateProofResponse;\nexport import VersionedHostAccountGetAliasError = T.VersionedHostAccountGetAliasError;\nexport import VersionedHostAccountGetAliasRequest = T.VersionedHostAccountGetAliasRequest;\nexport import VersionedHostAccountGetAliasResponse = T.VersionedHostAccountGetAliasResponse;\nexport import VersionedHostAccountGetError = T.VersionedHostAccountGetError;\nexport import VersionedHostAccountGetRequest = T.VersionedHostAccountGetRequest;\nexport import VersionedHostAccountGetResponse = T.VersionedHostAccountGetResponse;\nexport import VersionedHostAccountListRingVrfKeysError = T.VersionedHostAccountListRingVrfKeysError;\nexport import VersionedHostAccountListRingVrfKeysRequest = T.VersionedHostAccountListRingVrfKeysRequest;\nexport import VersionedHostAccountListRingVrfKeysResponse = T.VersionedHostAccountListRingVrfKeysResponse;\nexport import VersionedHostAccountRegisterRingVrfKeyError = T.VersionedHostAccountRegisterRingVrfKeyError;\nexport import VersionedHostAccountRegisterRingVrfKeyRequest = T.VersionedHostAccountRegisterRingVrfKeyRequest;\nexport import VersionedHostAccountRegisterRingVrfKeyResponse = T.VersionedHostAccountRegisterRingVrfKeyResponse;\nexport import VersionedHostAccountRingVrfSignError = T.VersionedHostAccountRingVrfSignError;\nexport import VersionedHostAccountRingVrfSignRequest = T.VersionedHostAccountRingVrfSignRequest;\nexport import VersionedHostAccountRingVrfSignResponse = T.VersionedHostAccountRingVrfSignResponse;\nexport import VersionedHostAccountSignVrfError = T.VersionedHostAccountSignVrfError;\nexport import VersionedHostAccountSignVrfRequest = T.VersionedHostAccountSignVrfRequest;\nexport import VersionedHostAccountSignVrfResponse = T.VersionedHostAccountSignVrfResponse;\nexport import VersionedHostChatActionSubscribeError = T.VersionedHostChatActionSubscribeError;\nexport import VersionedHostChatActionSubscribeItem = T.VersionedHostChatActionSubscribeItem;\nexport import VersionedHostChatActionSubscribeRequest = T.VersionedHostChatActionSubscribeRequest;\nexport import VersionedHostChatCreateRoomError = T.VersionedHostChatCreateRoomError;\nexport import VersionedHostChatCreateRoomRequest = T.VersionedHostChatCreateRoomRequest;\nexport import VersionedHostChatCreateRoomResponse = T.VersionedHostChatCreateRoomResponse;\nexport import VersionedHostChatListSubscribeError = T.VersionedHostChatListSubscribeError;\nexport import VersionedHostChatListSubscribeItem = T.VersionedHostChatListSubscribeItem;\nexport import VersionedHostChatListSubscribeRequest = T.VersionedHostChatListSubscribeRequest;\nexport import VersionedHostChatPostMessageError = T.VersionedHostChatPostMessageError;\nexport import VersionedHostChatPostMessageRequest = T.VersionedHostChatPostMessageRequest;\nexport import VersionedHostChatPostMessageResponse = T.VersionedHostChatPostMessageResponse;\nexport import VersionedHostChatRegisterBotError = T.VersionedHostChatRegisterBotError;\nexport import VersionedHostChatRegisterBotRequest = T.VersionedHostChatRegisterBotRequest;\nexport import VersionedHostChatRegisterBotResponse = T.VersionedHostChatRegisterBotResponse;\nexport import VersionedHostCoinPaymentCreateChequeError = T.VersionedHostCoinPaymentCreateChequeError;\nexport import VersionedHostCoinPaymentCreateChequeRequest = T.VersionedHostCoinPaymentCreateChequeRequest;\nexport import VersionedHostCoinPaymentCreateChequeResponse = T.VersionedHostCoinPaymentCreateChequeResponse;\nexport import VersionedHostCoinPaymentCreatePurseError = T.VersionedHostCoinPaymentCreatePurseError;\nexport import VersionedHostCoinPaymentCreatePurseRequest = T.VersionedHostCoinPaymentCreatePurseRequest;\nexport import VersionedHostCoinPaymentCreatePurseResponse = T.VersionedHostCoinPaymentCreatePurseResponse;\nexport import VersionedHostCoinPaymentCreateReceivableError = T.VersionedHostCoinPaymentCreateReceivableError;\nexport import VersionedHostCoinPaymentCreateReceivableRequest = T.VersionedHostCoinPaymentCreateReceivableRequest;\nexport import VersionedHostCoinPaymentCreateReceivableResponse = T.VersionedHostCoinPaymentCreateReceivableResponse;\nexport import VersionedHostCoinPaymentDeletePurseError = T.VersionedHostCoinPaymentDeletePurseError;\nexport import VersionedHostCoinPaymentDeletePurseItem = T.VersionedHostCoinPaymentDeletePurseItem;\nexport import VersionedHostCoinPaymentDeletePurseRequest = T.VersionedHostCoinPaymentDeletePurseRequest;\nexport import VersionedHostCoinPaymentDepositError = T.VersionedHostCoinPaymentDepositError;\nexport import VersionedHostCoinPaymentDepositItem = T.VersionedHostCoinPaymentDepositItem;\nexport import VersionedHostCoinPaymentDepositRequest = T.VersionedHostCoinPaymentDepositRequest;\nexport import VersionedHostCoinPaymentListenForError = T.VersionedHostCoinPaymentListenForError;\nexport import VersionedHostCoinPaymentListenForItem = T.VersionedHostCoinPaymentListenForItem;\nexport import VersionedHostCoinPaymentListenForRequest = T.VersionedHostCoinPaymentListenForRequest;\nexport import VersionedHostCoinPaymentQueryPurseError = T.VersionedHostCoinPaymentQueryPurseError;\nexport import VersionedHostCoinPaymentQueryPurseRequest = T.VersionedHostCoinPaymentQueryPurseRequest;\nexport import VersionedHostCoinPaymentQueryPurseResponse = T.VersionedHostCoinPaymentQueryPurseResponse;\nexport import VersionedHostCoinPaymentRebalancePurseError = T.VersionedHostCoinPaymentRebalancePurseError;\nexport import VersionedHostCoinPaymentRebalancePurseItem = T.VersionedHostCoinPaymentRebalancePurseItem;\nexport import VersionedHostCoinPaymentRebalancePurseRequest = T.VersionedHostCoinPaymentRebalancePurseRequest;\nexport import VersionedHostCoinPaymentRefundError = T.VersionedHostCoinPaymentRefundError;\nexport import VersionedHostCoinPaymentRefundItem = T.VersionedHostCoinPaymentRefundItem;\nexport import VersionedHostCoinPaymentRefundRequest = T.VersionedHostCoinPaymentRefundRequest;\nexport import VersionedHostCreateTransactionError = T.VersionedHostCreateTransactionError;\nexport import VersionedHostCreateTransactionRequest = T.VersionedHostCreateTransactionRequest;\nexport import VersionedHostCreateTransactionResponse = T.VersionedHostCreateTransactionResponse;\nexport import VersionedHostCreateTransactionWithLegacyAccountError = T.VersionedHostCreateTransactionWithLegacyAccountError;\nexport import VersionedHostCreateTransactionWithLegacyAccountRequest = T.VersionedHostCreateTransactionWithLegacyAccountRequest;\nexport import VersionedHostCreateTransactionWithLegacyAccountResponse = T.VersionedHostCreateTransactionWithLegacyAccountResponse;\nexport import VersionedHostDeriveEntropyError = T.VersionedHostDeriveEntropyError;\nexport import VersionedHostDeriveEntropyRequest = T.VersionedHostDeriveEntropyRequest;\nexport import VersionedHostDeriveEntropyResponse = T.VersionedHostDeriveEntropyResponse;\nexport import VersionedHostDevicePermissionError = T.VersionedHostDevicePermissionError;\nexport import VersionedHostDevicePermissionRequest = T.VersionedHostDevicePermissionRequest;\nexport import VersionedHostDevicePermissionResponse = T.VersionedHostDevicePermissionResponse;\nexport import VersionedHostFeatureSupportedError = T.VersionedHostFeatureSupportedError;\nexport import VersionedHostFeatureSupportedRequest = T.VersionedHostFeatureSupportedRequest;\nexport import VersionedHostFeatureSupportedResponse = T.VersionedHostFeatureSupportedResponse;\nexport import VersionedHostGetLegacyAccountsError = T.VersionedHostGetLegacyAccountsError;\nexport import VersionedHostGetLegacyAccountsRequest = T.VersionedHostGetLegacyAccountsRequest;\nexport import VersionedHostGetLegacyAccountsResponse = T.VersionedHostGetLegacyAccountsResponse;\nexport import VersionedHostGetProductContextError = T.VersionedHostGetProductContextError;\nexport import VersionedHostGetProductContextRequest = T.VersionedHostGetProductContextRequest;\nexport import VersionedHostGetProductContextResponse = T.VersionedHostGetProductContextResponse;\nexport import VersionedHostGetUserIdError = T.VersionedHostGetUserIdError;\nexport import VersionedHostGetUserIdRequest = T.VersionedHostGetUserIdRequest;\nexport import VersionedHostGetUserIdResponse = T.VersionedHostGetUserIdResponse;\nexport import VersionedHostHandshakeError = T.VersionedHostHandshakeError;\nexport import VersionedHostHandshakeRequest = T.VersionedHostHandshakeRequest;\nexport import VersionedHostHandshakeResponse = T.VersionedHostHandshakeResponse;\nexport import HostInfo = T.HostInfo;\nexport import VersionedHostInfoError = T.VersionedHostInfoError;\nexport import VersionedHostInfoRequest = T.VersionedHostInfoRequest;\nexport import VersionedHostInfoResponse = T.VersionedHostInfoResponse;\nexport import VersionedHostLocalStorageChangeItem = T.VersionedHostLocalStorageChangeItem;\nexport import VersionedHostLocalStorageClearError = T.VersionedHostLocalStorageClearError;\nexport import VersionedHostLocalStorageClearRequest = T.VersionedHostLocalStorageClearRequest;\nexport import VersionedHostLocalStorageClearResponse = T.VersionedHostLocalStorageClearResponse;\nexport import VersionedHostLocalStorageReadError = T.VersionedHostLocalStorageReadError;\nexport import VersionedHostLocalStorageReadRequest = T.VersionedHostLocalStorageReadRequest;\nexport import VersionedHostLocalStorageReadResponse = T.VersionedHostLocalStorageReadResponse;\nexport import VersionedHostLocalStorageSubscribeError = T.VersionedHostLocalStorageSubscribeError;\nexport import VersionedHostLocalStorageSubscribeRequest = T.VersionedHostLocalStorageSubscribeRequest;\nexport import VersionedHostLocalStorageWriteError = T.VersionedHostLocalStorageWriteError;\nexport import VersionedHostLocalStorageWriteRequest = T.VersionedHostLocalStorageWriteRequest;\nexport import VersionedHostLocalStorageWriteResponse = T.VersionedHostLocalStorageWriteResponse;\nexport import VersionedHostLocaleSubscribeError = T.VersionedHostLocaleSubscribeError;\nexport import VersionedHostLocaleSubscribeItem = T.VersionedHostLocaleSubscribeItem;\nexport import VersionedHostLocaleSubscribeRequest = T.VersionedHostLocaleSubscribeRequest;\nexport import HostNativeChatAcknowledgment = T.HostNativeChatAcknowledgment;\nexport import HostNativeChatAttachment = T.HostNativeChatAttachment;\nexport import HostNativeChatAttachmentKind = T.HostNativeChatAttachmentKind;\nexport import HostNativeChatAttachmentMetadata = T.HostNativeChatAttachmentMetadata;\nexport import HostNativeChatAttachmentState = T.HostNativeChatAttachmentState;\nexport import HostNativeChatBinding = T.HostNativeChatBinding;\nexport import HostNativeChatDevice = T.HostNativeChatDevice;\nexport import HostNativeChatInvitation = T.HostNativeChatInvitation;\nexport import HostNativeChatMessages = T.HostNativeChatMessages;\nexport import HostNativeChatMigrationInvitation = T.HostNativeChatMigrationInvitation;\nexport import HostNativeChatOpenPage = T.HostNativeChatOpenPage;\nexport import HostNativeChatOpened = T.HostNativeChatOpened;\nexport import HostNativeChatPayment = T.HostNativeChatPayment;\nexport import HostNativeChatPaymentDirection = T.HostNativeChatPaymentDirection;\nexport import HostNativeChatPaymentFailure = T.HostNativeChatPaymentFailure;\nexport import HostNativeChatPaymentState = T.HostNativeChatPaymentState;\nexport import HostNativeChatPeer = T.HostNativeChatPeer;\nexport import HostNativeChatPeerDevice = T.HostNativeChatPeerDevice;\nexport import HostNativeChatPrepared = T.HostNativeChatPrepared;\nexport import HostNativeChatRichMessage = T.HostNativeChatRichMessage;\nexport import HostNativeChatRichMessageKind = T.HostNativeChatRichMessageKind;\nexport import HostNativeChatRoute = T.HostNativeChatRoute;\nexport import HostNativeChatStatePage = T.HostNativeChatStatePage;\nexport import VersionedHostNavigateToError = T.VersionedHostNavigateToError;\nexport import VersionedHostNavigateToRequest = T.VersionedHostNavigateToRequest;\nexport import VersionedHostNavigateToResponse = T.VersionedHostNavigateToResponse;\nexport import VersionedHostPaymentBalanceSubscribeError = T.VersionedHostPaymentBalanceSubscribeError;\nexport import VersionedHostPaymentBalanceSubscribeItem = T.VersionedHostPaymentBalanceSubscribeItem;\nexport import VersionedHostPaymentBalanceSubscribeRequest = T.VersionedHostPaymentBalanceSubscribeRequest;\nexport import VersionedHostPaymentError = T.VersionedHostPaymentError;\nexport import VersionedHostPaymentRequest = T.VersionedHostPaymentRequest;\nexport import VersionedHostPaymentResponse = T.VersionedHostPaymentResponse;\nexport import VersionedHostPaymentStatusSubscribeError = T.VersionedHostPaymentStatusSubscribeError;\nexport import VersionedHostPaymentStatusSubscribeItem = T.VersionedHostPaymentStatusSubscribeItem;\nexport import VersionedHostPaymentStatusSubscribeRequest = T.VersionedHostPaymentStatusSubscribeRequest;\nexport import VersionedHostPaymentTopUpError = T.VersionedHostPaymentTopUpError;\nexport import VersionedHostPaymentTopUpRequest = T.VersionedHostPaymentTopUpRequest;\nexport import VersionedHostPaymentTopUpResponse = T.VersionedHostPaymentTopUpResponse;\nexport import HostPlatform = T.HostPlatform;\nexport import VersionedHostPocketListSubscribeError = T.VersionedHostPocketListSubscribeError;\nexport import VersionedHostPocketListSubscribeItem = T.VersionedHostPocketListSubscribeItem;\nexport import VersionedHostPocketListSubscribeRequest = T.VersionedHostPocketListSubscribeRequest;\nexport import VersionedHostPocketRemoveCardError = T.VersionedHostPocketRemoveCardError;\nexport import VersionedHostPocketRemoveCardRequest = T.VersionedHostPocketRemoveCardRequest;\nexport import VersionedHostPocketRemoveCardResponse = T.VersionedHostPocketRemoveCardResponse;\nexport import VersionedHostProductDeviceChatError = T.VersionedHostProductDeviceChatError;\nexport import VersionedHostProductDeviceChatRequest = T.VersionedHostProductDeviceChatRequest;\nexport import VersionedHostProductDeviceChatResponse = T.VersionedHostProductDeviceChatResponse;\nexport import VersionedHostProfilePresentError = T.VersionedHostProfilePresentError;\nexport import VersionedHostProfilePresentRequest = T.VersionedHostProfilePresentRequest;\nexport import VersionedHostProfilePresentResponse = T.VersionedHostProfilePresentResponse;\nexport import VersionedHostPushNotificationCancelError = T.VersionedHostPushNotificationCancelError;\nexport import VersionedHostPushNotificationCancelRequest = T.VersionedHostPushNotificationCancelRequest;\nexport import VersionedHostPushNotificationCancelResponse = T.VersionedHostPushNotificationCancelResponse;\nexport import VersionedHostPushNotificationError = T.VersionedHostPushNotificationError;\nexport import VersionedHostPushNotificationRequest = T.VersionedHostPushNotificationRequest;\nexport import VersionedHostPushNotificationResponse = T.VersionedHostPushNotificationResponse;\nexport import VersionedHostRendererActionSubscribeError = T.VersionedHostRendererActionSubscribeError;\nexport import VersionedHostRendererActionSubscribeItem = T.VersionedHostRendererActionSubscribeItem;\nexport import VersionedHostRendererActionSubscribeRequest = T.VersionedHostRendererActionSubscribeRequest;\nexport import VersionedHostRequestLoginError = T.VersionedHostRequestLoginError;\nexport import VersionedHostRequestLoginRequest = T.VersionedHostRequestLoginRequest;\nexport import VersionedHostRequestLoginResponse = T.VersionedHostRequestLoginResponse;\nexport import VersionedHostRequestResourceAllocationError = T.VersionedHostRequestResourceAllocationError;\nexport import VersionedHostRequestResourceAllocationRequest = T.VersionedHostRequestResourceAllocationRequest;\nexport import VersionedHostRequestResourceAllocationResponse = T.VersionedHostRequestResourceAllocationResponse;\nexport import HostSignPayloadData = T.HostSignPayloadData;\nexport import VersionedHostSignPayloadError = T.VersionedHostSignPayloadError;\nexport import VersionedHostSignPayloadRequest = T.VersionedHostSignPayloadRequest;\nexport import VersionedHostSignPayloadResponse = T.VersionedHostSignPayloadResponse;\nexport import VersionedHostSignPayloadWithLegacyAccountError = T.VersionedHostSignPayloadWithLegacyAccountError;\nexport import VersionedHostSignPayloadWithLegacyAccountRequest = T.VersionedHostSignPayloadWithLegacyAccountRequest;\nexport import VersionedHostSignPayloadWithLegacyAccountResponse = T.VersionedHostSignPayloadWithLegacyAccountResponse;\nexport import VersionedHostSignRawError = T.VersionedHostSignRawError;\nexport import VersionedHostSignRawRequest = T.VersionedHostSignRawRequest;\nexport import VersionedHostSignRawResponse = T.VersionedHostSignRawResponse;\nexport import VersionedHostSignRawWithLegacyAccountError = T.VersionedHostSignRawWithLegacyAccountError;\nexport import VersionedHostSignRawWithLegacyAccountRequest = T.VersionedHostSignRawWithLegacyAccountRequest;\nexport import VersionedHostSignRawWithLegacyAccountResponse = T.VersionedHostSignRawWithLegacyAccountResponse;\nexport import VersionedHostThemeSubscribeError = T.VersionedHostThemeSubscribeError;\nexport import VersionedHostThemeSubscribeItem = T.VersionedHostThemeSubscribeItem;\nexport import VersionedHostThemeSubscribeRequest = T.VersionedHostThemeSubscribeRequest;\nexport import VersionedHostWorkerBeginOperationError = T.VersionedHostWorkerBeginOperationError;\nexport import VersionedHostWorkerBeginOperationRequest = T.VersionedHostWorkerBeginOperationRequest;\nexport import VersionedHostWorkerBeginOperationResponse = T.VersionedHostWorkerBeginOperationResponse;\nexport import VersionedHostWorkerEndOperationError = T.VersionedHostWorkerEndOperationError;\nexport import VersionedHostWorkerEndOperationRequest = T.VersionedHostWorkerEndOperationRequest;\nexport import VersionedHostWorkerEndOperationResponse = T.VersionedHostWorkerEndOperationResponse;\nexport import HostWorkerOperationError = T.HostWorkerOperationError;\nexport import ImageFit = T.ImageFit;\nexport import ImageProps = T.ImageProps;\nexport import ImageSource = T.ImageSource;\nexport import LegacyAccount = T.LegacyAccount;\nexport import LegacyAccountTxPayload = T.LegacyAccountTxPayload;\nexport import Modifier = T.Modifier;\nexport import NotificationId = T.NotificationId;\nexport import OperationId = T.OperationId;\nexport import OperationStartedResult = T.OperationStartedResult;\nexport import PaymentTopUpSource = T.PaymentTopUpSource;\nexport import PocketCard = T.PocketCard;\nexport import PreimageSubmitError = T.PreimageSubmitError;\nexport import ProductAccount = T.ProductAccount;\nexport import ProductAccountId = T.ProductAccountId;\nexport import ProductAccountTxPayload = T.ProductAccountTxPayload;\nexport import ProductProofContext = T.ProductProofContext;\nexport import VersionedProductRendererRenderError = T.VersionedProductRendererRenderError;\nexport import VersionedProductRendererRenderItem = T.VersionedProductRendererRenderItem;\nexport import VersionedProductRendererRenderRequest = T.VersionedProductRendererRenderRequest;\nexport import RawPayload = T.RawPayload;\nexport import RegisteredRingVrfKey = T.RegisteredRingVrfKey;\nexport import VersionedRemoteChainHeadBodyError = T.VersionedRemoteChainHeadBodyError;\nexport import VersionedRemoteChainHeadBodyRequest = T.VersionedRemoteChainHeadBodyRequest;\nexport import VersionedRemoteChainHeadBodyResponse = T.VersionedRemoteChainHeadBodyResponse;\nexport import VersionedRemoteChainHeadCallError = T.VersionedRemoteChainHeadCallError;\nexport import VersionedRemoteChainHeadCallRequest = T.VersionedRemoteChainHeadCallRequest;\nexport import VersionedRemoteChainHeadCallResponse = T.VersionedRemoteChainHeadCallResponse;\nexport import VersionedRemoteChainHeadContinueError = T.VersionedRemoteChainHeadContinueError;\nexport import VersionedRemoteChainHeadContinueRequest = T.VersionedRemoteChainHeadContinueRequest;\nexport import VersionedRemoteChainHeadContinueResponse = T.VersionedRemoteChainHeadContinueResponse;\nexport import VersionedRemoteChainHeadFollowError = T.VersionedRemoteChainHeadFollowError;\nexport import VersionedRemoteChainHeadFollowItem = T.VersionedRemoteChainHeadFollowItem;\nexport import VersionedRemoteChainHeadFollowRequest = T.VersionedRemoteChainHeadFollowRequest;\nexport import VersionedRemoteChainHeadHeaderError = T.VersionedRemoteChainHeadHeaderError;\nexport import VersionedRemoteChainHeadHeaderRequest = T.VersionedRemoteChainHeadHeaderRequest;\nexport import VersionedRemoteChainHeadHeaderResponse = T.VersionedRemoteChainHeadHeaderResponse;\nexport import VersionedRemoteChainHeadStopOperationError = T.VersionedRemoteChainHeadStopOperationError;\nexport import VersionedRemoteChainHeadStopOperationRequest = T.VersionedRemoteChainHeadStopOperationRequest;\nexport import VersionedRemoteChainHeadStopOperationResponse = T.VersionedRemoteChainHeadStopOperationResponse;\nexport import VersionedRemoteChainHeadStorageError = T.VersionedRemoteChainHeadStorageError;\nexport import VersionedRemoteChainHeadStorageRequest = T.VersionedRemoteChainHeadStorageRequest;\nexport import VersionedRemoteChainHeadStorageResponse = T.VersionedRemoteChainHeadStorageResponse;\nexport import VersionedRemoteChainHeadUnpinError = T.VersionedRemoteChainHeadUnpinError;\nexport import VersionedRemoteChainHeadUnpinRequest = T.VersionedRemoteChainHeadUnpinRequest;\nexport import VersionedRemoteChainHeadUnpinResponse = T.VersionedRemoteChainHeadUnpinResponse;\nexport import VersionedRemoteChainInfoError = T.VersionedRemoteChainInfoError;\nexport import VersionedRemoteChainInfoRequest = T.VersionedRemoteChainInfoRequest;\nexport import VersionedRemoteChainInfoResponse = T.VersionedRemoteChainInfoResponse;\nexport import VersionedRemoteChainSpecChainNameError = T.VersionedRemoteChainSpecChainNameError;\nexport import VersionedRemoteChainSpecChainNameRequest = T.VersionedRemoteChainSpecChainNameRequest;\nexport import VersionedRemoteChainSpecChainNameResponse = T.VersionedRemoteChainSpecChainNameResponse;\nexport import VersionedRemoteChainSpecGenesisHashError = T.VersionedRemoteChainSpecGenesisHashError;\nexport import VersionedRemoteChainSpecGenesisHashRequest = T.VersionedRemoteChainSpecGenesisHashRequest;\nexport import VersionedRemoteChainSpecGenesisHashResponse = T.VersionedRemoteChainSpecGenesisHashResponse;\nexport import VersionedRemoteChainSpecPropertiesError = T.VersionedRemoteChainSpecPropertiesError;\nexport import VersionedRemoteChainSpecPropertiesRequest = T.VersionedRemoteChainSpecPropertiesRequest;\nexport import VersionedRemoteChainSpecPropertiesResponse = T.VersionedRemoteChainSpecPropertiesResponse;\nexport import VersionedRemoteChainTransactionBroadcastError = T.VersionedRemoteChainTransactionBroadcastError;\nexport import VersionedRemoteChainTransactionBroadcastRequest = T.VersionedRemoteChainTransactionBroadcastRequest;\nexport import VersionedRemoteChainTransactionBroadcastResponse = T.VersionedRemoteChainTransactionBroadcastResponse;\nexport import VersionedRemoteChainTransactionStopError = T.VersionedRemoteChainTransactionStopError;\nexport import VersionedRemoteChainTransactionStopRequest = T.VersionedRemoteChainTransactionStopRequest;\nexport import VersionedRemoteChainTransactionStopResponse = T.VersionedRemoteChainTransactionStopResponse;\nexport import RemotePermission = T.RemotePermission;\nexport import VersionedRemotePermissionError = T.VersionedRemotePermissionError;\nexport import VersionedRemotePermissionRequest = T.VersionedRemotePermissionRequest;\nexport import VersionedRemotePermissionResponse = T.VersionedRemotePermissionResponse;\nexport import VersionedRemotePreimageLookupSubscribeError = T.VersionedRemotePreimageLookupSubscribeError;\nexport import VersionedRemotePreimageLookupSubscribeItem = T.VersionedRemotePreimageLookupSubscribeItem;\nexport import VersionedRemotePreimageLookupSubscribeRequest = T.VersionedRemotePreimageLookupSubscribeRequest;\nexport import VersionedRemotePreimageSubmitError = T.VersionedRemotePreimageSubmitError;\nexport import VersionedRemotePreimageSubmitRequest = T.VersionedRemotePreimageSubmitRequest;\nexport import VersionedRemotePreimageSubmitResponse = T.VersionedRemotePreimageSubmitResponse;\nexport import VersionedRemoteStatementStoreCreateProofAuthorizedError = T.VersionedRemoteStatementStoreCreateProofAuthorizedError;\nexport import VersionedRemoteStatementStoreCreateProofAuthorizedRequest = T.VersionedRemoteStatementStoreCreateProofAuthorizedRequest;\nexport import VersionedRemoteStatementStoreCreateProofAuthorizedResponse = T.VersionedRemoteStatementStoreCreateProofAuthorizedResponse;\nexport import VersionedRemoteStatementStoreCreateProofError = T.VersionedRemoteStatementStoreCreateProofError;\nexport import VersionedRemoteStatementStoreCreateProofRequest = T.VersionedRemoteStatementStoreCreateProofRequest;\nexport import VersionedRemoteStatementStoreCreateProofResponse = T.VersionedRemoteStatementStoreCreateProofResponse;\nexport import VersionedRemoteStatementStoreSubmitError = T.VersionedRemoteStatementStoreSubmitError;\nexport import VersionedRemoteStatementStoreSubmitRequest = T.VersionedRemoteStatementStoreSubmitRequest;\nexport import VersionedRemoteStatementStoreSubmitResponse = T.VersionedRemoteStatementStoreSubmitResponse;\nexport import VersionedRemoteStatementStoreSubscribeError = T.VersionedRemoteStatementStoreSubscribeError;\nexport import VersionedRemoteStatementStoreSubscribeItem = T.VersionedRemoteStatementStoreSubscribeItem;\nexport import VersionedRemoteStatementStoreSubscribeRequest = T.VersionedRemoteStatementStoreSubscribeRequest;\nexport import RenderContext = T.RenderContext;\nexport import RendererNode = T.RendererNode;\nexport import ResourceAllocationError = T.ResourceAllocationError;\nexport import RingLocation = T.RingLocation;\nexport import RingLocationJunction = T.RingLocationJunction;\nexport import RingVrfKeyDisclosure = T.RingVrfKeyDisclosure;\nexport import RingVrfPublicKey = T.RingVrfPublicKey;\nexport import RowProps = T.RowProps;\nexport import RuntimeApi = T.RuntimeApi;\nexport import RuntimeSpec = T.RuntimeSpec;\nexport import RuntimeType = T.RuntimeType;\nexport import Shape = T.Shape;\nexport import SignedStatement = T.SignedStatement;\nexport import Size = T.Size;\nexport import Statement = T.Statement;\nexport import StatementProof = T.StatementProof;\nexport import StorageQueryItem = T.StorageQueryItem;\nexport import StorageQueryType = T.StorageQueryType;\nexport import StorageResultItem = T.StorageResultItem;\nexport import TextFieldProps = T.TextFieldProps;\nexport import TextProps = T.TextProps;\nexport import ThemeName = T.ThemeName;\nexport import ThemeVariant = T.ThemeVariant;\nexport import Topic = T.Topic;\nexport import TxPayloadExtension = T.TxPayloadExtension;\nexport import TypographyStyle = T.TypographyStyle;\nexport import HostAccountConnectionStatusSubscribeItem = T.HostAccountConnectionStatusSubscribeItem;\nexport import HostAccountCreateProofError = T.HostAccountCreateProofError;\nexport import HostAccountCreateProofRequest = T.HostAccountCreateProofRequest;\nexport import HostAccountCreateProofResponse = T.HostAccountCreateProofResponse;\nexport import HostAccountGetAliasError = T.HostAccountGetAliasError;\nexport import HostAccountGetAliasRequest = T.HostAccountGetAliasRequest;\nexport import HostAccountGetError = T.HostAccountGetError;\nexport import HostAccountGetRequest = T.HostAccountGetRequest;\nexport import HostAccountGetResponse = T.HostAccountGetResponse;\nexport import HostAccountListRingVrfKeysError = T.HostAccountListRingVrfKeysError;\nexport import HostAccountListRingVrfKeysRequest = T.HostAccountListRingVrfKeysRequest;\nexport import HostAccountRegisterRingVrfKeyError = T.HostAccountRegisterRingVrfKeyError;\nexport import HostAccountRegisterRingVrfKeyRequest = T.HostAccountRegisterRingVrfKeyRequest;\nexport import HostAccountRingVrfSignError = T.HostAccountRingVrfSignError;\nexport import HostAccountRingVrfSignRequest = T.HostAccountRingVrfSignRequest;\nexport import HostAccountSignVrfError = T.HostAccountSignVrfError;\nexport import HostAccountSignVrfRequest = T.HostAccountSignVrfRequest;\nexport import HostChatActionSubscribeItem = T.HostChatActionSubscribeItem;\nexport import HostChatCreateRoomError = T.HostChatCreateRoomError;\nexport import HostChatCreateRoomRequest = T.HostChatCreateRoomRequest;\nexport import HostChatCreateRoomResponse = T.HostChatCreateRoomResponse;\nexport import HostChatListSubscribeItem = T.HostChatListSubscribeItem;\nexport import HostChatPostMessageError = T.HostChatPostMessageError;\nexport import HostChatPostMessageRequest = T.HostChatPostMessageRequest;\nexport import HostChatPostMessageResponse = T.HostChatPostMessageResponse;\nexport import HostChatRegisterBotError = T.HostChatRegisterBotError;\nexport import HostChatRegisterBotRequest = T.HostChatRegisterBotRequest;\nexport import HostChatRegisterBotResponse = T.HostChatRegisterBotResponse;\nexport import HostCoinPaymentCreateChequeRequest = T.HostCoinPaymentCreateChequeRequest;\nexport import HostCoinPaymentCreateChequeResponse = T.HostCoinPaymentCreateChequeResponse;\nexport import HostCoinPaymentCreatePurseRequest = T.HostCoinPaymentCreatePurseRequest;\nexport import HostCoinPaymentCreatePurseResponse = T.HostCoinPaymentCreatePurseResponse;\nexport import HostCoinPaymentCreateReceivableRequest = T.HostCoinPaymentCreateReceivableRequest;\nexport import HostCoinPaymentCreateReceivableResponse = T.HostCoinPaymentCreateReceivableResponse;\nexport import HostCoinPaymentDeletePurseRequest = T.HostCoinPaymentDeletePurseRequest;\nexport import HostCoinPaymentDepositRequest = T.HostCoinPaymentDepositRequest;\nexport import HostCoinPaymentListenForItem = T.HostCoinPaymentListenForItem;\nexport import HostCoinPaymentListenForRequest = T.HostCoinPaymentListenForRequest;\nexport import HostCoinPaymentQueryPurseRequest = T.HostCoinPaymentQueryPurseRequest;\nexport import HostCoinPaymentQueryPurseResponse = T.HostCoinPaymentQueryPurseResponse;\nexport import HostCoinPaymentRebalancePurseRequest = T.HostCoinPaymentRebalancePurseRequest;\nexport import HostCoinPaymentRefundRequest = T.HostCoinPaymentRefundRequest;\nexport import HostCreateTransactionError = T.HostCreateTransactionError;\nexport import HostCreateTransactionResponse = T.HostCreateTransactionResponse;\nexport import HostCreateTransactionWithLegacyAccountResponse = T.HostCreateTransactionWithLegacyAccountResponse;\nexport import HostDeriveEntropyError = T.HostDeriveEntropyError;\nexport import HostDeriveEntropyRequest = T.HostDeriveEntropyRequest;\nexport import HostDeriveEntropyResponse = T.HostDeriveEntropyResponse;\nexport import HostDevicePermissionRequest = T.HostDevicePermissionRequest;\nexport import HostDevicePermissionResponse = T.HostDevicePermissionResponse;\nexport import HostFeatureSupportedRequest = T.HostFeatureSupportedRequest;\nexport import HostFeatureSupportedResponse = T.HostFeatureSupportedResponse;\nexport import HostGetLegacyAccountsResponse = T.HostGetLegacyAccountsResponse;\nexport import HostGetProductContextResponse = T.HostGetProductContextResponse;\nexport import HostGetUserIdError = T.HostGetUserIdError;\nexport import HostGetUserIdResponse = T.HostGetUserIdResponse;\nexport import HostHandshakeError = T.HostHandshakeError;\nexport import HostHandshakeRequest = T.HostHandshakeRequest;\nexport import HostLocalStorageChangeItem = T.HostLocalStorageChangeItem;\nexport import HostLocalStorageClearRequest = T.HostLocalStorageClearRequest;\nexport import V01HostLocalStorageReadError = T.V01HostLocalStorageReadError;\nexport import V01HostLocalStorageReadRequest = T.V01HostLocalStorageReadRequest;\nexport import HostLocalStorageReadResponse = T.HostLocalStorageReadResponse;\nexport import HostLocalStorageSubscribeRequest = T.HostLocalStorageSubscribeRequest;\nexport import HostLocalStorageWriteRequest = T.HostLocalStorageWriteRequest;\nexport import HostLocaleSubscribeItem = T.HostLocaleSubscribeItem;\nexport import HostNavigateToError = T.HostNavigateToError;\nexport import HostNavigateToRequest = T.HostNavigateToRequest;\nexport import HostPaymentBalanceSubscribeError = T.HostPaymentBalanceSubscribeError;\nexport import HostPaymentBalanceSubscribeItem = T.HostPaymentBalanceSubscribeItem;\nexport import HostPaymentBalanceSubscribeRequest = T.HostPaymentBalanceSubscribeRequest;\nexport import HostPaymentError = T.HostPaymentError;\nexport import HostPaymentRequest = T.HostPaymentRequest;\nexport import HostPaymentResponse = T.HostPaymentResponse;\nexport import HostPaymentStatusSubscribeError = T.HostPaymentStatusSubscribeError;\nexport import HostPaymentStatusSubscribeItem = T.HostPaymentStatusSubscribeItem;\nexport import HostPaymentStatusSubscribeRequest = T.HostPaymentStatusSubscribeRequest;\nexport import HostPaymentTopUpError = T.HostPaymentTopUpError;\nexport import HostPaymentTopUpRequest = T.HostPaymentTopUpRequest;\nexport import HostPocketListSubscribeItem = T.HostPocketListSubscribeItem;\nexport import HostPocketRemoveCardError = T.HostPocketRemoveCardError;\nexport import HostPocketRemoveCardRequest = T.HostPocketRemoveCardRequest;\nexport import HostProfilePresentError = T.HostProfilePresentError;\nexport import HostProfilePresentRequest = T.HostProfilePresentRequest;\nexport import HostPushNotificationCancelRequest = T.HostPushNotificationCancelRequest;\nexport import HostPushNotificationError = T.HostPushNotificationError;\nexport import HostPushNotificationRequest = T.HostPushNotificationRequest;\nexport import HostPushNotificationResponse = T.HostPushNotificationResponse;\nexport import HostRendererActionSubscribeItem = T.HostRendererActionSubscribeItem;\nexport import HostRequestLoginError = T.HostRequestLoginError;\nexport import HostRequestLoginRequest = T.HostRequestLoginRequest;\nexport import HostRequestLoginResponse = T.HostRequestLoginResponse;\nexport import HostRequestResourceAllocationRequest = T.HostRequestResourceAllocationRequest;\nexport import HostRequestResourceAllocationResponse = T.HostRequestResourceAllocationResponse;\nexport import HostSignPayloadError = T.HostSignPayloadError;\nexport import HostSignPayloadRequest = T.HostSignPayloadRequest;\nexport import HostSignPayloadResponse = T.HostSignPayloadResponse;\nexport import HostSignPayloadWithLegacyAccountRequest = T.HostSignPayloadWithLegacyAccountRequest;\nexport import HostSignRawRequest = T.HostSignRawRequest;\nexport import HostSignRawWithLegacyAccountRequest = T.HostSignRawWithLegacyAccountRequest;\nexport import HostThemeSubscribeItem = T.HostThemeSubscribeItem;\nexport import HostWorkerBeginOperationRequest = T.HostWorkerBeginOperationRequest;\nexport import HostWorkerBeginOperationResponse = T.HostWorkerBeginOperationResponse;\nexport import HostWorkerEndOperationRequest = T.HostWorkerEndOperationRequest;\nexport import ProductRendererRenderRequest = T.ProductRendererRenderRequest;\nexport import RemoteChainHeadBodyRequest = T.RemoteChainHeadBodyRequest;\nexport import RemoteChainHeadBodyResponse = T.RemoteChainHeadBodyResponse;\nexport import RemoteChainHeadCallRequest = T.RemoteChainHeadCallRequest;\nexport import RemoteChainHeadCallResponse = T.RemoteChainHeadCallResponse;\nexport import RemoteChainHeadContinueRequest = T.RemoteChainHeadContinueRequest;\nexport import RemoteChainHeadFollowItem = T.RemoteChainHeadFollowItem;\nexport import RemoteChainHeadFollowRequest = T.RemoteChainHeadFollowRequest;\nexport import RemoteChainHeadHeaderRequest = T.RemoteChainHeadHeaderRequest;\nexport import RemoteChainHeadHeaderResponse = T.RemoteChainHeadHeaderResponse;\nexport import RemoteChainHeadStopOperationRequest = T.RemoteChainHeadStopOperationRequest;\nexport import RemoteChainHeadStorageRequest = T.RemoteChainHeadStorageRequest;\nexport import RemoteChainHeadStorageResponse = T.RemoteChainHeadStorageResponse;\nexport import RemoteChainHeadUnpinRequest = T.RemoteChainHeadUnpinRequest;\nexport import RemoteChainInfoError = T.RemoteChainInfoError;\nexport import RemoteChainInfoRequest = T.RemoteChainInfoRequest;\nexport import RemoteChainInfoResponse = T.RemoteChainInfoResponse;\nexport import RemoteChainSpecChainNameRequest = T.RemoteChainSpecChainNameRequest;\nexport import RemoteChainSpecChainNameResponse = T.RemoteChainSpecChainNameResponse;\nexport import RemoteChainSpecGenesisHashRequest = T.RemoteChainSpecGenesisHashRequest;\nexport import RemoteChainSpecGenesisHashResponse = T.RemoteChainSpecGenesisHashResponse;\nexport import RemoteChainSpecPropertiesRequest = T.RemoteChainSpecPropertiesRequest;\nexport import RemoteChainSpecPropertiesResponse = T.RemoteChainSpecPropertiesResponse;\nexport import RemoteChainTransactionBroadcastRequest = T.RemoteChainTransactionBroadcastRequest;\nexport import RemoteChainTransactionBroadcastResponse = T.RemoteChainTransactionBroadcastResponse;\nexport import RemoteChainTransactionStopRequest = T.RemoteChainTransactionStopRequest;\nexport import RemotePermissionRequest = T.RemotePermissionRequest;\nexport import RemotePermissionResponse = T.RemotePermissionResponse;\nexport import RemotePreimageLookupSubscribeItem = T.RemotePreimageLookupSubscribeItem;\nexport import RemotePreimageLookupSubscribeRequest = T.RemotePreimageLookupSubscribeRequest;\nexport import RemoteStatementStoreCreateProofError = T.RemoteStatementStoreCreateProofError;\nexport import RemoteStatementStoreCreateProofRequest = T.RemoteStatementStoreCreateProofRequest;\nexport import RemoteStatementStoreCreateProofResponse = T.RemoteStatementStoreCreateProofResponse;\nexport import RemoteStatementStoreSubscribeItem = T.RemoteStatementStoreSubscribeItem;\nexport import RemoteStatementStoreSubscribeRequest = T.RemoteStatementStoreSubscribeRequest;\nexport import HostLocalStorageReadError = T.HostLocalStorageReadError;\nexport import HostLocalStorageReadRequest = T.HostLocalStorageReadRequest;\nexport import HostProductDeviceChatError = T.HostProductDeviceChatError;\nexport import V02HostProductDeviceChatRequest = T.V02HostProductDeviceChatRequest;\nexport import V02HostProductDeviceChatResponse = T.V02HostProductDeviceChatResponse;\nexport import HostProductDeviceChatRequest = T.HostProductDeviceChatRequest;\nexport import HostProductDeviceChatResponse = T.HostProductDeviceChatResponse;\nexport import VerticalAlignment = T.VerticalAlignment;\nexport import VrfSignature = T.VrfSignature;\nexport import VrfTranscriptItem = T.VrfTranscriptItem;\n\n// index.d.ts\n\n\n// transport.d.ts\n/**\n * Wire trait discriminant reserved for method-independent protocol errors. No\n * API trait may declare it, so no method is ever addressed here.\n **/\nexport declare const PROTOCOL_ERROR_TRAIT_ID: 255;\n/** Wire method discriminant reserved for method-independent protocol errors. **/\nexport declare const PROTOCOL_ERROR_METHOD_ID: 255;\n/** The peer rejected an outbound frame because it does not support its API. **/\nexport declare class UnsupportedMessageError extends Error {\n /** Trait discriminant of the unsupported outbound frame. **/\n readonly traitId: number;\n /** Method discriminant of the unsupported outbound frame. **/\n readonly methodId: number;\n constructor(traitId: number, methodId: number);\n}\n/** The host connection ended; interrupted operations are not retried. */\nexport declare class ConnectionResetError extends Error {\n constructor(options?: ErrorOptions);\n}\n/** Call result returned when the peer does not recognize a request frame. **/\nexport type UnsupportedCallError = Extract, {\n tag: \"Unsupported\";\n}>;\n/**\n * Handle returned by TrUAPI subscription APIs.\n **/\nexport interface Subscription {\n /**\n * Stop the subscription. Calling this more than once has no additional effect.\n **/\n unsubscribe: () => void;\n /**\n * Transport-assigned request id for the subscription start frame.\n *\n * Methods that accept a `followSubscriptionId` use this value to scope\n * follow-up requests to a specific active subscription.\n **/\n subscriptionId: string;\n}\n/**\n * Terminal error delivered through `Observer.error` for every non-normal\n * subscription end. When the peer interrupted the stream with a typed payload,\n * `reason` carries the decoded `Reason`; otherwise `reason` is `undefined` and\n * the underlying transport/decode error is preserved on `cause`.\n *\n * Discriminate with `error.reason !== undefined` (or `'reason' in error`).\n **/\nexport declare class SubscriptionError extends Error {\n /**\n * Typed payload supplied by the peer when it interrupted the subscription.\n * `undefined` when the stream ended for any other reason (transport close,\n * decode failure, malformed interrupt payload).\n **/\n readonly reason?: Reason;\n constructor(message: string, options?: {\n reason?: Reason;\n cause?: unknown;\n });\n}\n/**\n * Minimal Observable-compatible observer shape used by generated subscription\n * APIs without depending on RxJS.\n *\n * `Reason` is the typed interrupt payload for the originating subscription.\n * Methods without a typed interrupt resolve `Reason` to `never`, leaving\n * `error.reason` typed as `undefined`.\n **/\nexport interface Observer {\n /**\n * Called with each successfully decoded subscription item.\n **/\n next(value: Item): void;\n /**\n * Called once when the stream terminates with an error. Inspect\n * `error.reason` to distinguish a typed peer interrupt from a transport or\n * decode failure (`error.cause` carries the underlying failure in the\n * latter case).\n **/\n error(error: SubscriptionError): void;\n /**\n * Called once when the peer normally completes the stream.\n **/\n complete(): void;\n}\ndeclare global {\n interface SymbolConstructor {\n readonly observable: unique symbol;\n }\n}\n/**\n * Minimal Observable-compatible object returned by generated subscription APIs.\n *\n * Implements the ES Observable interop protocol so that consumers can pass\n * an instance straight to `rxjs.from(...)`.\n **/\nexport interface ObservableLike {\n /**\n * Start the stream and receive `next`, `error`, and `complete` callbacks.\n **/\n subscribe(observer?: Partial>): Subscription;\n /**\n * Observable interop hook. Returns `this`.\n **/\n [Symbol.observable](): ObservableLike;\n}\n/**\n * Product-side handler for a subscription the native host initiates.\n *\n * It receives the decoded request and two callbacks: `send` delivers one item\n * to the host, and `interrupt` ends the stream, cleanly when called with no\n * argument and with the method's interrupt value otherwise. The returned\n * teardown, if any, runs once the stream ends: on the host's stop frame, on\n * `interrupt`, when the transport closes, or when the host restarts the same\n * request id.\n **/\nexport type HostInitiatedSubscriptionHandler = (request: Request, send: (item: Item) => void, interrupt: (reason?: Reason) => void) => (() => void) | void;\n/**\n * Wire discriminant pair addressing a method. One id addresses a method\n * regardless of shape (request/response, or a subscription's four phases):\n * which leg of the exchange a frame carries is the wire's own `messageType`\n * byte, not a separate id per leg.\n **/\nexport interface MethodIds {\n /**\n * Wire trait discriminant.\n **/\n trait: number;\n /**\n * Wire method discriminant within the trait.\n **/\n method: number;\n /**\n * Whether this method's legs follow the request/response shape or the\n * subscription shape (`\"subscription\"` covers both plain and result\n * subscriptions, which share the same four-leg wire shape). The one piece\n * of shape a payload-blind reader needs to interpret a frame's own\n * `messageType` byte without decoding the payload.\n **/\n kind: \"request\" | \"subscription\";\n}\n/**\n * Per-call options every generated request method accepts as its last\n * argument.\n **/\nexport interface CallOptions {\n /** See {@link RequestParams.signal}. **/\n signal?: AbortSignal;\n}\n/**\n * Options accepted by `TrUApiTransport.request`.\n **/\nexport interface RequestParams {\n /**\n * Wire discriminants for this request method.\n **/\n ids: MethodIds;\n /**\n * SCALE-encoded request wrapper payload bytes (its own `V` tag is the\n * wire's only version signal), constructed by the generated caller.\n **/\n payload: Uint8Array;\n /**\n * Decode a `Response`-leg frame's raw payload bytes into the typed Ok/Err\n * outcome. Implementations decode `Result<{Method}Response,\n * CallError<{Method}Error>>` directly. The transport unwraps the result\n * into `ResultAsync`.\n **/\n decodeResponse: (payload: Uint8Array) => ResultPayload;\n /**\n * Withdraw the call. Aborting sends a `Cancel` frame on this method's own\n * address; the promise still settles on the response the host sends, which\n * for a call the host stopped is `CallError::Cancelled`. A signal already\n * aborted when the call is made sends nothing and rejects immediately.\n *\n * A host that predates the `Cancel` leg drops the frame, so an aborted call\n * against one settles on its deadline instead. There is no way to detect that\n * first: `system.featureSupported` answers only about chains, so an abort\n * against an older host is indistinguishable from one it honoured.\n **/\n signal?: AbortSignal;\n}\n/**\n * Options accepted by `TrUApiTransport.subscribeRaw`.\n **/\nexport interface SubscribeRawParams {\n /**\n * Wire discriminants for this subscription method.\n **/\n ids: MethodIds;\n /**\n * SCALE-encoded `Start`-leg payload bytes: the request wrapper's own\n * encoding, or empty bytes for a method with no request at all,\n * constructed by the generated caller.\n **/\n payload: Uint8Array;\n /**\n * Called with a `Receive`-leg frame's raw payload bytes.\n **/\n onReceive: (payload: Uint8Array) => void;\n /**\n * Called with an `Interrupt`-leg frame's raw payload bytes.\n **/\n onInterrupt?: (payload: Uint8Array) => void;\n /**\n * Called when a transport-level error or unsupported start frame terminates\n * the subscription.\n **/\n onClose?: (error: Error) => void;\n}\n/** Product-side registration for one host-initiated subscription method. **/\nexport interface HostInitiatedSubscriptionRegistration {\n /** Install or replace the handler used for future start frames. **/\n setHandler(handler: HostInitiatedSubscriptionHandler): {\n unsubscribe(): void;\n };\n}\n/** Options used to register a host-initiated subscription method. **/\nexport interface RegisterHostInitiatedSubscriptionParams {\n /** Wire discriminants for the host-initiated subscription. **/\n ids: MethodIds;\n /**\n * Decode a `Start`-leg frame's raw payload bytes into the typed request.\n **/\n decodeRequest(payload: Uint8Array): Request;\n /**\n * Encode one product emission as a `Receive`-leg frame's raw payload bytes.\n **/\n encodeItem(item: Item): Uint8Array;\n /**\n * Encode an `Interrupt`-leg frame's raw payload bytes: the stream's clean\n * end when `reason` is omitted, and the method's interrupt value otherwise.\n **/\n encodeInterrupt(reason?: Reason): Uint8Array;\n /**\n * Exact payload used when the transport ends a stream the product's handler\n * never got to serve.\n **/\n declinePayload: Uint8Array;\n /** Number of starts retained before a handler is installed. **/\n bufferCapacity: number;\n}\n/**\n * Byte-level transport used by generated client stubs.\n **/\nexport interface TrUApiTransport {\n /**\n * Send a one-shot request and resolve with the typed Ok/Err outcome.\n **/\n request(params: RequestParams): ResultAsync;\n /**\n * Start a subscription and return a handle that can stop it.\n **/\n subscribeRaw(params: SubscribeRawParams): Subscription;\n /** Register product-side handling for a host-initiated subscription. **/\n registerHostInitiatedSubscription(params: RegisterHostInitiatedSubscriptionParams): HostInitiatedSubscriptionRegistration;\n /**\n * Tear down the transport and release the listeners it registered on the\n * underlying `WireProvider`. Pending requests reject and live subscriptions\n * receive `onClose`. Idempotent.\n *\n * The provider itself is left alone; the caller decides whether to also\n * call `provider.dispose()` (long-lived hosts that swap providers will\n * typically dispose the transport but keep the provider).\n **/\n dispose(): void;\n}\n/**\n * Tagged payload inside a TrUAPI wire frame.\n **/\nexport interface Payload {\n /**\n * Wire-table trait discriminant: first byte of the `(trait, method)` pair.\n **/\n traitId: number;\n /**\n * Wire-table method discriminant within the trait: second byte of the pair.\n **/\n methodId: number;\n /**\n * Which leg of the method's exchange this frame carries: `Request`/`Start`\n * = 0, `Response`/`Receive` = 1, `Interrupt` = 2, `Stop` = 3. Third byte of\n * the wire frame \u2014 readable generically, without decoding `value`.\n **/\n messageType: number;\n /**\n * SCALE-encoded payload body: that leg's own versioned wrapper, with no\n * further tag identifying direction or version beyond the wrapper's own.\n **/\n value: Uint8Array;\n}\n/** See {@link Payload.messageType}. */\nexport declare const MESSAGE_TYPE_REQUEST = 0;\n/** See {@link Payload.messageType}. */\nexport declare const MESSAGE_TYPE_START = 0;\n/** See {@link Payload.messageType}. */\nexport declare const MESSAGE_TYPE_RESPONSE = 1;\n/** See {@link Payload.messageType}. */\nexport declare const MESSAGE_TYPE_RECEIVE = 1;\n/** See {@link Payload.messageType}. */\nexport declare const MESSAGE_TYPE_INTERRUPT = 2;\n/** See {@link Payload.messageType}. */\nexport declare const MESSAGE_TYPE_STOP = 3;\n/**\n * A request's withdrawal, correlated by the same `requestId` and carrying no\n * payload. The call still settles with exactly one response; this only fires\n * the handler's cancellation token on the far side.\n **/\nexport declare const MESSAGE_TYPE_CANCEL = 4;\n/**\n * Top-level TrUAPI wire message.\n **/\nexport interface ProtocolMessage {\n /**\n * Request id used to correlate request/response and subscription frames.\n **/\n requestId: string;\n /**\n * Tagged SCALE payload carried by this frame.\n **/\n payload: Payload;\n}\n/**\n * Raw SCALE-wire-frame pipe abstraction used by the transport. A `WireProvider`\n * is the low-level channel (a `MessagePort` or iframe `postMessage` link) that\n * carries encoded frames between the product and the host.\n **/\nexport interface WireProvider {\n /**\n * Send a complete SCALE-encoded wire frame to the peer.\n **/\n postMessage(message: Uint8Array): void;\n /**\n * Register a callback for inbound SCALE-encoded wire frames.\n **/\n subscribe(callback: (message: Uint8Array) => void): () => void;\n /**\n * Register a callback for provider-level close or failure events.\n *\n * Providers keep a terminal close reason. The callback fires at most once\n * for an active subscription, and fires immediately when registered after\n * the provider has already closed.\n **/\n subscribeClose?(callback: (error: Error) => void): () => void;\n /** End current operations while keeping the provider available for new work. */\n subscribeReset?(callback: (error: Error) => void): () => void;\n /**\n * Release provider resources and close the underlying pipe.\n **/\n dispose(): void;\n}\n/**\n * A {@link WireProvider} backed by a WebSocket, which reports when its socket\n * is up. Awaiting {@link WebSocketWireProvider.opened} is optional: frames\n * posted earlier are queued and flushed on open.\n **/\nexport interface WebSocketWireProvider extends WireProvider {\n /** Resolves once the socket is open, rejects if it never connects. */\n opened: Promise;\n}\n/**\n * Encode a `ProtocolMessage` into a SCALE wire frame.\n **/\nexport declare function encodeWireMessage(message: ProtocolMessage): Result;\n/**\n * Decode a SCALE wire frame into a `ProtocolMessage`.\n **/\nexport declare function decodeWireMessage(message: Uint8Array): Result;\n/**\n * Create a provider for the child side of an iframe `postMessage` channel.\n *\n * `target` is the `Window` the provider posts to (typically `window.parent`);\n * `hostOrigin` is the pinned `targetOrigin` for outbound frames and the\n * required `event.origin` of inbound frames. The provider only delivers\n * frames whose `event.source === target` and `event.origin === hostOrigin`,\n * so it cannot be coerced by an unrelated frame parent.\n **/\nexport declare function createIframeProvider(options: {\n target: Window;\n hostOrigin: string;\n}): WireProvider;\n/**\n * Create a provider from a web or Electron `MessagePort`.\n **/\nexport declare function createMessagePortProvider(port: MessagePort | Promise): WireProvider;\n/**\n * Wire provider over a binary WebSocket, one message per SCALE frame.\n *\n * This is the transport a host exposes on a loopback socket: the Rust core's\n * `ws-bridge`, and `truapi-host signing-host --frame-listen`. The frame bytes\n * are identical to what the {@link createMessagePortProvider} path carries, so\n * this is a pipe and nothing more.\n *\n * Frames posted before the socket opens are queued and flushed on open, so a\n * caller never has to await {@link WebSocketWireProvider.opened} first.\n **/\nexport declare function createWebSocketProvider(url: string): WebSocketWireProvider;\n/** Capture native socket APIs before product code installs network gates. */\nexport declare function createWebSocketProviderFactory(): (url: string) => WebSocketWireProvider;\n\n\n// client.d.ts\nexport type { Subscription, TrUApiTransport };\n/** A request received no matching response before its transport deadline. */\nexport declare class RequestTimeoutError extends Error {\n /** Transport-assigned request identifier. */\n readonly requestId: string;\n /** Trait discriminant of the unanswered request. */\n readonly traitId: number;\n /** Method discriminant of the unanswered request. */\n readonly methodId: number;\n /** Deadline that elapsed, in milliseconds. */\n readonly timeoutMs: number;\n constructor(requestId: string, traitId: number, methodId: number, timeoutMs: number);\n}\n/**\n * Options accepted when constructing a transport.\n */\nexport interface CreateTransportOptions {\n /** Request ID namespace when multiple transports share a connection. Defaults to `p:`. */\n requestIdPrefix?: string;\n /** Wait for connection readiness before sending a request or starting a subscription. */\n prepare?: (ids: MethodIds) => Promise;\n /** Replace a failed connection after a malformed frame; otherwise the transport closes permanently. */\n onProtocolError?: (error: Error) => void;\n /**\n * Maximum time to wait for a matching response before rejecting the request.\n *\n * Defaults to 120 seconds. This bounds dead hosts and missed transport\n * handshakes while leaving interactive approval flows enough time to finish.\n * The handshake keeps its own shorter deadline, since a codec mismatch means\n * no answer is ever coming.\n */\n requestTimeoutMs?: number;\n}\n/**\n * Build a `TrUApiTransport` on top of a `WireProvider`, adding request/response\n * correlation and subscription start/receive/stop lifecycle handling.\n */\nexport declare function createTransport(provider: WireProvider, options?: CreateTransportOptions): TrUApiTransport;\n\n\n// generated/index.d.ts\n\n\n// generated/client.d.ts\nexport { ResultAsync, SubscriptionError };\nexport type { CallOptions, HostInitiatedSubscriptionHandler, ObservableLike, Observer, Result, Subscription, TrUApiTransport };\nexport declare const TRUAPI_VERSION: 2;\nexport declare const TRUAPI_CODEC_VERSION: 3;\nexport declare const TRUAPI_WIRE_SCHEMA_HASH: \"c8972ad11436a788\";\n/** Account lookup, aliasing, and proof generation. */\nexport declare class AccountClient {\n #private;\n constructor(transport: TrUApiTransport);\n /** Subscribe to account connection status changes. */\n connectionStatusSubscribe(): ObservableLike>;\n /** Retrieve a product-scoped account. */\n getAccount(request: T.HostAccountGetRequest, options?: CallOptions): ResultAsync>;\n /** Retrieve the contextual alias for a context and ring. */\n getAccountAlias(request: T.HostAccountGetAliasRequest, options?: CallOptions): ResultAsync>;\n /** Generate a ring VRF proof with an explicitly registered member key. */\n createAccountProof(request: T.HostAccountCreateProofRequest, options?: CallOptions): ResultAsync>;\n /**\n * Produce an sr25519 (schnorrkel) VRF signature from a product account.\n *\n * The host builds a Merlin transcript from `transcriptLabel` and `items`\n * and signs it with the account's key, returning the VRF pre-output and\n * proof. Authorized like signing: local when `AutoSigning` covers the\n * account, otherwise a per-call user confirmation.\n */\n signVrf(request: T.HostAccountSignVrfRequest, options?: CallOptions): ResultAsync>;\n /** Register a ring-VRF key owned by the calling product. */\n registerRingVrfKey(request: T.HostAccountRegisterRingVrfKeyRequest, options?: CallOptions): ResultAsync>;\n /** List registered ring-VRF keys owned by a product. */\n listRingVrfKeys(request: T.HostAccountListRingVrfKeysRequest, options?: CallOptions): ResultAsync, S.CallErrorValue>;\n /** Sign bytes directly with a registered ring-VRF member key. */\n ringVrfSign(request: T.HostAccountRingVrfSignRequest, options?: CallOptions): ResultAsync>;\n /**\n * Use a non-exportable Host Chat device for native cryptographic operations\n * and reviewed main-purse payments. The product owns native lifecycle frames,\n * subscriptions, delivery, retries, history, and acknowledgments.\n *\n * `Bind` resolves the peer independently. `Prepare` validates native plaintext\n * and returns signed ciphertext for product submission. `Open` authenticates\n * complete external statements and rejects reflected local output; it is not\n * an arbitrary decryption primitive. Incoming plaintext can contain incoming\n * bearer coin keys: persist the import intent securely and use generic payment\n * top-up before acknowledging. Wallet/device keys and outgoing main-purse\n * coin secrets never leave the Host.\n *\n * `Initialize` also advances private file transfers. Persist any legacy\n * migration view and ordinary prepared statements before `CommitMigration`.\n * `ContinueOpen` retrieves the next bounded page of an authenticated batch.\n * `ContinueState` retrieves remaining pages of a stable public state snapshot;\n * persist every page before committing its migration.\n *\n * Method 11 (the former raw-crypto interface) and method 12's former V1 actor\n * operations are retired, not forwarded. This boundary uses V2 payloads.\n */\n deviceChat(request: T.HostProductDeviceChatRequest, options?: CallOptions): ResultAsync>;\n /**\n * List non-product accounts the user owns.\n *\n * Current hosts do not expose non-product accounts, so the list is empty.\n */\n getLegacyAccounts(options?: CallOptions): ResultAsync>;\n /** Fetch the user's primary identity. */\n getUserId(options?: CallOptions): ResultAsync>;\n /**\n * Request the host to present the login flow to the user.\n *\n * Products should call this in response to a user action (e.g. tapping a\n * \"Sign in\" button), not automatically on load.\n */\n requestLogin(request: T.HostRequestLoginRequest, options?: CallOptions): ResultAsync>;\n}\n/** Chain interaction methods. */\nexport declare class ChainClient {\n #private;\n constructor(transport: TrUApiTransport);\n /** Follow the chain head and receive block events. */\n followHeadSubscribe({ request }: {\n request: T.RemoteChainHeadFollowRequest;\n }): ObservableLike>;\n /** Fetch a block header. */\n getHeadHeader(request: T.RemoteChainHeadHeaderRequest, options?: CallOptions): ResultAsync>;\n /** Fetch a block body. */\n getHeadBody(request: T.RemoteChainHeadBodyRequest, options?: CallOptions): ResultAsync>;\n /** Query runtime storage at a specific block. */\n getHeadStorage(request: T.RemoteChainHeadStorageRequest, options?: CallOptions): ResultAsync>;\n /** Invoke a runtime call at a specific block. */\n callHead(request: T.RemoteChainHeadCallRequest, options?: CallOptions): ResultAsync>;\n /** Release pinned blocks. */\n unpinHead(request: T.RemoteChainHeadUnpinRequest, options?: CallOptions): ResultAsync>;\n /** Continue a paused chain-head operation. */\n continueHead(request: T.RemoteChainHeadContinueRequest, options?: CallOptions): ResultAsync>;\n /** Stop a chain-head operation. */\n stopHeadOperation(request: T.RemoteChainHeadStopOperationRequest, options?: CallOptions): ResultAsync>;\n /** Fetch the canonical genesis hash for a chain. */\n getSpecGenesisHash(request: T.RemoteChainSpecGenesisHashRequest, options?: CallOptions): ResultAsync>;\n /** Fetch the display name of a chain. */\n getSpecChainName(request: T.RemoteChainSpecChainNameRequest, options?: CallOptions): ResultAsync>;\n /** Fetch the JSON-encoded properties of a chain. */\n getSpecProperties(request: T.RemoteChainSpecPropertiesRequest, options?: CallOptions): ResultAsync>;\n /** Broadcast a signed transaction. */\n broadcastTransaction(request: T.RemoteChainTransactionBroadcastRequest, options?: CallOptions): ResultAsync>;\n /** Stop a transaction broadcast. */\n stopTransaction(request: T.RemoteChainTransactionStopRequest, options?: CallOptions): ResultAsync>;\n /**\n * Resolve a chain identifier to its genesis hash against the host's\n * configured environment (RFC 0026).\n */\n getChainInfo(request: T.RemoteChainInfoRequest, options?: CallOptions): ResultAsync>;\n}\n/** Chat room, bot, and message APIs. */\nexport declare class ChatClient {\n #private;\n constructor(transport: TrUApiTransport);\n /** Create a chat room. */\n createRoom(request: T.HostChatCreateRoomRequest, options?: CallOptions): ResultAsync>;\n /** Register a chat bot. */\n registerBot(request: T.HostChatRegisterBotRequest, options?: CallOptions): ResultAsync>;\n /** Subscribe to the list of chat rooms. */\n listSubscribe(): ObservableLike>;\n /**\n * Post a message to a chat room.\n *\n * The host bounds and screens what it forwards. Message text is capped at\n * 16 KiB and keeps line breaks and tabs, but is rejected for other\n * control characters and for bidirectional overrides. Identifiers and\n * display names are normalized and screened. A message carries at most 32\n * actions and 32 media items, a custom payload at most 256 KiB, and a URL\n * at most 2 KiB which must be `https` or an inline raster image. A\n * rejection reports `MessageTooLarge` when the body or custom payload is\n * over budget, and `Unknown` with a reason naming the field otherwise.\n *\n * The returned `messageId` is the correlation key for any action the\n * message carries: a later `actionSubscribe` trigger names it.\n */\n postMessage(request: T.HostChatPostMessageRequest, options?: CallOptions): ResultAsync>;\n /** Subscribe to received chat actions. */\n actionSubscribe(): ObservableLike>;\n}\n/**\n * CoinPayment operations.\n *\n * RFC 0017 describes `Resolvable` values for long-running operations.\n * TrUAPI represents those as subscriptions whose items are the RFC status\n * updates.\n */\nexport declare class CoinPaymentClient {\n #private;\n constructor(transport: TrUApiTransport);\n /** Create a new firewalled CoinPayment purse. */\n createPurse(request: T.HostCoinPaymentCreatePurseRequest, options?: CallOptions): ResultAsync>;\n /** Query product-visible purse metadata and balance. */\n queryPurse(request: T.HostCoinPaymentQueryPurseRequest, options?: CallOptions): ResultAsync>;\n /** Transfer balance between local purses. */\n rebalancePurse({ request }: {\n request: T.HostCoinPaymentRebalancePurseRequest;\n }): ObservableLike>;\n /** Delete a purse after draining its balance into another local purse. */\n deletePurse({ request }: {\n request: T.HostCoinPaymentDeletePurseRequest;\n }): ObservableLike>;\n /** Create a receivable public key for depositing into a purse. */\n createReceivable(request: T.HostCoinPaymentCreateReceivableRequest, options?: CallOptions): ResultAsync>;\n /** Create a cheque paying from a local purse to a receivable. */\n createCheque(request: T.HostCoinPaymentCreateChequeRequest, options?: CallOptions): ResultAsync>;\n /** Claim coins from a cheque into the receivable's purse. */\n deposit({ request }: {\n request: T.HostCoinPaymentDepositRequest;\n }): ObservableLike>;\n /** Attempt to return coins associated with a receivable. */\n refund({ request }: {\n request: T.HostCoinPaymentRefundRequest;\n }): ObservableLike>;\n /** Listen for a cheque delivered through a standard transmission channel. */\n listenForPayment({ request }: {\n request: T.HostCoinPaymentListenForRequest;\n }): ObservableLike>;\n}\n/** Deterministic entropy derivation. */\nexport declare class EntropyClient {\n #private;\n constructor(transport: TrUApiTransport);\n /** Derive deterministic entropy. */\n derive(request: T.HostDeriveEntropyRequest, options?: CallOptions): ResultAsync>;\n}\n/** Local key/value storage scoped to the calling product. */\nexport declare class LocalStorageClient {\n #private;\n constructor(transport: TrUApiTransport);\n /** Read a value by key. */\n read(request: T.HostLocalStorageReadRequest, options?: CallOptions): ResultAsync>;\n /** Write a value to a key. */\n write(request: T.HostLocalStorageWriteRequest, options?: CallOptions): ResultAsync>;\n /** Clear a value by key. */\n clear(request: T.HostLocalStorageClearRequest, options?: CallOptions): ResultAsync>;\n /**\n * Subscribe to changes of one key in the product's own storage namespace.\n *\n * Emits the current value immediately, then one item per later write or\n * clear of the key by any of the product's runtimes. A write that leaves\n * the stored bytes unchanged emits nothing.\n */\n subscribe({ request }: {\n request: T.HostLocalStorageSubscribeRequest;\n }): ObservableLike>;\n}\n/** Host locale subscription. */\nexport declare class LocaleClient {\n #private;\n constructor(transport: TrUApiTransport);\n /** Subscribe to the host's selected locale. */\n subscribe(): ObservableLike>;\n}\n/** Notification methods for locally-rendered push notifications. */\nexport declare class NotificationsClient {\n #private;\n constructor(transport: TrUApiTransport);\n /**\n * Send a push notification to the user.\n *\n * Returns a [`NotificationId`](crate::v01::NotificationId) that can be\n * passed to [`cancel_push_notification`](Self::cancel_push_notification)\n * to retract a scheduled notification. When `scheduled_at` is set the host\n * persists the notification across restarts and fires it through the\n * platform-native scheduler. See [RFC 0019].\n *\n * [RFC 0019]: https://github.com/paritytech/host-rust-core/blob/main/docs/rfcs/0019-scheduled-notifications.md\n */\n sendPushNotification(request: T.HostPushNotificationRequest, options?: CallOptions): ResultAsync>;\n /**\n * Cancels a previously issued push notification.\n *\n * Cancellation is idempotent: returns `Ok(())` whether the notification is\n * still pending, already fired, or was never issued. See [RFC 0019].\n *\n * [RFC 0019]: https://github.com/paritytech/host-rust-core/blob/main/docs/rfcs/0019-scheduled-notifications.md\n */\n cancelPushNotification(request: T.HostPushNotificationCancelRequest, options?: CallOptions): ResultAsync>;\n}\n/** Payment request and balance/status subscription methods. */\nexport declare class PaymentClient {\n #private;\n constructor(transport: TrUApiTransport);\n /** Subscribe to payment balance updates. */\n balanceSubscribe({ request }: {\n request: T.HostPaymentBalanceSubscribeRequest;\n }): ObservableLike>;\n /** Request a payment from the user. */\n request(request: T.HostPaymentRequest, options?: CallOptions): ResultAsync>;\n /** Subscribe to payment lifecycle updates for a specific payment. */\n statusSubscribe({ request }: {\n request: T.HostPaymentStatusSubscribeRequest;\n }): ObservableLike>;\n /** Top up the user's payment balance. */\n topUp(request: T.HostPaymentTopUpRequest, options?: CallOptions): ResultAsync>;\n}\n/** Permission request methods. */\nexport declare class PermissionsClient {\n #private;\n constructor(transport: TrUApiTransport);\n /** Request a device-capability permission from the user. */\n requestDevicePermission(request: T.HostDevicePermissionRequest, options?: CallOptions): ResultAsync>;\n /**\n * Request a remote-operation permission.\n *\n * This example makes live requests to Frankfurter after permission is granted.\n */\n requestRemotePermission(request: T.RemotePermissionRequest, options?: CallOptions): ResultAsync>;\n}\n/**\n * Pocket cards backed by the calling product.\n *\n * The host owns the collection: a product observes its own cards and may\n * remove them, but cannot add one.\n */\nexport declare class PocketClient {\n #private;\n constructor(transport: TrUApiTransport);\n /**\n * Subscribe to the calling product's cards.\n *\n * Emits the whole set on subscribe and again after every change.\n */\n listSubscribe(): ObservableLike>;\n /**\n * Remove one of the calling product's cards.\n *\n * Removing a card that is not present succeeds. A privileged card is\n * refused with `Privileged`.\n */\n removeCard(request: T.HostPocketRemoveCardRequest, options?: CallOptions): ResultAsync>;\n}\n/** Preimage lookup and submission methods. */\nexport declare class PreimageClient {\n #private;\n constructor(transport: TrUApiTransport);\n /** Subscribe to preimage lookups for a given key. */\n lookupSubscribe({ request }: {\n request: T.RemotePreimageLookupSubscribeRequest;\n }): ObservableLike>;\n /** Submit a preimage. Returns the preimage key (hash) on success. */\n submit(request: HexString, options?: CallOptions): ResultAsync>;\n}\n/**\n * Profiles shown in host-owned UI.\n *\n * The product hands over an opaque reference; the host resolves, decrypts and\n * renders it. Profile bytes never return to the product.\n */\nexport declare class ProfileClient {\n #private;\n constructor(transport: TrUApiTransport);\n /**\n * Show the referenced profile in host-owned UI.\n *\n * Resolves once the host has taken the presentation, not when the user\n * dismisses it. Loading and fetch failures are shown to the user, not\n * returned; a reference this host cannot parse is `InvalidReference`.\n */\n present(request: T.HostProfilePresentRequest, options?: CallOptions): ResultAsync>;\n}\n/** Product-rendered bodies and the actions triggered inside them. */\nexport declare class RendererClient {\n #private;\n constructor(transport: TrUApiTransport);\n /**\n * Streams renderer trees for one product-rendered body. Each item\n * replaces the previous tree. The stream stays open while the body is\n * displayed so the product can redraw in place.\n */\n onRender(handler: HostInitiatedSubscriptionHandler>): {\n unsubscribe(): void;\n };\n /** Subscribe to actions triggered inside this product's rendered bodies. */\n actionSubscribe(): ObservableLike>;\n}\n/** Resource pre-allocation (allowance management). */\nexport declare class ResourceAllocationClient {\n #private;\n constructor(transport: TrUApiTransport);\n /** Request the host to pre-allocate one or more resources. */\n request(request: T.HostRequestResourceAllocationRequest, options?: CallOptions): ResultAsync>;\n}\n/** Signing operations. */\nexport declare class SigningClient {\n #private;\n constructor(transport: TrUApiTransport);\n /**\n * Construct a transaction for a product account.\n *\n * Served locally without a user confirmation when an RFC-0010 `AutoSigning`\n * grant covers the account; otherwise each call is confirmed by the user.\n *\n * Under Extrinsic V5, omitting `VerifyMultiSignature` from `extensions`\n * lets the host sign with the signer's key. Listing it \u2014 as `Disabled`,\n * with a proof in a later extension \u2014 encodes the given bytes verbatim and\n * returns an unsigned transaction.\n */\n createTransaction(request: T.ProductAccountTxPayload, options?: CallOptions): ResultAsync>;\n /**\n * Construct a transaction for a non-product (legacy) account.\n *\n * The V5 `VerifyMultiSignature` rule is the same as\n * [`Signing::create_transaction`]: omit it and the host signs, list it and\n * the given bytes are used with no host signature.\n */\n createTransactionWithLegacyAccount(request: T.LegacyAccountTxPayload, options?: CallOptions): ResultAsync>;\n /** Sign raw bytes with a non-product account. */\n signRawWithLegacyAccount(request: T.HostSignRawWithLegacyAccountRequest, options?: CallOptions): ResultAsync>;\n /** Sign an extrinsic payload with a non-product account. */\n signPayloadWithLegacyAccount(request: T.HostSignPayloadWithLegacyAccountRequest, options?: CallOptions): ResultAsync>;\n /**\n * Sign raw bytes or a message.\n *\n * Served locally without a user confirmation when an RFC-0010 `AutoSigning`\n * grant covers the account; otherwise each call is confirmed by the user.\n */\n signRaw(request: T.HostSignRawRequest, options?: CallOptions): ResultAsync>;\n /**\n * Sign an extrinsic payload.\n *\n * Served locally without a user confirmation when an RFC-0010 `AutoSigning`\n * grant covers the account; otherwise each call is confirmed by the user.\n */\n signPayload(request: T.HostSignPayloadRequest, options?: CallOptions): ResultAsync>;\n /**\n * Sign the supplied data without adding or removing a watermark.\n *\n * Temporary compatibility API for runtime ownership proofs, including the\n * 32-byte Resources alias used by Humanity. Payload decoding matches\n * watermarked signing, but the decoded bytes are signed exactly as supplied.\n * This permits transaction-shaped data and requires signing authorization\n * and explicit user confirmation.\n *\n * @deprecated Temporary unwatermarked signing; migrate to watermarked signing when the runtime supports it. This API will be removed. See \n */\n signRawUnwatermarkedDeprecated(request: T.HostSignRawRequest, options?: CallOptions): ResultAsync>;\n /**\n * Sign the supplied data without adding or removing a watermark.\n *\n * Temporary compatibility API for runtime ownership proofs, including the\n * 32-byte Resources alias used by Humanity. Payload decoding matches\n * watermarked signing, but the decoded bytes are signed exactly as supplied.\n * This permits transaction-shaped data and requires signing authorization\n * and explicit user confirmation.\n *\n * @deprecated Temporary unwatermarked signing; migrate to watermarked signing when the runtime supports it. This API will be removed. See \n */\n signRawUnwatermarkedDeprecatedWithLegacyAccount(request: T.HostSignRawWithLegacyAccountRequest, options?: CallOptions): ResultAsync>;\n}\n/** Statement store methods. */\nexport declare class StatementStoreClient {\n #private;\n constructor(transport: TrUApiTransport);\n /** Subscribe to statements matching a topic filter. */\n subscribe({ request }: {\n request: T.RemoteStatementStoreSubscribeRequest;\n }): ObservableLike>;\n /**\n * Create a proof for a statement.\n *\n * **Deprecated:** use [`create_proof_authorized`](Self::create_proof_authorized)\n * instead, which uses a pre-allocated allowance account and does not\n * require a per-call signing prompt. Pairing hosts may reject this method\n * when their signing channel cannot sign statement proof payloads exactly.\n */\n createProof(request: T.RemoteStatementStoreCreateProofRequest, options?: CallOptions): ResultAsync>;\n /**\n * Create a proof for a statement using a pre-allocated allowance account,\n * bypassing the per-call signing prompt.\n */\n createProofAuthorized(request: T.Statement, options?: CallOptions): ResultAsync>;\n /**\n * Submit a signed statement to the network. The request body is the\n * [`SignedStatement`](crate::v01::SignedStatement) directly (no wrapping\n * struct), matching upstream `triangle-js-sdks`.\n */\n submit(request: T.SignedStatement, options?: CallOptions): ResultAsync>;\n}\n/**\n * General-purpose TrUAPI methods for handshake, feature detection,\n * navigation, and runtime information.\n */\nexport declare class SystemClient {\n #private;\n constructor(transport: TrUApiTransport);\n /** Negotiate the wire codec version with the product. */\n handshake(options?: CallOptions): ResultAsync>;\n /** Query whether the host supports a specific feature. */\n featureSupported(request: T.HostFeatureSupportedRequest, options?: CallOptions): ResultAsync>;\n /**\n * Request the host to open a URL.\n *\n * An `http` or `https` URL outside the ecosystem needs a\n * `RemotePermission::Remote` grant for the target host, and prompts for one\n * on first use. dotNS names, `localhost`, and the app-handoff schemes\n * (`mailto:`, `tel:`, `polkadot:`, `dot:`) consume no grant. The grant is\n * per host and shared with outbound data access to that host, so approving\n * one covers the other.\n */\n navigateTo(request: T.HostNavigateToRequest, options?: CallOptions): ResultAsync>;\n /**\n * Report the host's identity and version.\n *\n * Returns the host's platform, name, and version so a product knows\n * exactly which host \u2014 and which build of it \u2014 is running it: for\n * adapting to the host, telemetry, and attributing behaviour to a\n * concrete build in diagnostics and bug reports.\n */\n info(options?: CallOptions): ResultAsync>;\n /** Return the product context bound to the current host runtime. */\n getProductContext(options?: CallOptions): ResultAsync>;\n}\n/** Host theme subscription. */\nexport declare class ThemeClient {\n #private;\n constructor(transport: TrUApiTransport);\n /** Subscribe to host theme changes. */\n subscribe(): ObservableLike>;\n}\n/**\n * Worker background-operation APIs.\n *\n * The host keeps a product's worker running while it holds at least one open\n * operation, which is how a worker outlives the surface that started it.\n */\nexport declare class WorkerClient {\n #private;\n constructor(transport: TrUApiTransport);\n /** Begin a pending operation. */\n beginOperation(request: T.HostWorkerBeginOperationRequest, options?: CallOptions): ResultAsync>;\n /**\n * End a pending operation. Idempotent: an unknown or already-ended id\n * succeeds, so a retry after an ambiguous failure is safe.\n */\n endOperation(request: T.HostWorkerEndOperationRequest, options?: CallOptions): ResultAsync>;\n}\nexport interface TrUApiClient {\n readonly account: AccountClient;\n readonly chain: ChainClient;\n readonly chat: ChatClient;\n readonly coinPayment: CoinPaymentClient;\n readonly entropy: EntropyClient;\n readonly localStorage: LocalStorageClient;\n readonly locale: LocaleClient;\n readonly notifications: NotificationsClient;\n readonly payment: PaymentClient;\n readonly permissions: PermissionsClient;\n readonly pocket: PocketClient;\n readonly preimage: PreimageClient;\n readonly profile: ProfileClient;\n readonly renderer: RendererClient;\n readonly resourceAllocation: ResourceAllocationClient;\n readonly signing: SigningClient;\n readonly statementStore: StatementStoreClient;\n readonly system: SystemClient;\n readonly theme: ThemeClient;\n readonly worker: WorkerClient;\n}\nexport type Client = TrUApiClient;\n/** Creates the generated client facade by binding each service namespace to the\n * shared transport instance. */\nexport declare function createClient(transport: TrUApiTransport): TrUApiClient;\n\n\n// development.d.ts\n/** Same as `HostAccountCreateProofRequest`, with the 32-byte context given raw. */\nexport interface DevelopmentCreateProofRequest extends Omit {\n /** The exact 32 bytes the proof is bound to, as `0x`-prefixed hex. */\n context: HexString;\n}\n/**\n * `account.createAccountProof` with a verbatim 32-byte proof context instead of\n * a product-namespaced one.\n *\n */\nexport declare function development_createAccountProof(client: Pick, request: DevelopmentCreateProofRequest): ResultAsync>;\n"; +export declare const truapiDts = "// neverthrow (inlined)\n\ninterface ErrorConfig {\n withStackTrace: boolean;\n}\n\ndeclare class ResultAsync implements PromiseLike> {\n private _promise;\n constructor(res: Promise>);\n static fromSafePromise(promise: PromiseLike): ResultAsync;\n static fromPromise(promise: PromiseLike, errorFn: (e: unknown) => E): ResultAsync;\n static fromThrowable(fn: (...args: A) => Promise, errorFn?: (err: unknown) => E): (...args: A) => ResultAsync;\n static combine, ...ResultAsync[]]>(asyncResultList: T): CombineResultAsyncs;\n static combine[]>(asyncResultList: T): CombineResultAsyncs;\n static combineWithAllErrors, ...ResultAsync[]]>(asyncResultList: T): CombineResultsWithAllErrorsArrayAsync;\n static combineWithAllErrors[]>(asyncResultList: T): CombineResultsWithAllErrorsArrayAsync;\n map(f: (t: T) => A | Promise): ResultAsync;\n andThrough(f: (t: T) => Result | ResultAsync): ResultAsync;\n andTee(f: (t: T) => unknown): ResultAsync;\n orTee(f: (t: E) => unknown): ResultAsync;\n mapErr(f: (e: E) => U | Promise): ResultAsync;\n andThen>(f: (t: T) => R): ResultAsync, InferErrTypes | E>;\n andThen>(f: (t: T) => R): ResultAsync, InferAsyncErrTypes | E>;\n andThen(f: (t: T) => Result | ResultAsync): ResultAsync;\n orElse>(f: (e: E) => R): ResultAsync | T, InferErrTypes>;\n orElse>(f: (e: E) => R): ResultAsync | T, InferAsyncErrTypes>;\n orElse(f: (e: E) => Result | ResultAsync): ResultAsync;\n match(ok: (t: T) => A, _err: (e: E) => B): Promise;\n unwrapOr(t: A): Promise;\n /**\n * @deprecated will be removed in 9.0.0.\n *\n * You can use `safeTry` without this method.\n * @example\n * ```typescript\n * safeTry(async function* () {\n * const okValue = yield* yourResult\n * })\n * ```\n * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.\n */\n safeUnwrap(): AsyncGenerator, T>;\n then(successCallback?: (res: Result) => A | PromiseLike, failureCallback?: (reason: unknown) => B | PromiseLike): PromiseLike;\n [Symbol.asyncIterator](): AsyncGenerator, T>;\n}\ndeclare function okAsync(value: T): ResultAsync;\ndeclare function okAsync(value: void): ResultAsync;\ndeclare function errAsync(err: E): ResultAsync;\ndeclare function errAsync(err: void): ResultAsync;\ndeclare const fromPromise: typeof ResultAsync.fromPromise;\ndeclare const fromSafePromise: typeof ResultAsync.fromSafePromise;\ndeclare const fromAsyncThrowable: typeof ResultAsync.fromThrowable;\ndeclare type CombineResultAsyncs[]> = IsLiteralArray extends 1 ? TraverseAsync> : ResultAsync, ExtractErrAsyncTypes[number]>;\ndeclare type CombineResultsWithAllErrorsArrayAsync[]> = IsLiteralArray extends 1 ? TraverseWithAllErrorsAsync> : ResultAsync, ExtractErrAsyncTypes[number][]>;\ndeclare type UnwrapAsync = IsLiteralArray extends 1 ? Writable extends [infer H, ...infer Rest] ? H extends PromiseLike ? HI extends Result ? [Dedup, ...UnwrapAsync] : never : never : [] : T extends Array ? A extends PromiseLike ? HI extends Result ? Ok[] : never : never : never;\ndeclare type TraverseAsync = IsLiteralArray extends 1 ? Combine extends [infer Oks, infer Errs] ? ResultAsync, MembersToUnion> : never : T extends Array ? Combine, Depth> extends [infer Oks, infer Errs] ? Oks extends unknown[] ? Errs extends unknown[] ? ResultAsync, MembersToUnion> : ResultAsync, Errs> : Errs extends unknown[] ? ResultAsync> : ResultAsync : never : never;\ndeclare type TraverseWithAllErrorsAsync = TraverseAsync extends ResultAsync ? ResultAsync : never;\ndeclare type Writable = T extends ReadonlyArray ? [...T] : T;\n\ndeclare type ExtractOkTypes[]> = {\n [idx in keyof T]: T[idx] extends Result ? U : never;\n};\ndeclare type ExtractOkAsyncTypes[]> = {\n [idx in keyof T]: T[idx] extends ResultAsync ? U : never;\n};\ndeclare type ExtractErrTypes[]> = {\n [idx in keyof T]: T[idx] extends Result ? E : never;\n};\ndeclare type ExtractErrAsyncTypes[]> = {\n [idx in keyof T]: T[idx] extends ResultAsync ? E : never;\n};\ndeclare type InferOkTypes = R extends Result ? T : never;\ndeclare type InferErrTypes = R extends Result ? E : never;\ndeclare type InferAsyncOkTypes = R extends ResultAsync ? T : never;\ndeclare type InferAsyncErrTypes = R extends ResultAsync ? E : never;\n\ndeclare namespace Result {\n /**\n * Wraps a function with a try catch, creating a new function with the same\n * arguments but returning `Ok` if successful, `Err` if the function throws\n *\n * @param fn function to wrap with ok on success or err on failure\n * @param errorFn when an error is thrown, this will wrap the error result if provided\n */\n function fromThrowable any, E>(fn: Fn, errorFn?: (e: unknown) => E): (...args: Parameters) => Result, E>;\n function combine, ...Result[]]>(resultList: T): CombineResults;\n function combine[]>(resultList: T): CombineResults;\n function combineWithAllErrors, ...Result[]]>(resultList: T): CombineResultsWithAllErrorsArray;\n function combineWithAllErrors[]>(resultList: T): CombineResultsWithAllErrorsArray;\n}\ndeclare type Result = Ok | Err;\ndeclare function ok(value: T): Ok;\ndeclare function ok(value: void): Ok;\ndeclare function err(err: E): Err;\ndeclare function err(err: E): Err;\ndeclare function err(err: void): Err;\n/**\n * Evaluates the given generator to a Result returned or an Err yielded from it,\n * whichever comes first.\n *\n * This function is intended to emulate Rust's ? operator.\n * See `/tests/safeTry.test.ts` for examples.\n *\n * @param body - What is evaluated. In body, `yield* result` works as\n * Rust's `result?` expression.\n * @returns The first occurrence of either an yielded Err or a returned Result.\n */\ndeclare function safeTry(body: () => Generator, Result>): Result;\ndeclare function safeTry, GeneratorReturnResult extends Result>(body: () => Generator): Result, InferErrTypes | InferErrTypes>;\n/**\n * Evaluates the given generator to a Result returned or an Err yielded from it,\n * whichever comes first.\n *\n * This function is intended to emulate Rust's ? operator.\n * See `/tests/safeTry.test.ts` for examples.\n *\n * @param body - What is evaluated. In body, `yield* result` and\n * `yield* resultAsync` work as Rust's `result?` expression.\n * @returns The first occurrence of either an yielded Err or a returned Result.\n */\ndeclare function safeTry(body: () => AsyncGenerator, Result>): ResultAsync;\ndeclare function safeTry, GeneratorReturnResult extends Result>(body: () => AsyncGenerator): ResultAsync, InferErrTypes | InferErrTypes>;\ninterface IResult {\n /**\n * Used to check if a `Result` is an `OK`\n *\n * @returns `true` if the result is an `OK` variant of Result\n */\n isOk(): this is Ok;\n /**\n * Used to check if a `Result` is an `Err`\n *\n * @returns `true` if the result is an `Err` variant of Result\n */\n isErr(): this is Err;\n /**\n * Maps a `Result` to `Result`\n * by applying a function to a contained `Ok` value, leaving an `Err` value\n * untouched.\n *\n * @param f The function to apply an `OK` value\n * @returns the result of applying `f` or an `Err` untouched\n */\n map(f: (t: T) => A): Result;\n /**\n * Maps a `Result` to `Result` by applying a function to a\n * contained `Err` value, leaving an `Ok` value untouched.\n *\n * This function can be used to pass through a successful result while\n * handling an error.\n *\n * @param f a function to apply to the error `Err` value\n */\n mapErr(f: (e: E) => U): Result;\n /**\n * Similar to `map` Except you must return a new `Result`.\n *\n * This is useful for when you need to do a subsequent computation using the\n * inner `T` value, but that computation might fail.\n * Additionally, `andThen` is really useful as a tool to flatten a\n * `Result, E1>` into a `Result` (see example below).\n *\n * @param f The function to apply to the current value\n */\n andThen>(f: (t: T) => R): Result, InferErrTypes | E>;\n andThen(f: (t: T) => Result): Result;\n /**\n * This \"tee\"s the current value to an passed-in computation such as side\n * effect functions but still returns the same current value as the result.\n *\n * This is useful when you want to pass the current result to your side-track\n * work such as logging but want to continue main-track work after that.\n * This method does not care about the result of the passed in computation.\n *\n * @param f The function to apply to the current value\n */\n andTee(f: (t: T) => unknown): Result;\n /**\n * This \"tee\"s the current `Err` value to an passed-in computation such as side\n * effect functions but still returns the same `Err` value as the result.\n *\n * This is useful when you want to pass the current `Err` value to your side-track\n * work such as logging but want to continue error-track work after that.\n * This method does not care about the result of the passed in computation.\n *\n * @param f The function to apply to the current `Err` value\n */\n orTee(f: (t: E) => unknown): Result;\n /**\n * Similar to `andTee` except error result of the computation will be passed\n * to the downstream in case of an error.\n *\n * This version is useful when you want to make side-effects but in case of an\n * error, you want to pass the error to the downstream.\n *\n * @param f The function to apply to the current value\n */\n andThrough>(f: (t: T) => R): Result | E>;\n andThrough(f: (t: T) => Result): Result;\n /**\n * Takes an `Err` value and maps it to a `Result`.\n *\n * This is useful for error recovery.\n *\n *\n * @param f A function to apply to an `Err` value, leaving `Ok` values\n * untouched.\n */\n orElse>(f: (e: E) => R): Result | T, InferErrTypes>;\n orElse(f: (e: E) => Result): Result;\n /**\n * Similar to `map` Except you must return a new `Result`.\n *\n * This is useful for when you need to do a subsequent async computation using\n * the inner `T` value, but that computation might fail. Must return a ResultAsync\n *\n * @param f The function that returns a `ResultAsync` to apply to the current\n * value\n */\n asyncAndThen(f: (t: T) => ResultAsync): ResultAsync;\n /**\n * Maps a `Result` to `ResultAsync`\n * by applying an async function to a contained `Ok` value, leaving an `Err`\n * value untouched.\n *\n * @param f An async function to apply an `OK` value\n */\n asyncMap(f: (t: T) => Promise): ResultAsync;\n /**\n * Unwrap the `Ok` value, or return the default if there is an `Err`\n *\n * @param v the default value to return if there is an `Err`\n */\n unwrapOr(v: A): T | A;\n /**\n *\n * Given 2 functions (one for the `Ok` variant and one for the `Err` variant)\n * execute the function that matches the `Result` variant.\n *\n * Match callbacks do not necessitate to return a `Result`, however you can\n * return a `Result` if you want to.\n *\n * `match` is like chaining `map` and `mapErr`, with the distinction that\n * with `match` both functions must have the same return type.\n *\n * @param ok\n * @param err\n */\n match(ok: (t: T) => A, err: (e: E) => B): A | B;\n /**\n * @deprecated will be removed in 9.0.0.\n *\n * You can use `safeTry` without this method.\n * @example\n * ```typescript\n * safeTry(function* () {\n * const okValue = yield* yourResult\n * })\n * ```\n * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.\n */\n safeUnwrap(): Generator, T>;\n /**\n * **This method is unsafe, and should only be used in a test environments**\n *\n * Takes a `Result` and returns a `T` when the result is an `Ok`, otherwise it throws a custom object.\n *\n * @param config\n */\n _unsafeUnwrap(config?: ErrorConfig): T;\n /**\n * **This method is unsafe, and should only be used in a test environments**\n *\n * takes a `Result` and returns a `E` when the result is an `Err`,\n * otherwise it throws a custom object.\n *\n * @param config\n */\n _unsafeUnwrapErr(config?: ErrorConfig): E;\n}\ndeclare class Ok implements IResult {\n readonly value: T;\n constructor(value: T);\n isOk(): this is Ok;\n isErr(): this is Err;\n map(f: (t: T) => A): Result;\n mapErr(_f: (e: E) => U): Result;\n andThen>(f: (t: T) => R): Result, InferErrTypes | E>;\n andThen(f: (t: T) => Result): Result;\n andThrough>(f: (t: T) => R): Result | E>;\n andThrough(f: (t: T) => Result): Result;\n andTee(f: (t: T) => unknown): Result;\n orTee(_f: (t: E) => unknown): Result;\n orElse>(_f: (e: E) => R): Result | T, InferErrTypes>;\n orElse(_f: (e: E) => Result): Result;\n asyncAndThen(f: (t: T) => ResultAsync): ResultAsync;\n asyncAndThrough>(f: (t: T) => R): ResultAsync | E>;\n asyncAndThrough(f: (t: T) => ResultAsync): ResultAsync;\n asyncMap(f: (t: T) => Promise): ResultAsync;\n unwrapOr(_v: A): T | A;\n match(ok: (t: T) => A, _err: (e: E) => B): A | B;\n safeUnwrap(): Generator, T>;\n _unsafeUnwrap(_?: ErrorConfig): T;\n _unsafeUnwrapErr(config?: ErrorConfig): E;\n [Symbol.iterator](): Generator, T>;\n}\ndeclare class Err implements IResult {\n readonly error: E;\n constructor(error: E);\n isOk(): this is Ok;\n isErr(): this is Err;\n map(_f: (t: T) => A): Result;\n mapErr(f: (e: E) => U): Result;\n andThrough(_f: (t: T) => Result): Result;\n andTee(_f: (t: T) => unknown): Result;\n orTee(f: (t: E) => unknown): Result;\n andThen>(_f: (t: T) => R): Result, InferErrTypes | E>;\n andThen(_f: (t: T) => Result): Result;\n orElse>(f: (e: E) => R): Result | T, InferErrTypes>;\n orElse(f: (e: E) => Result): Result;\n asyncAndThen(_f: (t: T) => ResultAsync): ResultAsync;\n asyncAndThrough(_f: (t: T) => ResultAsync): ResultAsync;\n asyncMap(_f: (t: T) => Promise): ResultAsync;\n unwrapOr(v: A): T | A;\n match(_ok: (t: T) => A, err: (e: E) => B): A | B;\n safeUnwrap(): Generator, T>;\n _unsafeUnwrap(config?: ErrorConfig): T;\n _unsafeUnwrapErr(_?: ErrorConfig): E;\n [Symbol.iterator](): Generator, T>;\n}\ndeclare const fromThrowable: typeof Result.fromThrowable;\ndeclare type Prev = [\n never,\n 0,\n 1,\n 2,\n 3,\n 4,\n 5,\n 6,\n 7,\n 8,\n 9,\n 10,\n 11,\n 12,\n 13,\n 14,\n 15,\n 16,\n 17,\n 18,\n 19,\n 20,\n 21,\n 22,\n 23,\n 24,\n 25,\n 26,\n 27,\n 28,\n 29,\n 30,\n 31,\n 32,\n 33,\n 34,\n 35,\n 36,\n 37,\n 38,\n 39,\n 40,\n 41,\n 42,\n 43,\n 44,\n 45,\n 46,\n 47,\n 48,\n 49,\n ...0[]\n];\ndeclare type CollectResults = [\n Depth\n] extends [never] ? [] : T extends [infer H, ...infer Rest] ? H extends Result ? CollectResults : never : Collected;\ndeclare type Transpose = A extends [infer T, ...infer Rest] ? T extends [infer L, infer R] ? Transposed extends [infer PL, infer PR] ? PL extends unknown[] ? PR extends unknown[] ? Transpose : never : never : Transpose : Transposed : Transposed;\ndeclare type Combine = Transpose, [], Depth> extends [\n infer L,\n infer R\n] ? [UnknownMembersToNever, UnknownMembersToNever] : Transpose, [], Depth> extends [] ? [[], []] : never;\ndeclare type Dedup = T extends Result ? [unknown] extends [RL] ? Err : Ok : T;\ndeclare type MemberListOf = ((T extends unknown ? (t: T) => T : never) extends infer U ? (U extends unknown ? (u: U) => unknown : never) extends (v: infer V) => unknown ? V : never : never) extends (_: unknown) => infer W ? [...MemberListOf>, W] : [];\ndeclare type EmptyArrayToNever = T extends [] ? never : NeverArrayToNever extends 1 ? T extends [never, ...infer Rest] ? [EmptyArrayToNever] extends [never] ? never : T : T : T;\ndeclare type UnknownMembersToNever = T extends [infer H, ...infer R] ? [[unknown] extends [H] ? never : H, ...UnknownMembersToNever] : T;\ndeclare type MembersToUnion = T extends unknown[] ? T[number] : never;\ndeclare type IsLiteralArray = T extends {\n length: infer L;\n} ? L extends number ? number extends L ? 0 : 1 : 0 : 0;\ndeclare type Traverse = Combine extends [infer Oks, infer Errs] ? Result, MembersToUnion> : never;\ndeclare type TraverseWithAllErrors = Traverse extends Result ? Result : never;\ndeclare type CombineResults[]> = IsLiteralArray extends 1 ? Traverse : Result, ExtractErrTypes[number]>;\ndeclare type CombineResultsWithAllErrorsArray[]> = IsLiteralArray extends 1 ? TraverseWithAllErrors : Result, ExtractErrTypes[number][]>;\n\n\n\n// scale.d.ts (module-scope)\n\n/** SCALE codec primitives used by the generated client.\n *\n * Thin wrapper over `scale-ts`: re-exports its primitives and combinators,\n * plus the Polkadot-flavour helpers it does not ship (hex-encoded bytes,\n * lazy recursive codecs, and `V`-indexed tagged unions).\n */\nimport { type Codec, type ResultPayload } from \"scale-ts\";\nexport type { Codec };\nexport type { ResultPayload } from \"scale-ts\";\n/**\n * Bare-named type alias matching generated codegen's naming convention for\n * generic wire types: `Result` is used as both a value (the codec\n * builder re-exported below) and a type (this alias for scale-ts's own\n * `ResultPayload`) in generated `types.ts`.\n */\nexport type Result = ResultPayload;\nexport { Bytes, Enum, Option, Result, Struct, Tuple, Vector, _void, compact, i8, i16, i32, i64, i128, str, u8, u16, u32, u64, u128, } from \"scale-ts\";\n/** SCALE boolean, rejecting byte values Rust cannot decode. */\nexport declare const bool: Codec;\n/**\n * Substrate `OptionBool`: a one-byte `Option`.\n *\n * Canonical SCALE encoding (matches `parity_scale_codec::OptionBool`):\n * `undefined` \u2192 `0`, `true` \u2192 `1`, `false` \u2192 `2`.\n */\nexport declare const OptionBool: Codec;\n/** Hex-encoded byte string, e.g. `\"0xdeadbeef\"`. */\nexport type HexString = `0x${string}`;\n/** Assert that a string is a valid hex string (`0x...`). */\nexport declare function toHexString(value: string): HexString;\n/** Encode a byte array as a lower-case hex string with a `0x` prefix. */\nexport declare function bytesToHex(bytes: Uint8Array): HexString;\n/** Decode a hex string into a byte array. Tolerates a missing `0x` prefix. */\nexport declare function hexToBytes(hex: string): Uint8Array;\n/**\n * SCALE codec for hex-encoded byte strings.\n *\n * Encode accepts a `0x`-prefixed hex string and emits SCALE bytes; decode\n * returns the bytes as a hex string. Pass `length` for fixed-size byte arrays\n * (`[u8; N]`); omit it for variable-length byte vectors (`Vec`).\n */\nexport declare function Hex(length?: number): Codec;\n/**\n * Same wire format as `scale-ts`'s `Enum`, but exposes `value` as optional in\n * the public TS type when the variant codec is `Codec`. Lets unit\n * variants of mixed enums round-trip as `{ tag: \"X\" }` (no `value` key).\n */\nexport declare function TaggedUnion(inner: O): Codec>;\n/** Public TS value for Rust's derived `CallError` enum. */\nexport type CallErrorValue = {\n tag: \"Domain\";\n value: D;\n} | {\n tag: \"Denied\";\n value?: undefined;\n} | {\n tag: \"Unsupported\";\n value?: undefined;\n} | {\n tag: \"MalformedFrame\";\n value: {\n reason: string;\n };\n} | {\n tag: \"HostFailure\";\n value: {\n reason: string;\n };\n} | {\n tag: \"Cancelled\";\n value?: undefined;\n};\n/** SCALE codec for Rust's derived `CallError` enum. */\nexport declare function CallError(domain: Codec): Codec>;\ntype TaggedUnionCodecs = {\n [Sym: symbol]: never;\n [Num: number]: never;\n [Str: string]: Codec;\n};\ntype TaggedUnionValue = {\n [K in keyof O & string]: O[K] extends Codec ? [T] extends [undefined] ? {\n tag: K;\n value?: undefined;\n } : {\n tag: K;\n value: T;\n } : never;\n}[keyof O & string];\n/**\n * Enum without payloads \u2014 maps string labels to SCALE discriminant bytes.\n *\n * `scale-ts` models `Enum({ Foo: _void, Bar: _void })` as tagged objects. For\n * user-facing TrUAPI enums with only unit variants, we keep the public TS shape\n * as a plain string union instead.\n */\nexport declare function Status(...variants: readonly T[]): Codec;\n/**\n * Defers codec construction until first use so recursive generated codecs can\n * reference each other safely.\n */\nexport declare function lazy(factory: () => Codec): Codec;\ntype IndexedVariantCodec = readonly [index: number, codec: Codec];\ntype IndexedVariantValue>, K extends keyof Variants & string> = Variants[K] extends IndexedVariantCodec ? [T] extends [undefined] ? {\n tag: K;\n value?: undefined;\n} : {\n tag: K;\n value: T;\n} : never;\n/**\n * Builds a tagged union codec with explicit SCALE discriminants.\n *\n * `scale-ts` assigns enum indexes by object key order. TrUAPI versioned enums pin\n * `V` to index `N - 1`, including V2-only enums, so generated codecs use this\n * helper for versioned wire wrappers.\n */\nexport declare function indexedTaggedUnion>>(variants: Variants): Codec<{\n [K in keyof Variants & string]: IndexedVariantValue;\n}[keyof Variants & string]>;\n\n\n// generated/types.d.ts (namespace T)\n\ndeclare namespace T {\n/** A 32-byte raw account identifier used for legacy (non-product) accounts. */\nexport type AccountId = HexString;\nexport const AccountId: Codec;\n/**\n * A press on a button the host draws for a `ChatMessageContent::Actions`\n * message.\n */\nexport interface ActionTrigger {\n /**\n * Message containing the action, as returned by `Chat::post_message` in\n * [`HostChatPostMessageResponse::message_id`].\n */\n messageId: string;\n /** Which action was triggered. */\n actionId: string;\n /** Optional additional data. */\n payload?: HexString;\n}\nexport const ActionTrigger: Codec;\n/**\n * A resource the host can pre-allocate on behalf of the product (RFC 0010).\n *\n * For the slot-table allowances (`StatementStoreAllowance`,\n * `BulletinAllowance`, `SmartContractAllowance`), pre-allocation is\n * opportunistic and the host may also fulfil the allowance implicitly on the\n * first submission. `AutoSigning` must be requested explicitly through this\n * call.\n */\nexport type AllocatableResource = \n/** Statement Store slot allowance for the product's own allowance account. */\n{\n tag: \"StatementStoreAllowance\";\n value?: undefined;\n}\n/** Bulletin chain slot allowance for the product's own allowance account. */\n | {\n tag: \"BulletinAllowance\";\n value?: undefined;\n}\n/**\n * Pre-warmed PGAS balance for the product account selected by this\n * derivation index.\n */\n | {\n tag: \"SmartContractAllowance\";\n value: DerivationIndex;\n}\n/** Permission to sign on the product's behalf without per-call user prompts. */\n | {\n tag: \"AutoSigning\";\n value?: undefined;\n}\n/**\n * Current UTC-day Statement Store allowance whose target is the product\n * account selected by this derivation index.\n */\n | {\n tag: \"ProductStatementStoreAllowance\";\n value: DerivationIndex;\n};\nexport const AllocatableResource: Codec;\n/** Outcome of allocating a single resource (RFC 0010). */\nexport type AllocationOutcome = \"Allocated\" | \"Rejected\" | \"NotAvailable\";\nexport const AllocationOutcome: Codec;\n/** Main-axis distribution of children. */\nexport type Arrangement = \"Start\" | \"End\" | \"Center\" | \"SpaceBetween\" | \"SpaceAround\" | \"SpaceEvenly\";\nexport const Arrangement: Codec;\n/** Background styling. */\nexport interface Background {\n /** Background color. */\n color: ColorToken;\n /** Background shape. */\n shape?: Shape;\n}\nexport const Background: Codec;\n/**\n * Balance amount for payment operations. Interpreted according to the host's\n * single fixed payment asset (e.g. pUSD).\n */\nexport type Balance = bigint;\nexport const Balance: Codec;\n/**\n * How a node composites with what is behind it. The values are those common\n * to CSS `mix-blend-mode`, SwiftUI `BlendMode` and Compose `BlendMode`.\n */\nexport type BlendingMode = \"Normal\" | \"Multiply\" | \"Screen\" | \"Overlay\" | \"Darken\" | \"Lighten\" | \"ColorDodge\" | \"ColorBurn\" | \"HardLight\" | \"SoftLight\" | \"Difference\" | \"Exclusion\" | \"Hue\" | \"Saturation\" | \"Color\" | \"Luminosity\";\nexport const BlendingMode: Codec;\n/** Border styling. */\nexport interface BorderStyle {\n /** Border width. */\n width: Size;\n /** Border color. */\n color: ColorToken;\n /** Border shape. */\n shape?: Shape;\n}\nexport const BorderStyle: Codec;\n/** Properties of a `Box`. */\nexport interface BoxProps {\n /** Placement of content within the box. */\n contentAlignment?: ContentAlignment;\n}\nexport const BoxProps: Codec;\n/** Properties of a `Button`. */\nexport interface ButtonProps {\n /** Button label. */\n text: string;\n /** Button emphasis. */\n variant?: ButtonVariant;\n /** Whether the button accepts presses. Absent leaves the default to the host. */\n enabled?: boolean;\n /**\n * Whether the button shows a loading state. A loading button accepts no\n * presses. Absent leaves the default to the host.\n */\n loading?: boolean;\n /** Action triggered on press. A button without one is inert. */\n clickAction?: string;\n}\nexport const ButtonProps: Codec;\n/** Button emphasis. */\nexport type ButtonVariant = \"Primary\" | \"Secondary\" | \"Text\";\nexport const ButtonVariant: Codec;\n/**\n * A 32-byte value, passed as plain bytes on FFI surfaces. Version-neutral:\n * the FFI conversion below applies to `[u8; 32]` fields in every protocol\n * version.\n */\nexport type Bytes32 = HexString;\nexport const Bytes32: Codec;\n/** Role of a chain within the host's configured environment. */\nexport type ChainIdentifier = \"Relay\" | \"AssetHub\" | \"People\" | \"Bulletin\";\nexport const ChainIdentifier: Codec;\n/** A clickable action button in a chat message. */\nexport interface ChatAction {\n /** Action identifier. */\n actionId: string;\n /** Button label. */\n title: string;\n}\nexport const ChatAction: Codec;\n/** Layout for action buttons. */\nexport type ChatActionLayout = \"Column\" | \"Grid\";\nexport const ChatActionLayout: Codec;\n/** Payload of a received chat action. */\nexport type ChatActionPayload = \n/** A peer posted a message. */\n{\n tag: \"MessagePosted\";\n value: ChatMessageContent;\n}\n/** A user pressed a host-drawn `Actions` button. */\n | {\n tag: \"ActionTriggered\";\n value: ActionTrigger;\n}\n/** A user issued a command. */\n | {\n tag: \"Command\";\n value: ChatCommand;\n};\nexport const ChatActionPayload: Codec;\n/** A set of action buttons with optional text. */\nexport interface ChatActions {\n /** Optional message text. */\n text?: string;\n /** List of action buttons. */\n actions: Array;\n /** `Column` or `Grid` layout. */\n layout: ChatActionLayout;\n}\nexport const ChatActions: Codec;\n/** Whether the bot was newly registered or already existed. */\nexport type ChatBotRegistrationStatus = \"New\" | \"Exists\";\nexport const ChatBotRegistrationStatus: Codec;\n/** A slash command from a chat user. */\nexport interface ChatCommand {\n /** Command name. */\n command: string;\n /** Command arguments. */\n payload: string;\n}\nexport const ChatCommand: Codec;\n/**\n * A custom message with application-defined type and binary payload. The\n * host draws it through `Renderer::render`, with a `ChatMessage` context\n * carrying `message_type` and `payload` as the render payload.\n */\nexport interface ChatCustomMessage {\n /** Application-defined type key. */\n messageType: string;\n /** Binary payload. */\n payload: HexString;\n}\nexport const ChatCustomMessage: Codec;\n/** A file attachment in a chat message. */\nexport interface ChatFile {\n /** File download URL. */\n url: string;\n /** File name. */\n fileName: string;\n /** MIME type. */\n mimeType: string;\n /** File size in bytes. */\n sizeBytes: bigint;\n /** Optional caption text. */\n text?: string;\n}\nexport const ChatFile: Codec;\n/** A media attachment. */\nexport interface ChatMedia {\n /** Media URL. */\n url: string;\n}\nexport const ChatMedia: Codec;\n/** Content of a chat message -- one of several types. */\nexport type ChatMessageContent = \n/** Plain text message. */\n{\n tag: \"Text\";\n value: {\n text: string;\n };\n}\n/** Rich text with media. */\n | {\n tag: \"RichText\";\n value: ChatRichText;\n}\n/** Action button set. */\n | {\n tag: \"Actions\";\n value: ChatActions;\n}\n/** File attachment. */\n | {\n tag: \"File\";\n value: ChatFile;\n}\n/** Emoji reaction. */\n | {\n tag: \"Reaction\";\n value: ChatReaction;\n}\n/** Reaction removal. */\n | {\n tag: \"ReactionRemoved\";\n value: ChatReaction;\n}\n/** Custom message. */\n | {\n tag: \"Custom\";\n value: ChatCustomMessage;\n};\nexport const ChatMessageContent: Codec;\n/** A reaction to a chat message. */\nexport interface ChatReaction {\n /** Message being reacted to. */\n messageId: string;\n /** Emoji reaction. */\n emoji: string;\n}\nexport const ChatReaction: Codec;\n/** Rich text message with optional media. */\nexport interface ChatRichText {\n /** Optional text content. */\n text?: string;\n /** Attached media items. */\n media: Array;\n}\nexport const ChatRichText: Codec;\n/** A chat room the product participates in. */\nexport interface ChatRoom {\n /** Room identifier. */\n roomId: string;\n /** `RoomHost` or `Bot`. */\n participatingAs: ChatRoomParticipation;\n}\nexport const ChatRoom: Codec;\n/** How the product participates in a chat room. */\nexport type ChatRoomParticipation = \"RoomHost\" | \"Bot\";\nexport const ChatRoomParticipation: Codec;\n/** Whether the room was newly created or already existed. */\nexport type ChatRoomRegistrationStatus = \"New\" | \"Exists\";\nexport const ChatRoomRegistrationStatus: Codec;\n/** Balance amount for CoinPayment operations. */\nexport type CoinPaymentBalance = number;\nexport const CoinPaymentBalance: Codec;\n/** Standardized encrypted Coinage secret transmission payload. */\nexport interface CoinPaymentCheque {\n /** Receivable public key protecting the cheque contents. */\n id: CoinPaymentReceivable;\n /** Claimed payment amount. */\n amount: CoinPaymentBalance;\n /** Concatenated coin secrets encrypted to the receivable. */\n encryptedSecrets: HexString;\n}\nexport const CoinPaymentCheque: Codec;\n/** Product-visible clearing reference for reconciliation and receipts. */\nexport interface CoinPaymentClearingReference {\n /** Clearing Merkle root. */\n root: CoinPaymentMerkleRoot;\n /** Product-visible coin key and transaction hash leaves. */\n leaves: Array<[CoinPaymentCoinagePubKey, CoinPaymentTransactionHash]>;\n}\nexport const CoinPaymentClearingReference: Codec;\n/** Public Coinage key referenced by clearing evidence. */\nexport type CoinPaymentCoinagePubKey = HexString;\nexport const CoinPaymentCoinagePubKey: Codec;\n/** Errors returned by CoinPayment host operations. */\nexport type CoinPaymentError = \"BalanceLow\" | \"Denied\" | \"BadCoins\" | \"SnipedCoins\" | \"PurseNotFound\" | \"ReceivableNotFound\" | \"UnsupportedChannel\" | \"UserAgentCapabilityUnavailable\" | \"Internal\";\nexport const CoinPaymentError: Codec;\n/** Merkle root for a product-visible clearing reference. */\nexport type CoinPaymentMerkleRoot = HexString;\nexport const CoinPaymentMerkleRoot: Codec;\n/** Authenticated product identifier recorded for a product-created purse. */\nexport type CoinPaymentProductId = string;\nexport const CoinPaymentProductId: Codec;\n/** RFC 0017 CoinPayment purse identifier. */\nexport type CoinPaymentPurseId = number;\nexport const CoinPaymentPurseId: Codec;\n/** Product-visible metadata and balance state for a CoinPayment purse. */\nexport interface CoinPaymentPurseInfo {\n /** Human-readable purse name supplied by the creating product. */\n name: string;\n /** Creation timestamp. */\n created: CoinPaymentTimestamp;\n /** Product that created the purse. */\n creator: CoinPaymentProductId;\n /** Current product-visible balance. */\n balance: CoinPaymentBalance;\n}\nexport const CoinPaymentPurseInfo: Codec;\n/** Public key identifying a CoinPayment receivable. */\nexport type CoinPaymentReceivable = HexString;\nexport const CoinPaymentReceivable: Codec;\n/** Clearing status stream item. */\nexport type CoinPaymentStatus = \n/** More coins have cleared. */\n{\n tag: \"Clearing\";\n value: {\n clearing: CoinPaymentBalance;\n cleared: CoinPaymentBalance;\n };\n}\n/** Some or all coins failed to transfer. */\n | {\n tag: \"Failed\";\n value: {\n error: CoinPaymentError;\n cleared: CoinPaymentBalance;\n reference: CoinPaymentClearingReference;\n };\n}\n/** All coins cleared. */\n | {\n tag: \"Done\";\n value: {\n cleared: CoinPaymentBalance;\n reference: CoinPaymentClearingReference;\n };\n};\nexport const CoinPaymentStatus: Codec;\n/** Milliseconds since Unix epoch. */\nexport type CoinPaymentTimestamp = bigint;\nexport const CoinPaymentTimestamp: Codec;\n/** Transaction hash for a product-visible clearing reference. */\nexport type CoinPaymentTransactionHash = HexString;\nexport const CoinPaymentTransactionHash: Codec;\n/** Standardized cheque transmission channel. */\nexport type CoinPaymentTransmissionChannel = \n/** Statement-store/HOP handoff identified by an SSS topic. */\n{\n tag: \"Standard\";\n value: {\n sssTopic: HexString;\n };\n};\nexport const CoinPaymentTransmissionChannel: Codec;\n/** Semantic color tokens, resolved by the host's theme. */\nexport type ColorToken = \"FgPrimary\" | \"FgSecondary\" | \"FgTertiary\" | \"BgSurfaceMain\" | \"BgSurfaceContainer\" | \"BgSurfaceNested\" | \"FgSuccess\" | \"FgError\" | \"FgWarning\";\nexport const ColorToken: Codec;\n/** Properties of a `Column`. */\nexport interface ColumnProps {\n /** Cross-axis alignment of children. */\n horizontalAlignment?: HorizontalAlignment;\n /** Main-axis distribution of children. */\n verticalArrangement?: Arrangement;\n}\nexport const ColumnProps: Codec;\n/** Placement of content within a `Box`. */\nexport type ContentAlignment = \"TopStart\" | \"TopCenter\" | \"TopEnd\" | \"CenterStart\" | \"Center\" | \"CenterEnd\" | \"BottomStart\" | \"BottomCenter\" | \"BottomEnd\";\nexport const ContentAlignment: Codec;\n/** A privacy-preserving alias derived via ring VRF, bound to a specific context. */\nexport interface ContextualAlias {\n /** 32-byte context identifier the alias is bound to. */\n context: HexString;\n /** Ring VRF alias (variable length). */\n alias: HexString;\n}\nexport const ContextualAlias: Codec;\n/**\n * Account selector within a product subtree. Encodes as\n * `Either` on the wire (`Index` = left, `Raw` = right).\n *\n * `Index` is the primary form \u2014 plain indices keep a product's accounts\n * enumerable. `Raw` carries a raw 32-byte derivation index for cases where\n * bytes are genuinely necessary. Hosts expand `Index(n)` to the internal\n * 32-byte index (`u32` little-endian plus the index magic).\n */\nexport type DerivationIndex = \n/** Plain account index. */\n{\n tag: \"Index\";\n value: number;\n}\n/** Raw 32-byte derivation index. */\n | {\n tag: \"Raw\";\n value: HexString;\n};\nexport const DerivationIndex: Codec;\n/** Edge dimensions. `bottom` defaults to `top` and `start` to `end` when absent. */\nexport interface Dimensions {\n /** Top edge. */\n top: Size;\n /** End edge. */\n end: Size;\n /** Bottom edge; defaults to `top`. */\n bottom?: Size;\n /** Start edge; defaults to `end`. */\n start?: Size;\n}\nexport const Dimensions: Codec;\n/** A visual effect. Each variant names one effect and carries its parameters. */\nexport type Effect = \"Rainbow\";\nexport const Effect: Codec;\n/** Properties of an `Effect`. */\nexport interface EffectProps {\n /** The effect applied to the children. */\n effect: Effect;\n}\nexport const EffectProps: Codec;\n/**\n * Generic error payload carrying a human-readable reason string. Used by many\n * methods as a catch-all error type.\n */\nexport interface GenericError {\n /** Human-readable failure reason. */\n reason: string;\n}\nexport const GenericError: Codec;\n/** A 32-byte chain genesis hash used to identify the target chain. */\nexport type GenesisHash = HexString;\nexport const GenesisHash: Codec;\n/** Cross-axis alignment of `Column` children. */\nexport type HorizontalAlignment = \"Start\" | \"Center\" | \"End\";\nexport const HorizontalAlignment: Codec;\n/** Versioned envelope for [`HostAccountConnectionStatusSubscribeError`]. */\nexport type VersionedHostAccountConnectionStatusSubscribeError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedHostAccountConnectionStatusSubscribeError: Codec;\n/** Versioned envelope for [`HostAccountConnectionStatusSubscribeItem`]. */\nexport type VersionedHostAccountConnectionStatusSubscribeItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountConnectionStatusSubscribeItem;\n};\nexport const VersionedHostAccountConnectionStatusSubscribeItem: Codec;\n/** Versioned envelope for [`HostAccountConnectionStatusSubscribeRequest`]. */\nexport type VersionedHostAccountConnectionStatusSubscribeRequest = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostAccountConnectionStatusSubscribeRequest: Codec;\n/** Versioned envelope for [`HostAccountCreateProofError`]. */\nexport type VersionedHostAccountCreateProofError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountCreateProofError;\n};\nexport const VersionedHostAccountCreateProofError: Codec;\n/** Versioned envelope for [`HostAccountCreateProofRequest`]. */\nexport type VersionedHostAccountCreateProofRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountCreateProofRequest;\n};\nexport const VersionedHostAccountCreateProofRequest: Codec;\n/** Versioned envelope for [`HostAccountCreateProofResponse`]. */\nexport type VersionedHostAccountCreateProofResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountCreateProofResponse;\n};\nexport const VersionedHostAccountCreateProofResponse: Codec;\n/** Versioned envelope for [`HostAccountGetAliasError`]. */\nexport type VersionedHostAccountGetAliasError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountGetAliasError;\n};\nexport const VersionedHostAccountGetAliasError: Codec;\n/** Versioned envelope for [`HostAccountGetAliasRequest`]. */\nexport type VersionedHostAccountGetAliasRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountGetAliasRequest;\n};\nexport const VersionedHostAccountGetAliasRequest: Codec;\n/** Versioned envelope for [`HostAccountGetAliasResponse`]. */\nexport type VersionedHostAccountGetAliasResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: ContextualAlias;\n};\nexport const VersionedHostAccountGetAliasResponse: Codec;\n/** Versioned envelope for [`HostAccountGetError`]. */\nexport type VersionedHostAccountGetError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountGetError;\n};\nexport const VersionedHostAccountGetError: Codec;\n/** Versioned envelope for [`HostAccountGetRequest`]. */\nexport type VersionedHostAccountGetRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountGetRequest;\n};\nexport const VersionedHostAccountGetRequest: Codec;\n/** Versioned envelope for [`HostAccountGetResponse`]. */\nexport type VersionedHostAccountGetResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountGetResponse;\n};\nexport const VersionedHostAccountGetResponse: Codec;\n/** Versioned envelope for [`HostAccountListRingVrfKeysError`]. */\nexport type VersionedHostAccountListRingVrfKeysError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountListRingVrfKeysError;\n};\nexport const VersionedHostAccountListRingVrfKeysError: Codec;\n/** Versioned envelope for [`HostAccountListRingVrfKeysRequest`]. */\nexport type VersionedHostAccountListRingVrfKeysRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountListRingVrfKeysRequest;\n};\nexport const VersionedHostAccountListRingVrfKeysRequest: Codec;\n/** Versioned envelope for [`HostAccountListRingVrfKeysResponse`]. */\nexport type VersionedHostAccountListRingVrfKeysResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: Array;\n};\nexport const VersionedHostAccountListRingVrfKeysResponse: Codec;\n/** Versioned envelope for [`HostAccountRegisterRingVrfKeyError`]. */\nexport type VersionedHostAccountRegisterRingVrfKeyError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountRegisterRingVrfKeyError;\n};\nexport const VersionedHostAccountRegisterRingVrfKeyError: Codec;\n/** Versioned envelope for [`HostAccountRegisterRingVrfKeyRequest`]. */\nexport type VersionedHostAccountRegisterRingVrfKeyRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountRegisterRingVrfKeyRequest;\n};\nexport const VersionedHostAccountRegisterRingVrfKeyRequest: Codec;\n/** Versioned envelope for [`HostAccountRegisterRingVrfKeyResponse`]. */\nexport type VersionedHostAccountRegisterRingVrfKeyResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RingVrfPublicKey;\n};\nexport const VersionedHostAccountRegisterRingVrfKeyResponse: Codec;\n/** Versioned envelope for [`HostAccountRingVrfSignError`]. */\nexport type VersionedHostAccountRingVrfSignError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountRingVrfSignError;\n};\nexport const VersionedHostAccountRingVrfSignError: Codec;\n/** Versioned envelope for [`HostAccountRingVrfSignRequest`]. */\nexport type VersionedHostAccountRingVrfSignRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountRingVrfSignRequest;\n};\nexport const VersionedHostAccountRingVrfSignRequest: Codec;\n/** Versioned envelope for [`HostAccountRingVrfSignResponse`]. */\nexport type VersionedHostAccountRingVrfSignResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HexString;\n};\nexport const VersionedHostAccountRingVrfSignResponse: Codec;\n/** Versioned envelope for [`HostAccountSignVrfError`]. */\nexport type VersionedHostAccountSignVrfError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountSignVrfError;\n};\nexport const VersionedHostAccountSignVrfError: Codec;\n/** Versioned envelope for [`HostAccountSignVrfRequest`]. */\nexport type VersionedHostAccountSignVrfRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountSignVrfRequest;\n};\nexport const VersionedHostAccountSignVrfRequest: Codec;\n/** Versioned envelope for [`HostAccountSignVrfResponse`]. */\nexport type VersionedHostAccountSignVrfResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: VrfSignature;\n};\nexport const VersionedHostAccountSignVrfResponse: Codec;\n/** Versioned envelope for [`HostChatActionSubscribeError`]. */\nexport type VersionedHostChatActionSubscribeError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedHostChatActionSubscribeError: Codec;\n/** Versioned envelope for [`HostChatActionSubscribeItem`]. */\nexport type VersionedHostChatActionSubscribeItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostChatActionSubscribeItem;\n};\nexport const VersionedHostChatActionSubscribeItem: Codec;\n/** Versioned envelope for [`HostChatActionSubscribeRequest`]. */\nexport type VersionedHostChatActionSubscribeRequest = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostChatActionSubscribeRequest: Codec;\n/** Versioned envelope for [`HostChatCreateRoomError`]. */\nexport type VersionedHostChatCreateRoomError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostChatCreateRoomError;\n};\nexport const VersionedHostChatCreateRoomError: Codec;\n/** Versioned envelope for [`HostChatCreateRoomRequest`]. */\nexport type VersionedHostChatCreateRoomRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostChatCreateRoomRequest;\n};\nexport const VersionedHostChatCreateRoomRequest: Codec;\n/** Versioned envelope for [`HostChatCreateRoomResponse`]. */\nexport type VersionedHostChatCreateRoomResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostChatCreateRoomResponse;\n};\nexport const VersionedHostChatCreateRoomResponse: Codec;\n/** Versioned envelope for [`HostChatListSubscribeError`]. */\nexport type VersionedHostChatListSubscribeError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedHostChatListSubscribeError: Codec;\n/** Versioned envelope for [`HostChatListSubscribeItem`]. */\nexport type VersionedHostChatListSubscribeItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostChatListSubscribeItem;\n};\nexport const VersionedHostChatListSubscribeItem: Codec;\n/** Versioned envelope for [`HostChatListSubscribeRequest`]. */\nexport type VersionedHostChatListSubscribeRequest = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostChatListSubscribeRequest: Codec;\n/** Versioned envelope for [`HostChatPostMessageError`]. */\nexport type VersionedHostChatPostMessageError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostChatPostMessageError;\n};\nexport const VersionedHostChatPostMessageError: Codec;\n/** Versioned envelope for [`HostChatPostMessageRequest`]. */\nexport type VersionedHostChatPostMessageRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostChatPostMessageRequest;\n};\nexport const VersionedHostChatPostMessageRequest: Codec;\n/** Versioned envelope for [`HostChatPostMessageResponse`]. */\nexport type VersionedHostChatPostMessageResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostChatPostMessageResponse;\n};\nexport const VersionedHostChatPostMessageResponse: Codec;\n/** Versioned envelope for [`HostChatRegisterBotError`]. */\nexport type VersionedHostChatRegisterBotError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostChatRegisterBotError;\n};\nexport const VersionedHostChatRegisterBotError: Codec;\n/** Versioned envelope for [`HostChatRegisterBotRequest`]. */\nexport type VersionedHostChatRegisterBotRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostChatRegisterBotRequest;\n};\nexport const VersionedHostChatRegisterBotRequest: Codec;\n/** Versioned envelope for [`HostChatRegisterBotResponse`]. */\nexport type VersionedHostChatRegisterBotResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostChatRegisterBotResponse;\n};\nexport const VersionedHostChatRegisterBotResponse: Codec;\n/** Versioned envelope for [`HostCoinPaymentCreateChequeError`]. */\nexport type VersionedHostCoinPaymentCreateChequeError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: CoinPaymentError;\n};\nexport const VersionedHostCoinPaymentCreateChequeError: Codec;\n/** Versioned envelope for [`HostCoinPaymentCreateChequeRequest`]. */\nexport type VersionedHostCoinPaymentCreateChequeRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCoinPaymentCreateChequeRequest;\n};\nexport const VersionedHostCoinPaymentCreateChequeRequest: Codec;\n/** Versioned envelope for [`HostCoinPaymentCreateChequeResponse`]. */\nexport type VersionedHostCoinPaymentCreateChequeResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCoinPaymentCreateChequeResponse;\n};\nexport const VersionedHostCoinPaymentCreateChequeResponse: Codec;\n/** Versioned envelope for [`HostCoinPaymentCreatePurseError`]. */\nexport type VersionedHostCoinPaymentCreatePurseError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: CoinPaymentError;\n};\nexport const VersionedHostCoinPaymentCreatePurseError: Codec;\n/** Versioned envelope for [`HostCoinPaymentCreatePurseRequest`]. */\nexport type VersionedHostCoinPaymentCreatePurseRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCoinPaymentCreatePurseRequest;\n};\nexport const VersionedHostCoinPaymentCreatePurseRequest: Codec;\n/** Versioned envelope for [`HostCoinPaymentCreatePurseResponse`]. */\nexport type VersionedHostCoinPaymentCreatePurseResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCoinPaymentCreatePurseResponse;\n};\nexport const VersionedHostCoinPaymentCreatePurseResponse: Codec;\n/** Versioned envelope for [`HostCoinPaymentCreateReceivableError`]. */\nexport type VersionedHostCoinPaymentCreateReceivableError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: CoinPaymentError;\n};\nexport const VersionedHostCoinPaymentCreateReceivableError: Codec;\n/** Versioned envelope for [`HostCoinPaymentCreateReceivableRequest`]. */\nexport type VersionedHostCoinPaymentCreateReceivableRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCoinPaymentCreateReceivableRequest;\n};\nexport const VersionedHostCoinPaymentCreateReceivableRequest: Codec;\n/** Versioned envelope for [`HostCoinPaymentCreateReceivableResponse`]. */\nexport type VersionedHostCoinPaymentCreateReceivableResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCoinPaymentCreateReceivableResponse;\n};\nexport const VersionedHostCoinPaymentCreateReceivableResponse: Codec;\n/** Versioned envelope for [`HostCoinPaymentDeletePurseError`]. */\nexport type VersionedHostCoinPaymentDeletePurseError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: CoinPaymentError;\n};\nexport const VersionedHostCoinPaymentDeletePurseError: Codec;\n/** Versioned envelope for [`HostCoinPaymentDeletePurseItem`]. */\nexport type VersionedHostCoinPaymentDeletePurseItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: CoinPaymentStatus;\n};\nexport const VersionedHostCoinPaymentDeletePurseItem: Codec;\n/** Versioned envelope for [`HostCoinPaymentDeletePurseRequest`]. */\nexport type VersionedHostCoinPaymentDeletePurseRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCoinPaymentDeletePurseRequest;\n};\nexport const VersionedHostCoinPaymentDeletePurseRequest: Codec;\n/** Versioned envelope for [`HostCoinPaymentDepositError`]. */\nexport type VersionedHostCoinPaymentDepositError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: CoinPaymentError;\n};\nexport const VersionedHostCoinPaymentDepositError: Codec;\n/** Versioned envelope for [`HostCoinPaymentDepositItem`]. */\nexport type VersionedHostCoinPaymentDepositItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: CoinPaymentStatus;\n};\nexport const VersionedHostCoinPaymentDepositItem: Codec;\n/** Versioned envelope for [`HostCoinPaymentDepositRequest`]. */\nexport type VersionedHostCoinPaymentDepositRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCoinPaymentDepositRequest;\n};\nexport const VersionedHostCoinPaymentDepositRequest: Codec;\n/** Versioned envelope for [`HostCoinPaymentListenForError`]. */\nexport type VersionedHostCoinPaymentListenForError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: CoinPaymentError;\n};\nexport const VersionedHostCoinPaymentListenForError: Codec;\n/** Versioned envelope for [`HostCoinPaymentListenForItem`]. */\nexport type VersionedHostCoinPaymentListenForItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCoinPaymentListenForItem;\n};\nexport const VersionedHostCoinPaymentListenForItem: Codec;\n/** Versioned envelope for [`HostCoinPaymentListenForRequest`]. */\nexport type VersionedHostCoinPaymentListenForRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCoinPaymentListenForRequest;\n};\nexport const VersionedHostCoinPaymentListenForRequest: Codec;\n/** Versioned envelope for [`HostCoinPaymentQueryPurseError`]. */\nexport type VersionedHostCoinPaymentQueryPurseError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: CoinPaymentError;\n};\nexport const VersionedHostCoinPaymentQueryPurseError: Codec;\n/** Versioned envelope for [`HostCoinPaymentQueryPurseRequest`]. */\nexport type VersionedHostCoinPaymentQueryPurseRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCoinPaymentQueryPurseRequest;\n};\nexport const VersionedHostCoinPaymentQueryPurseRequest: Codec;\n/** Versioned envelope for [`HostCoinPaymentQueryPurseResponse`]. */\nexport type VersionedHostCoinPaymentQueryPurseResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCoinPaymentQueryPurseResponse;\n};\nexport const VersionedHostCoinPaymentQueryPurseResponse: Codec;\n/** Versioned envelope for [`HostCoinPaymentRebalancePurseError`]. */\nexport type VersionedHostCoinPaymentRebalancePurseError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: CoinPaymentError;\n};\nexport const VersionedHostCoinPaymentRebalancePurseError: Codec;\n/** Versioned envelope for [`HostCoinPaymentRebalancePurseItem`]. */\nexport type VersionedHostCoinPaymentRebalancePurseItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: CoinPaymentStatus;\n};\nexport const VersionedHostCoinPaymentRebalancePurseItem: Codec;\n/** Versioned envelope for [`HostCoinPaymentRebalancePurseRequest`]. */\nexport type VersionedHostCoinPaymentRebalancePurseRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCoinPaymentRebalancePurseRequest;\n};\nexport const VersionedHostCoinPaymentRebalancePurseRequest: Codec;\n/** Versioned envelope for [`HostCoinPaymentRefundError`]. */\nexport type VersionedHostCoinPaymentRefundError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: CoinPaymentError;\n};\nexport const VersionedHostCoinPaymentRefundError: Codec;\n/** Versioned envelope for [`HostCoinPaymentRefundItem`]. */\nexport type VersionedHostCoinPaymentRefundItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: CoinPaymentStatus;\n};\nexport const VersionedHostCoinPaymentRefundItem: Codec;\n/** Versioned envelope for [`HostCoinPaymentRefundRequest`]. */\nexport type VersionedHostCoinPaymentRefundRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCoinPaymentRefundRequest;\n};\nexport const VersionedHostCoinPaymentRefundRequest: Codec;\n/** Versioned envelope for [`HostCreateTransactionError`]. */\nexport type VersionedHostCreateTransactionError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCreateTransactionError;\n};\nexport const VersionedHostCreateTransactionError: Codec;\n/** Versioned envelope for [`HostCreateTransactionRequest`]. */\nexport type VersionedHostCreateTransactionRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: ProductAccountTxPayload;\n};\nexport const VersionedHostCreateTransactionRequest: Codec;\n/** Versioned envelope for [`HostCreateTransactionResponse`]. */\nexport type VersionedHostCreateTransactionResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCreateTransactionResponse;\n};\nexport const VersionedHostCreateTransactionResponse: Codec;\n/** Versioned envelope for [`HostCreateTransactionWithLegacyAccountError`]. */\nexport type VersionedHostCreateTransactionWithLegacyAccountError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCreateTransactionError;\n};\nexport const VersionedHostCreateTransactionWithLegacyAccountError: Codec;\n/** Versioned envelope for [`HostCreateTransactionWithLegacyAccountRequest`]. */\nexport type VersionedHostCreateTransactionWithLegacyAccountRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: LegacyAccountTxPayload;\n};\nexport const VersionedHostCreateTransactionWithLegacyAccountRequest: Codec;\n/** Versioned envelope for [`HostCreateTransactionWithLegacyAccountResponse`]. */\nexport type VersionedHostCreateTransactionWithLegacyAccountResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostCreateTransactionWithLegacyAccountResponse;\n};\nexport const VersionedHostCreateTransactionWithLegacyAccountResponse: Codec;\n/** Versioned envelope for [`HostDeriveEntropyError`]. */\nexport type VersionedHostDeriveEntropyError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostDeriveEntropyError;\n};\nexport const VersionedHostDeriveEntropyError: Codec;\n/** Versioned envelope for [`HostDeriveEntropyRequest`]. */\nexport type VersionedHostDeriveEntropyRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostDeriveEntropyRequest;\n};\nexport const VersionedHostDeriveEntropyRequest: Codec;\n/** Versioned envelope for [`HostDeriveEntropyResponse`]. */\nexport type VersionedHostDeriveEntropyResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostDeriveEntropyResponse;\n};\nexport const VersionedHostDeriveEntropyResponse: Codec;\n/** Versioned envelope for [`HostDevicePermissionError`]. */\nexport type VersionedHostDevicePermissionError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedHostDevicePermissionError: Codec;\n/** Versioned envelope for [`HostDevicePermissionRequest`]. */\nexport type VersionedHostDevicePermissionRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostDevicePermissionRequest;\n};\nexport const VersionedHostDevicePermissionRequest: Codec;\n/** Versioned envelope for [`HostDevicePermissionResponse`]. */\nexport type VersionedHostDevicePermissionResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostDevicePermissionResponse;\n};\nexport const VersionedHostDevicePermissionResponse: Codec;\n/** Versioned envelope for [`HostFeatureSupportedError`]. */\nexport type VersionedHostFeatureSupportedError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedHostFeatureSupportedError: Codec;\n/** Versioned envelope for [`HostFeatureSupportedRequest`]. */\nexport type VersionedHostFeatureSupportedRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostFeatureSupportedRequest;\n};\nexport const VersionedHostFeatureSupportedRequest: Codec;\n/** Versioned envelope for [`HostFeatureSupportedResponse`]. */\nexport type VersionedHostFeatureSupportedResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostFeatureSupportedResponse;\n};\nexport const VersionedHostFeatureSupportedResponse: Codec;\n/** Versioned envelope for [`HostGetLegacyAccountsError`]. */\nexport type VersionedHostGetLegacyAccountsError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostAccountGetError;\n};\nexport const VersionedHostGetLegacyAccountsError: Codec;\n/** Versioned envelope for [`HostGetLegacyAccountsRequest`]. */\nexport type VersionedHostGetLegacyAccountsRequest = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostGetLegacyAccountsRequest: Codec;\n/** Versioned envelope for [`HostGetLegacyAccountsResponse`]. */\nexport type VersionedHostGetLegacyAccountsResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostGetLegacyAccountsResponse;\n};\nexport const VersionedHostGetLegacyAccountsResponse: Codec;\n/** Versioned envelope for [`HostGetProductContextError`]. */\nexport type VersionedHostGetProductContextError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedHostGetProductContextError: Codec;\n/** Versioned envelope for [`HostGetProductContextRequest`]. */\nexport type VersionedHostGetProductContextRequest = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostGetProductContextRequest: Codec;\n/** Versioned envelope for [`HostGetProductContextResponse`]. */\nexport type VersionedHostGetProductContextResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostGetProductContextResponse;\n};\nexport const VersionedHostGetProductContextResponse: Codec;\n/** Versioned envelope for [`HostGetUserIdError`]. */\nexport type VersionedHostGetUserIdError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostGetUserIdError;\n};\nexport const VersionedHostGetUserIdError: Codec;\n/** Versioned envelope for [`HostGetUserIdRequest`]. */\nexport type VersionedHostGetUserIdRequest = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostGetUserIdRequest: Codec;\n/** Versioned envelope for [`HostGetUserIdResponse`]. */\nexport type VersionedHostGetUserIdResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostGetUserIdResponse;\n};\nexport const VersionedHostGetUserIdResponse: Codec;\n/** Versioned envelope for [`HostHandshakeError`]. */\nexport type VersionedHostHandshakeError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostHandshakeError;\n};\nexport const VersionedHostHandshakeError: Codec;\n/** Versioned envelope for [`HostHandshakeRequest`]. */\nexport type VersionedHostHandshakeRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostHandshakeRequest;\n};\nexport const VersionedHostHandshakeRequest: Codec;\n/** Versioned envelope for [`HostHandshakeResponse`]. */\nexport type VersionedHostHandshakeResponse = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostHandshakeResponse: Codec;\n/**\n * Identity and version of the host currently running the product.\n *\n * Reported by [`crate::api::System::host_info`] so a product knows which host\n * (and which build of it) is running it \u2014 for adapting to the host,\n * telemetry, and attributing behaviour to a concrete build in diagnostics and\n * bug reports.\n */\nexport interface HostInfo {\n /** Platform category the host runs on. */\n platform: HostPlatform;\n /**\n * Human-readable name of the host implementation, e.g. `\"Polkadot\n * Desktop\"`, `\"Polkadot Mobile\"`, or `\"dotli\"`. Hosts should report a\n * stable, non-empty name.\n */\n name: string;\n /**\n * Host-native version string, e.g. a semver such as `\"1.2.3\"`. Hosts\n * should report a non-empty value; the format is the host's own.\n */\n version: string;\n}\nexport const HostInfo: Codec;\n/** Versioned envelope for [`HostInfoError`]. */\nexport type VersionedHostInfoError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedHostInfoError: Codec;\n/** Versioned envelope for [`HostInfoRequest`]. */\nexport type VersionedHostInfoRequest = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostInfoRequest: Codec;\n/** Versioned envelope for [`HostInfoResponse`]. */\nexport type VersionedHostInfoResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostInfo;\n};\nexport const VersionedHostInfoResponse: Codec;\n/** Versioned envelope for [`HostLocalStorageChangeItem`]. */\nexport type VersionedHostLocalStorageChangeItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostLocalStorageChangeItem;\n};\nexport const VersionedHostLocalStorageChangeItem: Codec;\n/** Versioned envelope for [`HostLocalStorageClearError`]. */\nexport type VersionedHostLocalStorageClearError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: V01HostLocalStorageReadError;\n};\nexport const VersionedHostLocalStorageClearError: Codec;\n/** Versioned envelope for [`HostLocalStorageClearRequest`]. */\nexport type VersionedHostLocalStorageClearRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostLocalStorageClearRequest;\n};\nexport const VersionedHostLocalStorageClearRequest: Codec;\n/** Versioned envelope for [`HostLocalStorageClearResponse`]. */\nexport type VersionedHostLocalStorageClearResponse = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostLocalStorageClearResponse: Codec;\n/** Versioned envelope for [`HostLocalStorageReadError`]. */\nexport type VersionedHostLocalStorageReadError = \n/** Version 2 payload. */\n{\n tag: \"V2\";\n value: HostLocalStorageReadError;\n};\nexport const VersionedHostLocalStorageReadError: Codec;\n/** Versioned envelope for [`HostLocalStorageReadRequest`]. */\nexport type VersionedHostLocalStorageReadRequest = \n/** Version 2 payload. */\n{\n tag: \"V2\";\n value: HostLocalStorageReadRequest;\n};\nexport const VersionedHostLocalStorageReadRequest: Codec;\n/** Versioned envelope for [`HostLocalStorageReadResponse`]. */\nexport type VersionedHostLocalStorageReadResponse = \n/** Version 2 payload. */\n{\n tag: \"V2\";\n value: HostLocalStorageReadResponse;\n};\nexport const VersionedHostLocalStorageReadResponse: Codec;\n/** Versioned envelope for [`HostLocalStorageSubscribeError`]. */\nexport type VersionedHostLocalStorageSubscribeError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedHostLocalStorageSubscribeError: Codec;\n/** Versioned envelope for [`HostLocalStorageSubscribeRequest`]. */\nexport type VersionedHostLocalStorageSubscribeRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostLocalStorageSubscribeRequest;\n};\nexport const VersionedHostLocalStorageSubscribeRequest: Codec;\n/** Versioned envelope for [`HostLocalStorageWriteError`]. */\nexport type VersionedHostLocalStorageWriteError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: V01HostLocalStorageReadError;\n};\nexport const VersionedHostLocalStorageWriteError: Codec;\n/** Versioned envelope for [`HostLocalStorageWriteRequest`]. */\nexport type VersionedHostLocalStorageWriteRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostLocalStorageWriteRequest;\n};\nexport const VersionedHostLocalStorageWriteRequest: Codec;\n/** Versioned envelope for [`HostLocalStorageWriteResponse`]. */\nexport type VersionedHostLocalStorageWriteResponse = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostLocalStorageWriteResponse: Codec;\n/** Versioned envelope for [`HostLocaleSubscribeError`]. */\nexport type VersionedHostLocaleSubscribeError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedHostLocaleSubscribeError: Codec;\n/** Versioned envelope for [`HostLocaleSubscribeItem`]. */\nexport type VersionedHostLocaleSubscribeItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostLocaleSubscribeItem;\n};\nexport const VersionedHostLocaleSubscribeItem: Codec;\n/** Versioned envelope for [`HostLocaleSubscribeRequest`]. */\nexport type VersionedHostLocaleSubscribeRequest = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostLocaleSubscribeRequest: Codec;\n/** A peer's native delivery acknowledgment, not a payment-clearing receipt. */\nexport interface HostNativeChatAcknowledgment {\n /** Authenticated acknowledging identity. */\n peerIdentity: HexString;\n /** Acknowledged native request identifier. */\n requestId: string;\n /** Native response code; zero denotes successful delivery processing. */\n responseCode: number;\n}\nexport const HostNativeChatAcknowledgment: Codec;\n/** Public attachment handle; only the Host can resolve its private backing. */\nexport interface HostNativeChatAttachment {\n /** Opaque handle scoped to the current wallet, network and calling product. */\n attachmentId: HexString;\n /** Non-secret native metadata. */\n metadata: HostNativeChatAttachmentMetadata;\n /** Current durable transfer progress. */\n state: HostNativeChatAttachmentState;\n}\nexport const HostNativeChatAttachment: Codec;\n/** Public native media metadata; thumbnails are BlurHash text, not executable images. */\nexport type HostNativeChatAttachmentKind = \n/** A general document or other opaque file. */\n{\n tag: \"File\";\n value?: undefined;\n}\n/** An image with native dimensions and an optional UTF-8 BlurHash. */\n | {\n tag: \"Image\";\n value: {\n width: number;\n height: number;\n thumbnail?: HexString;\n };\n}\n/** A video with native duration and an optional UTF-8 BlurHash. */\n | {\n tag: \"Video\";\n value: {\n durationSeconds: number;\n thumbnail?: HexString;\n };\n};\nexport const HostNativeChatAttachmentKind: Codec;\n/** Safe attachment description, independent of private transfer credentials. */\nexport interface HostNativeChatAttachmentMetadata {\n /** Validated media type; it does not authorize execution or network loading. */\n mimeType: string;\n /** Exact native file size, verified against the downloaded root and chunks. */\n sizeBytes: number;\n /** General file, image or video metadata. */\n kind: HostNativeChatAttachmentKind;\n}\nexport const HostNativeChatAttachmentMetadata: Codec;\n/** Durable transfer progress, distinct from message delivery acknowledgment. */\nexport type HostNativeChatAttachmentState = \n/** The Host is securing an immutable selected source. */\n{\n tag: \"Preparing\";\n value?: undefined;\n}\n/** Native HOP entries are being uploaded. */\n | {\n tag: \"Uploading\";\n value: {\n uploadedBytes: number;\n };\n}\n/** Verified file bytes are being committed to private local storage. */\n | {\n tag: \"Downloading\";\n value: {\n downloadedBytes: number;\n };\n}\n/** Complete verified bytes are available through trusted Host presentation. */\n | {\n tag: \"Ready\";\n value?: undefined;\n}\n/** An interrupted transfer retains its exact credentials and progress for retry. */\n | {\n tag: \"Recovering\";\n value?: undefined;\n};\nexport const HostNativeChatAttachmentState: Codec;\n/** Peer cryptographic identity independently resolved and bound by the Host. */\nexport interface HostNativeChatBinding {\n /** Authenticated peer root identity. */\n peerIdentity: HexString;\n /** Peer identity-level native Chat encryption key. */\n peerChatPublicKey: HexString;\n /** Identity proof used in the native invitation handshake. */\n identityProof: HexString;\n}\nexport const HostNativeChatBinding: Codec;\n/** The Host-owned device's public identity and statement-signing account. */\nexport interface HostNativeChatDevice {\n /** Wallet identity on the configured People chain. */\n identityAccountId: HexString;\n /** Wallet identity's public X25519 key. */\n identityChatPublicKey: HexString;\n /** Product account used to obtain a statement-store allowance for this device. */\n productAccount: ProductAccountId;\n /** Public statement signer for the Host-owned device. */\n accountId: HexString;\n /** Public X25519 key; its secret never leaves the Host. */\n chatPublicKey: HexString;\n}\nexport const HostNativeChatDevice: Codec;\n/** An authenticated invitation awaiting the user's Chat decision. */\nexport interface HostNativeChatInvitation {\n /** Host-generated stable invitation identifier. */\n invitationId: HexString;\n /** Authenticated sender identity. */\n peerIdentity: HexString;\n /** Host-resolved sender username, when available. */\n username?: string;\n /** Authenticated native invitation timestamp in milliseconds. */\n timestamp: bigint;\n /** Ordinary initial text, never an embedded payment or control message. */\n text: string;\n}\nexport const HostNativeChatInvitation: Codec;\n/** Safe ordinary messages from one authenticated native request. */\nexport interface HostNativeChatMessages {\n /** Authenticated counterparty identity. */\n peerIdentity: HexString;\n /** Whether the peer sent these messages; false also covers our welcome text. */\n incoming: boolean;\n /** Native request identifier, retained for message-delivery correlation. */\n requestId: string;\n /** Native message encodings after custody-sensitive content is removed. */\n messages: Array;\n}\nexport const HostNativeChatMessages: Codec;\n/** Native request identity needed to answer a migrated legacy invitation. */\nexport interface HostNativeChatMigrationInvitation {\n /** Invitation handle in the accompanying legacy public view. */\n invitationId: HexString;\n /** Original native request identity to acknowledge when answering. */\n requestId: string;\n}\nexport const HostNativeChatMigrationInvitation: Codec;\n/** Continuation metadata for a bounded page of authenticated incoming plaintext. */\nexport interface HostNativeChatOpenPage {\n /** Opaque identifier of the authenticated opening operation. */\n openId: HexString;\n /** Cursor identifying this page. */\n cursor: number;\n /** Cursor to request next; absent when the authenticated batch is complete. */\n nextCursor?: number;\n}\nexport const HostNativeChatOpenPage: Codec;\n/** Authenticated incoming native plaintext, potentially containing incoming coin keys. */\nexport interface HostNativeChatOpened {\n /** Authenticated peer root identity, never the local wallet's own identity. */\n peerIdentity: HexString;\n /** Account that signed the accepted native statement. */\n senderAccountId: HexString;\n /** Authenticated native context of the incoming statement. */\n route: HostNativeChatRoute;\n /** Native invitation or tagged request/response plaintext; never outgoing payment memos. */\n plaintext: HexString;\n}\nexport const HostNativeChatOpened: Codec;\n/** A product-visible payment card; it contains no spendable memo material. */\nexport interface HostNativeChatPayment {\n /** Durable, product-scoped operation identifier. */\n operationId: HexString;\n /** Caller request id for outgoing payments; native request id for incoming ones. */\n requestId: string;\n /** Native message id used to place the payment in conversation history. */\n messageId: string;\n /** Native message timestamp in milliseconds. */\n timestamp: bigint;\n /** Counterparty identity authenticated by the Host. */\n peerIdentity: HexString;\n /** Incoming or outgoing relative to the current wallet. */\n direction: HostNativeChatPaymentDirection;\n /** Exact requested/received value in cents. */\n amountCents: bigint;\n /** Durable transport/clearing state. */\n state: HostNativeChatPaymentState;\n}\nexport const HostNativeChatPayment: Codec;\n/** Payment direction relative to the current wallet. */\nexport type HostNativeChatPaymentDirection = \"Outgoing\" | \"Incoming\";\nexport const HostNativeChatPaymentDirection: Codec;\n/** Public, non-secret payment failure categories. */\nexport type HostNativeChatPaymentFailure = \"Cancelled\" | \"InsufficientBalance\" | \"AlreadySpent\" | \"InvalidMemo\" | \"ChainRejected\";\nexport const HostNativeChatPaymentFailure: Codec;\n/** Durable payment state. Delivery and on-chain clearing are deliberately distinct. */\nexport type HostNativeChatPaymentState = \n/** Approved inputs are reserved; required split/unload work is in progress. */\n{\n tag: \"Preparing\";\n value?: undefined;\n}\n/** The encrypted memo is durable and transport delivery is being retried. */\n | {\n tag: \"Delivering\";\n value?: undefined;\n}\n/** The peer acknowledged the memo; settlement has not yet been established. */\n | {\n tag: \"Delivered\";\n value?: undefined;\n}\n/** Received secrets are durably held while their claim is in progress. */\n | {\n tag: \"Claiming\";\n value?: undefined;\n}\n/** Some, but not all, of the payment has been observed clearing on chain. */\n | {\n tag: \"PartiallyCleared\";\n value: {\n clearedCents: bigint;\n };\n}\n/** The complete payment has been verified at chain finality. */\n | {\n tag: \"Cleared\";\n value?: undefined;\n}\n/** An ambiguous effect is retained for reconciliation; inputs remain reserved. */\n | {\n tag: \"Recovering\";\n value?: undefined;\n}\n/** A definitive failure; the Host has reconciled any possible prior effects. */\n | {\n tag: \"Failed\";\n value: {\n reason: HostNativeChatPaymentFailure;\n };\n};\nexport const HostNativeChatPaymentState: Codec;\n/** Public conversation state; products cannot write this roster back to the Host. */\nexport interface HostNativeChatPeer {\n /** Recipient wallet identity. */\n identityAccountId: HexString;\n /** Username resolved by the Host, if currently available. */\n username?: string;\n /** Devices admitted by authenticated native invitation/control messages. */\n devices: Array;\n /** Native session topics for subscriptions, not request/response channel hashes. */\n incomingChannels: Array;\n /** Whether establishment and legacy-device revocation have been acknowledged. */\n readyForPayments: boolean;\n}\nexport const HostNativeChatPeer: Codec;\n/** Public metadata for one authenticated remote device. */\nexport interface HostNativeChatPeerDevice {\n /** Remote device's statement signer. */\n accountId: HexString;\n /** Remote device's authenticated public X25519 key. */\n chatPublicKey: HexString;\n}\nexport const HostNativeChatPeerDevice: Codec;\n/** Signed ciphertext with the native identity required for durable product delivery. */\nexport interface HostNativeChatPrepared {\n /** Exact signed ciphertext to submit again when retrying delivery. */\n statement: SignedStatement;\n /** Authenticated recipient root identity. */\n peerIdentity: HexString;\n /** Native request identity used to correlate delivery acknowledgments. */\n requestId: string;\n /** Whether delivery remains pending until a native peer acknowledgment arrives. */\n requiresAck: boolean;\n /** Original product intent id for correlating migrated pending UI, when retained. */\n clientRequestId?: string;\n}\nexport const HostNativeChatPrepared: Codec;\n/** Authenticated rich content after private file capabilities have been removed. */\nexport interface HostNativeChatRichMessage {\n /** Authenticated conversation identity. */\n peerIdentity: HexString;\n /** Whether the remote peer authored this content. */\n incoming: boolean;\n /** Native request id used for delivery acknowledgment. */\n requestId: string;\n /** Native id of this message or edit event. */\n messageId: string;\n /** Native timestamp in milliseconds. */\n timestamp: bigint;\n /** New message, reply or edit; authorship checks still apply to edits. */\n kind: HostNativeChatRichMessageKind;\n /** Ordinary optional text. */\n text?: string;\n /** Opaque file handles and safe metadata, never native file references. */\n attachments: Array;\n}\nexport const HostNativeChatRichMessage: Codec;\n/** Native rich-content timeline operation. */\nexport type HostNativeChatRichMessageKind = \n/** A new ordinary rich message. */\n{\n tag: \"Message\";\n value?: undefined;\n}\n/** A new rich message replying to an earlier message. */\n | {\n tag: \"Reply\";\n value: {\n messageId: string;\n };\n}\n/** A replacement of the same author's earlier rich content. */\n | {\n tag: \"Edited\";\n value: {\n messageId: string;\n };\n};\nexport const HostNativeChatRichMessageKind: Codec;\n/** The authenticated native encryption and statement-routing context. */\nexport type HostNativeChatRoute = \"Invitation\" | \"Identity\" | \"Device\";\nexport const HostNativeChatRoute: Codec;\n/** Continuation metadata for a bounded page of a stable public state snapshot. */\nexport interface HostNativeChatStatePage {\n /** Opaque identifier of the Host-retained public state snapshot. */\n stateId: HexString;\n /** Cursor identifying this page. */\n cursor: number;\n /** Cursor to request next; absent when the snapshot is complete. */\n nextCursor?: number;\n}\nexport const HostNativeChatStatePage: Codec;\n/** Versioned envelope for [`HostNavigateToError`]. */\nexport type VersionedHostNavigateToError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostNavigateToError;\n};\nexport const VersionedHostNavigateToError: Codec;\n/** Versioned envelope for [`HostNavigateToRequest`]. */\nexport type VersionedHostNavigateToRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostNavigateToRequest;\n};\nexport const VersionedHostNavigateToRequest: Codec;\n/** Versioned envelope for [`HostNavigateToResponse`]. */\nexport type VersionedHostNavigateToResponse = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostNavigateToResponse: Codec;\n/** Versioned envelope for [`HostPaymentBalanceSubscribeError`]. */\nexport type VersionedHostPaymentBalanceSubscribeError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPaymentBalanceSubscribeError;\n};\nexport const VersionedHostPaymentBalanceSubscribeError: Codec;\n/** Versioned envelope for [`HostPaymentBalanceSubscribeItem`]. */\nexport type VersionedHostPaymentBalanceSubscribeItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPaymentBalanceSubscribeItem;\n};\nexport const VersionedHostPaymentBalanceSubscribeItem: Codec;\n/** Versioned envelope for [`HostPaymentBalanceSubscribeRequest`]. */\nexport type VersionedHostPaymentBalanceSubscribeRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPaymentBalanceSubscribeRequest;\n};\nexport const VersionedHostPaymentBalanceSubscribeRequest: Codec;\n/** Versioned envelope for [`HostPaymentError`]. */\nexport type VersionedHostPaymentError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPaymentError;\n};\nexport const VersionedHostPaymentError: Codec;\n/** Versioned envelope for [`HostPaymentRequest`]. */\nexport type VersionedHostPaymentRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPaymentRequest;\n};\nexport const VersionedHostPaymentRequest: Codec;\n/** Versioned envelope for [`HostPaymentResponse`]. */\nexport type VersionedHostPaymentResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPaymentResponse;\n};\nexport const VersionedHostPaymentResponse: Codec;\n/** Versioned envelope for [`HostPaymentStatusSubscribeError`]. */\nexport type VersionedHostPaymentStatusSubscribeError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPaymentStatusSubscribeError;\n};\nexport const VersionedHostPaymentStatusSubscribeError: Codec;\n/** Versioned envelope for [`HostPaymentStatusSubscribeItem`]. */\nexport type VersionedHostPaymentStatusSubscribeItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPaymentStatusSubscribeItem;\n};\nexport const VersionedHostPaymentStatusSubscribeItem: Codec;\n/** Versioned envelope for [`HostPaymentStatusSubscribeRequest`]. */\nexport type VersionedHostPaymentStatusSubscribeRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPaymentStatusSubscribeRequest;\n};\nexport const VersionedHostPaymentStatusSubscribeRequest: Codec;\n/** Versioned envelope for [`HostPaymentTopUpError`]. */\nexport type VersionedHostPaymentTopUpError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPaymentTopUpError;\n};\nexport const VersionedHostPaymentTopUpError: Codec;\n/** Versioned envelope for [`HostPaymentTopUpRequest`]. */\nexport type VersionedHostPaymentTopUpRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPaymentTopUpRequest;\n};\nexport const VersionedHostPaymentTopUpRequest: Codec;\n/** Versioned envelope for [`HostPaymentTopUpResponse`]. */\nexport type VersionedHostPaymentTopUpResponse = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostPaymentTopUpResponse: Codec;\n/** Platform category a host runs on. */\nexport type HostPlatform = \"Web\" | \"Android\" | \"Ios\" | \"Desktop\" | \"Cli\" | \"Unknown\";\nexport const HostPlatform: Codec;\n/** Versioned envelope for [`HostPocketListSubscribeError`]. */\nexport type VersionedHostPocketListSubscribeError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedHostPocketListSubscribeError: Codec;\n/** Versioned envelope for [`HostPocketListSubscribeItem`]. */\nexport type VersionedHostPocketListSubscribeItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPocketListSubscribeItem;\n};\nexport const VersionedHostPocketListSubscribeItem: Codec;\n/** Versioned envelope for [`HostPocketListSubscribeRequest`]. */\nexport type VersionedHostPocketListSubscribeRequest = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostPocketListSubscribeRequest: Codec;\n/** Versioned envelope for [`HostPocketRemoveCardError`]. */\nexport type VersionedHostPocketRemoveCardError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPocketRemoveCardError;\n};\nexport const VersionedHostPocketRemoveCardError: Codec;\n/** Versioned envelope for [`HostPocketRemoveCardRequest`]. */\nexport type VersionedHostPocketRemoveCardRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPocketRemoveCardRequest;\n};\nexport const VersionedHostPocketRemoveCardRequest: Codec;\n/** Versioned envelope for [`HostPocketRemoveCardResponse`]. */\nexport type VersionedHostPocketRemoveCardResponse = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostPocketRemoveCardResponse: Codec;\n/** Versioned envelope for [`HostProductDeviceChatError`]. */\nexport type VersionedHostProductDeviceChatError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostProductDeviceChatError;\n};\nexport const VersionedHostProductDeviceChatError: Codec;\n/** Versioned envelope for [`HostProductDeviceChatRequest`]. */\nexport type VersionedHostProductDeviceChatRequest = \n/** Version 2 payload. */\n{\n tag: \"V2\";\n value: HostProductDeviceChatRequest;\n};\nexport const VersionedHostProductDeviceChatRequest: Codec;\n/** Versioned envelope for [`HostProductDeviceChatResponse`]. */\nexport type VersionedHostProductDeviceChatResponse = \n/** Version 2 payload. */\n{\n tag: \"V2\";\n value: HostProductDeviceChatResponse;\n};\nexport const VersionedHostProductDeviceChatResponse: Codec;\n/** Versioned envelope for [`HostProfileDiscloseError`]. */\nexport type VersionedHostProfileDiscloseError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostProfileDiscloseError;\n};\nexport const VersionedHostProfileDiscloseError: Codec;\n/** Versioned envelope for [`HostProfileDiscloseRequest`]. */\nexport type VersionedHostProfileDiscloseRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostProfileDiscloseRequest;\n};\nexport const VersionedHostProfileDiscloseRequest: Codec;\n/** Versioned envelope for [`HostProfileDiscloseResponse`]. */\nexport type VersionedHostProfileDiscloseResponse = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostProfileDiscloseResponse: Codec;\n/** Versioned envelope for [`HostProfilePresentContactError`]. */\nexport type VersionedHostProfilePresentContactError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostProfilePresentContactError;\n};\nexport const VersionedHostProfilePresentContactError: Codec;\n/** Versioned envelope for [`HostProfilePresentContactRequest`]. */\nexport type VersionedHostProfilePresentContactRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostProfilePresentContactRequest;\n};\nexport const VersionedHostProfilePresentContactRequest: Codec;\n/** Versioned envelope for [`HostProfilePresentContactResponse`]. */\nexport type VersionedHostProfilePresentContactResponse = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostProfilePresentContactResponse: Codec;\n/** Versioned envelope for [`HostProfilePresentError`]. */\nexport type VersionedHostProfilePresentError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostProfilePresentError;\n};\nexport const VersionedHostProfilePresentError: Codec;\n/** Versioned envelope for [`HostProfilePresentRequest`]. */\nexport type VersionedHostProfilePresentRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostProfilePresentRequest;\n};\nexport const VersionedHostProfilePresentRequest: Codec;\n/** Versioned envelope for [`HostProfilePresentResponse`]. */\nexport type VersionedHostProfilePresentResponse = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostProfilePresentResponse: Codec;\n/** Versioned envelope for [`HostProfileRetractError`]. */\nexport type VersionedHostProfileRetractError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostProfileRetractError;\n};\nexport const VersionedHostProfileRetractError: Codec;\n/** Versioned envelope for [`HostProfileRetractRequest`]. */\nexport type VersionedHostProfileRetractRequest = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostProfileRetractRequest: Codec;\n/** Versioned envelope for [`HostProfileRetractResponse`]. */\nexport type VersionedHostProfileRetractResponse = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostProfileRetractResponse: Codec;\n/** Versioned envelope for [`HostPushNotificationCancelError`]. */\nexport type VersionedHostPushNotificationCancelError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedHostPushNotificationCancelError: Codec;\n/** Versioned envelope for [`HostPushNotificationCancelRequest`]. */\nexport type VersionedHostPushNotificationCancelRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPushNotificationCancelRequest;\n};\nexport const VersionedHostPushNotificationCancelRequest: Codec;\n/** Versioned envelope for [`HostPushNotificationCancelResponse`]. */\nexport type VersionedHostPushNotificationCancelResponse = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostPushNotificationCancelResponse: Codec;\n/** Versioned envelope for [`HostPushNotificationError`]. */\nexport type VersionedHostPushNotificationError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPushNotificationError;\n};\nexport const VersionedHostPushNotificationError: Codec;\n/** Versioned envelope for [`HostPushNotificationRequest`]. */\nexport type VersionedHostPushNotificationRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPushNotificationRequest;\n};\nexport const VersionedHostPushNotificationRequest: Codec;\n/** Versioned envelope for [`HostPushNotificationResponse`]. */\nexport type VersionedHostPushNotificationResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostPushNotificationResponse;\n};\nexport const VersionedHostPushNotificationResponse: Codec;\n/** Versioned envelope for [`HostRendererActionSubscribeError`]. */\nexport type VersionedHostRendererActionSubscribeError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedHostRendererActionSubscribeError: Codec;\n/** Versioned envelope for [`HostRendererActionSubscribeItem`]. */\nexport type VersionedHostRendererActionSubscribeItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostRendererActionSubscribeItem;\n};\nexport const VersionedHostRendererActionSubscribeItem: Codec;\n/** Versioned envelope for [`HostRendererActionSubscribeRequest`]. */\nexport type VersionedHostRendererActionSubscribeRequest = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostRendererActionSubscribeRequest: Codec;\n/** Versioned envelope for [`HostRequestLoginError`]. */\nexport type VersionedHostRequestLoginError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostRequestLoginError;\n};\nexport const VersionedHostRequestLoginError: Codec;\n/** Versioned envelope for [`HostRequestLoginRequest`]. */\nexport type VersionedHostRequestLoginRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostRequestLoginRequest;\n};\nexport const VersionedHostRequestLoginRequest: Codec;\n/** Versioned envelope for [`HostRequestLoginResponse`]. */\nexport type VersionedHostRequestLoginResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostRequestLoginResponse;\n};\nexport const VersionedHostRequestLoginResponse: Codec;\n/** Versioned envelope for [`HostRequestResourceAllocationError`]. */\nexport type VersionedHostRequestResourceAllocationError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: ResourceAllocationError;\n};\nexport const VersionedHostRequestResourceAllocationError: Codec;\n/** Versioned envelope for [`HostRequestResourceAllocationRequest`]. */\nexport type VersionedHostRequestResourceAllocationRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostRequestResourceAllocationRequest;\n};\nexport const VersionedHostRequestResourceAllocationRequest: Codec;\n/** Versioned envelope for [`HostRequestResourceAllocationResponse`]. */\nexport type VersionedHostRequestResourceAllocationResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostRequestResourceAllocationResponse;\n};\nexport const VersionedHostRequestResourceAllocationResponse: Codec;\n/**\n * Full Substrate extrinsic signing payload with all fields needed for signature\n * generation.\n */\nexport interface HostSignPayloadData {\n /** Reference block hash. */\n blockHash: HexString;\n /** Reference block number. */\n blockNumber: HexString;\n /** Mortality era encoding. */\n era: HexString;\n /** Chain genesis hash. */\n genesisHash: HexString;\n /** SCALE-encoded call data. */\n method: HexString;\n /** Account nonce. */\n nonce: HexString;\n /** Runtime spec version. */\n specVersion: HexString;\n /** Transaction tip. */\n tip: HexString;\n /** Transaction format version. */\n transactionVersion: HexString;\n /** Extension identifiers. */\n signedExtensions: Array;\n /** Extrinsic version. */\n version: number;\n /** For multi-asset tips. */\n assetId?: HexString;\n /** CheckMetadataHash extension. */\n metadataHash?: HexString;\n /** Metadata mode. */\n mode?: number;\n /** Request signed transaction back, encoded as one byte: absent, true, or false. */\n withSignedTransaction?: boolean;\n}\nexport const HostSignPayloadData: Codec;\n/** Versioned envelope for [`HostSignPayloadError`]. */\nexport type VersionedHostSignPayloadError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostSignPayloadError;\n};\nexport const VersionedHostSignPayloadError: Codec;\n/** Versioned envelope for [`HostSignPayloadRequest`]. */\nexport type VersionedHostSignPayloadRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostSignPayloadRequest;\n};\nexport const VersionedHostSignPayloadRequest: Codec;\n/** Versioned envelope for [`HostSignPayloadResponse`]. */\nexport type VersionedHostSignPayloadResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostSignPayloadResponse;\n};\nexport const VersionedHostSignPayloadResponse: Codec;\n/** Versioned envelope for [`HostSignPayloadWithLegacyAccountError`]. */\nexport type VersionedHostSignPayloadWithLegacyAccountError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostSignPayloadError;\n};\nexport const VersionedHostSignPayloadWithLegacyAccountError: Codec;\n/** Versioned envelope for [`HostSignPayloadWithLegacyAccountRequest`]. */\nexport type VersionedHostSignPayloadWithLegacyAccountRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostSignPayloadWithLegacyAccountRequest;\n};\nexport const VersionedHostSignPayloadWithLegacyAccountRequest: Codec;\n/** Versioned envelope for [`HostSignPayloadWithLegacyAccountResponse`]. */\nexport type VersionedHostSignPayloadWithLegacyAccountResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostSignPayloadResponse;\n};\nexport const VersionedHostSignPayloadWithLegacyAccountResponse: Codec;\n/** Versioned envelope for [`HostSignRawError`]. */\nexport type VersionedHostSignRawError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostSignPayloadError;\n};\nexport const VersionedHostSignRawError: Codec;\n/** Versioned envelope for [`HostSignRawRequest`]. */\nexport type VersionedHostSignRawRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostSignRawRequest;\n};\nexport const VersionedHostSignRawRequest: Codec;\n/** Versioned envelope for [`HostSignRawResponse`]. */\nexport type VersionedHostSignRawResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostSignPayloadResponse;\n};\nexport const VersionedHostSignRawResponse: Codec;\n/** Versioned envelope for [`HostSignRawWithLegacyAccountError`]. */\nexport type VersionedHostSignRawWithLegacyAccountError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostSignPayloadError;\n};\nexport const VersionedHostSignRawWithLegacyAccountError: Codec;\n/** Versioned envelope for [`HostSignRawWithLegacyAccountRequest`]. */\nexport type VersionedHostSignRawWithLegacyAccountRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostSignRawWithLegacyAccountRequest;\n};\nexport const VersionedHostSignRawWithLegacyAccountRequest: Codec;\n/** Versioned envelope for [`HostSignRawWithLegacyAccountResponse`]. */\nexport type VersionedHostSignRawWithLegacyAccountResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostSignPayloadResponse;\n};\nexport const VersionedHostSignRawWithLegacyAccountResponse: Codec;\n/** Versioned envelope for [`HostThemeSubscribeError`]. */\nexport type VersionedHostThemeSubscribeError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedHostThemeSubscribeError: Codec;\n/** Versioned envelope for [`HostThemeSubscribeItem`]. */\nexport type VersionedHostThemeSubscribeItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostThemeSubscribeItem;\n};\nexport const VersionedHostThemeSubscribeItem: Codec;\n/** Versioned envelope for [`HostThemeSubscribeRequest`]. */\nexport type VersionedHostThemeSubscribeRequest = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostThemeSubscribeRequest: Codec;\n/** Versioned envelope for [`HostWorkerBeginOperationError`]. */\nexport type VersionedHostWorkerBeginOperationError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostWorkerOperationError;\n};\nexport const VersionedHostWorkerBeginOperationError: Codec;\n/** Versioned envelope for [`HostWorkerBeginOperationRequest`]. */\nexport type VersionedHostWorkerBeginOperationRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostWorkerBeginOperationRequest;\n};\nexport const VersionedHostWorkerBeginOperationRequest: Codec;\n/** Versioned envelope for [`HostWorkerBeginOperationResponse`]. */\nexport type VersionedHostWorkerBeginOperationResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostWorkerBeginOperationResponse;\n};\nexport const VersionedHostWorkerBeginOperationResponse: Codec;\n/** Versioned envelope for [`HostWorkerEndOperationError`]. */\nexport type VersionedHostWorkerEndOperationError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostWorkerOperationError;\n};\nexport const VersionedHostWorkerEndOperationError: Codec;\n/** Versioned envelope for [`HostWorkerEndOperationRequest`]. */\nexport type VersionedHostWorkerEndOperationRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HostWorkerEndOperationRequest;\n};\nexport const VersionedHostWorkerEndOperationRequest: Codec;\n/** Versioned envelope for [`HostWorkerEndOperationResponse`]. */\nexport type VersionedHostWorkerEndOperationResponse = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedHostWorkerEndOperationResponse: Codec;\n/** Pending-operation error. */\nexport type HostWorkerOperationError = \n/**\n * The product is already at the host's per-product limit of open\n * operations.\n */\n{\n tag: \"TooManyOpen\";\n value?: undefined;\n}\n/** Catch-all host failure. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostWorkerOperationError: Codec;\n/** How an image meets the box its modifiers size. */\nexport type ImageFit = \"None\" | \"Fill\" | \"Cover\" | \"Contain\" | \"ScaleDown\";\nexport const ImageFit: Codec;\n/** Properties of an `Image`. */\nexport interface ImageProps {\n /** Where the image bytes come from. */\n source: ImageSource;\n /** Defaults to `Fill`. */\n fit?: ImageFit;\n}\nexport const ImageProps: Codec;\n/** Where image bytes come from. The host fetches them; the tree carries no URL. */\nexport type ImageSource = \n/** A Bulletin chain blob, addressed by its CID. */\n{\n tag: \"Bulletin\";\n value: string;\n}\n/**\n * A file inside the product's executable archive, as a path relative to\n * the archive root.\n */\n | {\n tag: \"Archive\";\n value: string;\n};\nexport const ImageSource: Codec;\n/**\n * A user-imported (legacy) account: public key plus an optional user-chosen\n * display name.\n *\n * Returned by [`HostGetLegacyAccountsResponse`]. Distinct from\n * [`ProductAccount`], which is protocol-derived and never carries a label.\n */\nexport interface LegacyAccount {\n /** The account public key (variable-length bytes). */\n publicKey: HexString;\n /** Optional user-chosen display name. */\n name?: string;\n}\nexport const LegacyAccount: Codec;\n/**\n * Transaction payload for a legacy (non-product) account.\n *\n * Identical to [`ProductAccountTxPayload`] except the signer is a raw\n * 32-byte [`AccountId`].\n */\nexport interface LegacyAccountTxPayload {\n /** Raw 32-byte public key of the legacy account. */\n signer: AccountId;\n /** Chain where the transaction will execute. */\n genesisHash: GenesisHash;\n /** SCALE-encoded Call data. */\n callData: HexString;\n /** Transaction extensions supplied by the caller. */\n extensions: Array;\n /** 0 for Extrinsic V4, runtime-supported value for V5. */\n txExtVersion: number;\n}\nexport const LegacyAccountTxPayload: Codec;\n/** Layout and styling applied to one node. */\nexport type Modifier = \n/** Outer spacing. */\n{\n tag: \"Margin\";\n value: Dimensions;\n}\n/** Inner spacing. */\n | {\n tag: \"Padding\";\n value: Dimensions;\n}\n/** Background fill. */\n | {\n tag: \"Background\";\n value: Background;\n}\n/** Border. */\n | {\n tag: \"Border\";\n value: BorderStyle;\n}\n/** Fixed height. */\n | {\n tag: \"Height\";\n value: Size;\n}\n/** Fixed width. */\n | {\n tag: \"Width\";\n value: Size;\n}\n/** Minimum width. */\n | {\n tag: \"MinWidth\";\n value: Size;\n}\n/** Minimum height. */\n | {\n tag: \"MinHeight\";\n value: Size;\n}\n/** Fill the available width. */\n | {\n tag: \"FillWidth\";\n value: boolean;\n}\n/** Fill the available height. */\n | {\n tag: \"FillHeight\";\n value: boolean;\n}\n/** 0 is transparent, 255 is opaque. */\n | {\n tag: \"Opacity\";\n value: number;\n}\n/** Compositing mode against what is behind the node. */\n | {\n tag: \"BlendingMode\";\n value: BlendingMode;\n};\nexport const Modifier: Codec;\n/** Opaque identifier for a push notification, unique per product. */\nexport type NotificationId = number;\nexport const NotificationId: Codec;\n/** Opaque host-assigned pending-operation identifier, unique per product. */\nexport type OperationId = number;\nexport const OperationId: Codec;\n/** Outcome of starting a chain-head operation. */\nexport type OperationStartedResult = \n/** The operation was accepted; results arrive as follow events. */\n{\n tag: \"Started\";\n value: {\n operationId: string;\n };\n}\n/** Too many operations are in progress; retry after some complete. */\n | {\n tag: \"LimitReached\";\n value?: undefined;\n};\nexport const OperationStartedResult: Codec;\n/**\n * Source for a payment top-up operation.\n *\n * See [RFC 0006].\n *\n * [RFC 0006]: https://github.com/paritytech/triangle-js-sdks/pull/94\n */\nexport type PaymentTopUpSource = \n/** Fund from one of the calling product's scoped accounts. */\n{\n tag: \"ProductAccount\";\n value: {\n derivationIndex: DerivationIndex;\n };\n}\n/**\n * Fund from a one-time account represented by its private key. This is a\n * standard account holding public funds, not a coin key.\n */\n | {\n tag: \"PrivateKey\";\n value: {\n sr25519SecretKey: HexString;\n };\n}\n/**\n * Fund directly from coin secret keys. Each key is an sr25519 secret\n * controlling a single coin.\n */\n | {\n tag: \"Coins\";\n value: {\n sr25519SecretKeys: Array;\n };\n};\nexport const PaymentTopUpSource: Codec;\n/** One of the calling product's Pocket cards. */\nexport interface PocketCard {\n /** Card label declared by the product, unique within the product. */\n cardId: string;\n /** Placed by the host itself; removable by neither the user nor the product. */\n privileged: boolean;\n}\nexport const PocketCard: Codec;\n/** Preimage submission error. */\nexport type PreimageSubmitError = \n/** Catch-all. */\n{\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const PreimageSubmitError: Codec;\n/** A product account: public key only, no display name. */\nexport interface ProductAccount {\n /** The account public key (variable-length bytes). */\n publicKey: HexString;\n}\nexport const ProductAccount: Codec;\n/**\n * Identifies a product-specific account by combining a dotNS domain name with a\n * derivation index.\n */\nexport interface ProductAccountId {\n /** A dotNS domain name identifier (e.g., `\"my-product.dot\"`). */\n dotNsIdentifier: string;\n /** Account selector within the product subtree. */\n derivationIndex: DerivationIndex;\n}\nexport const ProductAccountId: Codec;\n/**\n * Transaction payload for a product account.\n *\n * Contains everything the host needs to construct a signed extrinsic.\n * The signer is a [`ProductAccountId`]; the host resolves the\n * corresponding key pair through its account management layer.\n */\nexport interface ProductAccountTxPayload {\n /** Product account that will sign the transaction. */\n signer: ProductAccountId;\n /** Chain where the transaction will execute. */\n genesisHash: GenesisHash;\n /** SCALE-encoded Call data. */\n callData: HexString;\n /** Transaction extensions supplied by the caller. */\n extensions: Array;\n /** 0 for Extrinsic V4, runtime-supported value for V5. */\n txExtVersion: number;\n}\nexport const ProductAccountTxPayload: Codec;\n/**\n * A product-scoped proof context: a product and a context within it.\n *\n * Hashed (with a `product//` prefix) into the 32-byte context bound\n * to a ring VRF proof, so contexts cannot collide across products and the same\n * member key under different contexts yields unlinkable aliases.\n */\nexport interface ProductProofContext {\n /** dotNS product identifier (e.g. `\"my-product.dot\"`) scoping the context. */\n productId: string;\n /**\n * Selector distinguishing contexts within the product; expands to the\n * same 32-byte derivation index as [`ProductAccountId::derivation_index`].\n */\n suffix: DerivationIndex;\n}\nexport const ProductProofContext: Codec;\n/** Versioned envelope for [`ProductRendererRenderError`]. */\nexport type VersionedProductRendererRenderError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedProductRendererRenderError: Codec;\n/** Versioned envelope for [`ProductRendererRenderItem`]. */\nexport type VersionedProductRendererRenderItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RendererNode;\n};\nexport const VersionedProductRendererRenderItem: Codec;\n/** Versioned envelope for [`ProductRendererRenderRequest`]. */\nexport type VersionedProductRendererRenderRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: ProductRendererRenderRequest;\n};\nexport const VersionedProductRendererRenderRequest: Codec;\n/** Raw data to sign -- either binary bytes or a string message. */\nexport type RawPayload = \n/** Raw binary data to sign. */\n{\n tag: \"Bytes\";\n value: {\n bytes: HexString;\n };\n}\n/** String message to sign. */\n | {\n tag: \"Payload\";\n value: {\n payload: string;\n };\n};\nexport const RawPayload: Codec;\n/** A registered ring-VRF key entry. */\nexport interface RegisteredRingVrfKey {\n /** Stable public name of the key. */\n handle: ProductAccountId;\n /** Rings the owning product declared this key for. */\n rings: Array;\n /** Present when the caller owns the key or requested/granted disclosure. */\n publicKey?: RingVrfPublicKey;\n}\nexport const RegisteredRingVrfKey: Codec;\n/** Versioned envelope for [`RemoteChainHeadBodyError`]. */\nexport type VersionedRemoteChainHeadBodyError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedRemoteChainHeadBodyError: Codec;\n/** Versioned envelope for [`RemoteChainHeadBodyRequest`]. */\nexport type VersionedRemoteChainHeadBodyRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainHeadBodyRequest;\n};\nexport const VersionedRemoteChainHeadBodyRequest: Codec;\n/** Versioned envelope for [`RemoteChainHeadBodyResponse`]. */\nexport type VersionedRemoteChainHeadBodyResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainHeadBodyResponse;\n};\nexport const VersionedRemoteChainHeadBodyResponse: Codec;\n/** Versioned envelope for [`RemoteChainHeadCallError`]. */\nexport type VersionedRemoteChainHeadCallError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedRemoteChainHeadCallError: Codec;\n/** Versioned envelope for [`RemoteChainHeadCallRequest`]. */\nexport type VersionedRemoteChainHeadCallRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainHeadCallRequest;\n};\nexport const VersionedRemoteChainHeadCallRequest: Codec;\n/** Versioned envelope for [`RemoteChainHeadCallResponse`]. */\nexport type VersionedRemoteChainHeadCallResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainHeadCallResponse;\n};\nexport const VersionedRemoteChainHeadCallResponse: Codec;\n/** Versioned envelope for [`RemoteChainHeadContinueError`]. */\nexport type VersionedRemoteChainHeadContinueError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedRemoteChainHeadContinueError: Codec;\n/** Versioned envelope for [`RemoteChainHeadContinueRequest`]. */\nexport type VersionedRemoteChainHeadContinueRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainHeadContinueRequest;\n};\nexport const VersionedRemoteChainHeadContinueRequest: Codec;\n/** Versioned envelope for [`RemoteChainHeadContinueResponse`]. */\nexport type VersionedRemoteChainHeadContinueResponse = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedRemoteChainHeadContinueResponse: Codec;\n/** Versioned envelope for [`RemoteChainHeadFollowError`]. */\nexport type VersionedRemoteChainHeadFollowError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedRemoteChainHeadFollowError: Codec;\n/** Versioned envelope for [`RemoteChainHeadFollowItem`]. */\nexport type VersionedRemoteChainHeadFollowItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainHeadFollowItem;\n};\nexport const VersionedRemoteChainHeadFollowItem: Codec;\n/** Versioned envelope for [`RemoteChainHeadFollowRequest`]. */\nexport type VersionedRemoteChainHeadFollowRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainHeadFollowRequest;\n};\nexport const VersionedRemoteChainHeadFollowRequest: Codec;\n/** Versioned envelope for [`RemoteChainHeadHeaderError`]. */\nexport type VersionedRemoteChainHeadHeaderError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedRemoteChainHeadHeaderError: Codec;\n/** Versioned envelope for [`RemoteChainHeadHeaderRequest`]. */\nexport type VersionedRemoteChainHeadHeaderRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainHeadHeaderRequest;\n};\nexport const VersionedRemoteChainHeadHeaderRequest: Codec;\n/** Versioned envelope for [`RemoteChainHeadHeaderResponse`]. */\nexport type VersionedRemoteChainHeadHeaderResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainHeadHeaderResponse;\n};\nexport const VersionedRemoteChainHeadHeaderResponse: Codec;\n/** Versioned envelope for [`RemoteChainHeadStopOperationError`]. */\nexport type VersionedRemoteChainHeadStopOperationError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedRemoteChainHeadStopOperationError: Codec;\n/** Versioned envelope for [`RemoteChainHeadStopOperationRequest`]. */\nexport type VersionedRemoteChainHeadStopOperationRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainHeadStopOperationRequest;\n};\nexport const VersionedRemoteChainHeadStopOperationRequest: Codec;\n/** Versioned envelope for [`RemoteChainHeadStopOperationResponse`]. */\nexport type VersionedRemoteChainHeadStopOperationResponse = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedRemoteChainHeadStopOperationResponse: Codec;\n/** Versioned envelope for [`RemoteChainHeadStorageError`]. */\nexport type VersionedRemoteChainHeadStorageError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedRemoteChainHeadStorageError: Codec;\n/** Versioned envelope for [`RemoteChainHeadStorageRequest`]. */\nexport type VersionedRemoteChainHeadStorageRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainHeadStorageRequest;\n};\nexport const VersionedRemoteChainHeadStorageRequest: Codec;\n/** Versioned envelope for [`RemoteChainHeadStorageResponse`]. */\nexport type VersionedRemoteChainHeadStorageResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainHeadStorageResponse;\n};\nexport const VersionedRemoteChainHeadStorageResponse: Codec;\n/** Versioned envelope for [`RemoteChainHeadUnpinError`]. */\nexport type VersionedRemoteChainHeadUnpinError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedRemoteChainHeadUnpinError: Codec;\n/** Versioned envelope for [`RemoteChainHeadUnpinRequest`]. */\nexport type VersionedRemoteChainHeadUnpinRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainHeadUnpinRequest;\n};\nexport const VersionedRemoteChainHeadUnpinRequest: Codec;\n/** Versioned envelope for [`RemoteChainHeadUnpinResponse`]. */\nexport type VersionedRemoteChainHeadUnpinResponse = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedRemoteChainHeadUnpinResponse: Codec;\n/** Versioned envelope for [`RemoteChainInfoError`]. */\nexport type VersionedRemoteChainInfoError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainInfoError;\n};\nexport const VersionedRemoteChainInfoError: Codec;\n/** Versioned envelope for [`RemoteChainInfoRequest`]. */\nexport type VersionedRemoteChainInfoRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainInfoRequest;\n};\nexport const VersionedRemoteChainInfoRequest: Codec;\n/** Versioned envelope for [`RemoteChainInfoResponse`]. */\nexport type VersionedRemoteChainInfoResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainInfoResponse;\n};\nexport const VersionedRemoteChainInfoResponse: Codec;\n/** Versioned envelope for [`RemoteChainSpecChainNameError`]. */\nexport type VersionedRemoteChainSpecChainNameError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedRemoteChainSpecChainNameError: Codec;\n/** Versioned envelope for [`RemoteChainSpecChainNameRequest`]. */\nexport type VersionedRemoteChainSpecChainNameRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainSpecChainNameRequest;\n};\nexport const VersionedRemoteChainSpecChainNameRequest: Codec;\n/** Versioned envelope for [`RemoteChainSpecChainNameResponse`]. */\nexport type VersionedRemoteChainSpecChainNameResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainSpecChainNameResponse;\n};\nexport const VersionedRemoteChainSpecChainNameResponse: Codec;\n/** Versioned envelope for [`RemoteChainSpecGenesisHashError`]. */\nexport type VersionedRemoteChainSpecGenesisHashError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedRemoteChainSpecGenesisHashError: Codec;\n/** Versioned envelope for [`RemoteChainSpecGenesisHashRequest`]. */\nexport type VersionedRemoteChainSpecGenesisHashRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainSpecGenesisHashRequest;\n};\nexport const VersionedRemoteChainSpecGenesisHashRequest: Codec;\n/** Versioned envelope for [`RemoteChainSpecGenesisHashResponse`]. */\nexport type VersionedRemoteChainSpecGenesisHashResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainSpecGenesisHashResponse;\n};\nexport const VersionedRemoteChainSpecGenesisHashResponse: Codec;\n/** Versioned envelope for [`RemoteChainSpecPropertiesError`]. */\nexport type VersionedRemoteChainSpecPropertiesError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedRemoteChainSpecPropertiesError: Codec;\n/** Versioned envelope for [`RemoteChainSpecPropertiesRequest`]. */\nexport type VersionedRemoteChainSpecPropertiesRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainSpecPropertiesRequest;\n};\nexport const VersionedRemoteChainSpecPropertiesRequest: Codec;\n/** Versioned envelope for [`RemoteChainSpecPropertiesResponse`]. */\nexport type VersionedRemoteChainSpecPropertiesResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainSpecPropertiesResponse;\n};\nexport const VersionedRemoteChainSpecPropertiesResponse: Codec;\n/** Versioned envelope for [`RemoteChainTransactionBroadcastError`]. */\nexport type VersionedRemoteChainTransactionBroadcastError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedRemoteChainTransactionBroadcastError: Codec;\n/** Versioned envelope for [`RemoteChainTransactionBroadcastRequest`]. */\nexport type VersionedRemoteChainTransactionBroadcastRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainTransactionBroadcastRequest;\n};\nexport const VersionedRemoteChainTransactionBroadcastRequest: Codec;\n/** Versioned envelope for [`RemoteChainTransactionBroadcastResponse`]. */\nexport type VersionedRemoteChainTransactionBroadcastResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainTransactionBroadcastResponse;\n};\nexport const VersionedRemoteChainTransactionBroadcastResponse: Codec;\n/** Versioned envelope for [`RemoteChainTransactionStopError`]. */\nexport type VersionedRemoteChainTransactionStopError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedRemoteChainTransactionStopError: Codec;\n/** Versioned envelope for [`RemoteChainTransactionStopRequest`]. */\nexport type VersionedRemoteChainTransactionStopRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteChainTransactionStopRequest;\n};\nexport const VersionedRemoteChainTransactionStopRequest: Codec;\n/** Versioned envelope for [`RemoteChainTransactionStopResponse`]. */\nexport type VersionedRemoteChainTransactionStopResponse = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedRemoteChainTransactionStopResponse: Codec;\n/**\n * One remote-operation permission requested by the product (RFC 0002).\n *\n * `ChainSubmit`, `PreimageSubmit`, and `StatementSubmit` are also triggered\n * implicitly by the corresponding business calls when not yet granted.\n */\nexport type RemotePermission = \n/**\n * Outbound HTTP/WebSocket access to a set of domains. External navigation\n * uses [`HostDevicePermissionRequest::OpenUrl`] instead.\n */\n{\n tag: \"Remote\";\n value: {\n domains: Array;\n };\n}\n/**\n * WebRTC access.\n *\n * The container authorizes each peer connection through Rust before its\n * first network method. Later methods on that connection share the same\n * decision, so a one-use grant permits one connection. New connections\n * check current permissions without requiring a page reload.\n *\n * Camera and microphone capture is gated by the OS permission prompts and\n * [`HostDevicePermissionRequest`], not by this permission.\n */\n | {\n tag: \"WebRtc\";\n value?: undefined;\n}\n/** Submitting transactions on behalf of the user via `remote_chain_transaction_broadcast`. */\n | {\n tag: \"ChainSubmit\";\n value?: undefined;\n}\n/** Submitting preimages on behalf of the user via `remote_preimage_submit`. */\n | {\n tag: \"PreimageSubmit\";\n value?: undefined;\n}\n/** Submitting statements on behalf of the user via `remote_statement_store_submit`. */\n | {\n tag: \"StatementSubmit\";\n value?: undefined;\n};\nexport const RemotePermission: Codec;\n/** Versioned envelope for [`RemotePermissionError`]. */\nexport type VersionedRemotePermissionError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedRemotePermissionError: Codec;\n/** Versioned envelope for [`RemotePermissionRequest`]. */\nexport type VersionedRemotePermissionRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemotePermissionRequest;\n};\nexport const VersionedRemotePermissionRequest: Codec;\n/** Versioned envelope for [`RemotePermissionResponse`]. */\nexport type VersionedRemotePermissionResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemotePermissionResponse;\n};\nexport const VersionedRemotePermissionResponse: Codec;\n/** Versioned envelope for [`RemotePreimageLookupSubscribeError`]. */\nexport type VersionedRemotePreimageLookupSubscribeError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedRemotePreimageLookupSubscribeError: Codec;\n/** Versioned envelope for [`RemotePreimageLookupSubscribeItem`]. */\nexport type VersionedRemotePreimageLookupSubscribeItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemotePreimageLookupSubscribeItem;\n};\nexport const VersionedRemotePreimageLookupSubscribeItem: Codec;\n/** Versioned envelope for [`RemotePreimageLookupSubscribeRequest`]. */\nexport type VersionedRemotePreimageLookupSubscribeRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemotePreimageLookupSubscribeRequest;\n};\nexport const VersionedRemotePreimageLookupSubscribeRequest: Codec;\n/** Versioned envelope for [`RemotePreimageSubmitError`]. */\nexport type VersionedRemotePreimageSubmitError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: PreimageSubmitError;\n};\nexport const VersionedRemotePreimageSubmitError: Codec;\n/** Versioned envelope for [`RemotePreimageSubmitRequest`]. */\nexport type VersionedRemotePreimageSubmitRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HexString;\n};\nexport const VersionedRemotePreimageSubmitRequest: Codec;\n/** Versioned envelope for [`RemotePreimageSubmitResponse`]. */\nexport type VersionedRemotePreimageSubmitResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: HexString;\n};\nexport const VersionedRemotePreimageSubmitResponse: Codec;\n/** Versioned envelope for [`RemoteStatementStoreCreateProofAuthorizedError`]. */\nexport type VersionedRemoteStatementStoreCreateProofAuthorizedError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteStatementStoreCreateProofError;\n};\nexport const VersionedRemoteStatementStoreCreateProofAuthorizedError: Codec;\n/** Versioned envelope for [`RemoteStatementStoreCreateProofAuthorizedRequest`]. */\nexport type VersionedRemoteStatementStoreCreateProofAuthorizedRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: Statement;\n};\nexport const VersionedRemoteStatementStoreCreateProofAuthorizedRequest: Codec;\n/** Versioned envelope for [`RemoteStatementStoreCreateProofAuthorizedResponse`]. */\nexport type VersionedRemoteStatementStoreCreateProofAuthorizedResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteStatementStoreCreateProofResponse;\n};\nexport const VersionedRemoteStatementStoreCreateProofAuthorizedResponse: Codec;\n/** Versioned envelope for [`RemoteStatementStoreCreateProofError`]. */\nexport type VersionedRemoteStatementStoreCreateProofError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteStatementStoreCreateProofError;\n};\nexport const VersionedRemoteStatementStoreCreateProofError: Codec;\n/** Versioned envelope for [`RemoteStatementStoreCreateProofRequest`]. */\nexport type VersionedRemoteStatementStoreCreateProofRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteStatementStoreCreateProofRequest;\n};\nexport const VersionedRemoteStatementStoreCreateProofRequest: Codec;\n/** Versioned envelope for [`RemoteStatementStoreCreateProofResponse`]. */\nexport type VersionedRemoteStatementStoreCreateProofResponse = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteStatementStoreCreateProofResponse;\n};\nexport const VersionedRemoteStatementStoreCreateProofResponse: Codec;\n/** Versioned envelope for [`RemoteStatementStoreSubmitError`]. */\nexport type VersionedRemoteStatementStoreSubmitError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedRemoteStatementStoreSubmitError: Codec;\n/** Versioned envelope for [`RemoteStatementStoreSubmitRequest`]. */\nexport type VersionedRemoteStatementStoreSubmitRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: SignedStatement;\n};\nexport const VersionedRemoteStatementStoreSubmitRequest: Codec;\n/** Versioned envelope for [`RemoteStatementStoreSubmitResponse`]. */\nexport type VersionedRemoteStatementStoreSubmitResponse = \n/** Version 1 (no payload). */\n{\n tag: \"V1\";\n value?: undefined;\n};\nexport const VersionedRemoteStatementStoreSubmitResponse: Codec;\n/** Versioned envelope for [`RemoteStatementStoreSubscribeError`]. */\nexport type VersionedRemoteStatementStoreSubscribeError = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: GenericError;\n};\nexport const VersionedRemoteStatementStoreSubscribeError: Codec;\n/** Versioned envelope for [`RemoteStatementStoreSubscribeItem`]. */\nexport type VersionedRemoteStatementStoreSubscribeItem = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteStatementStoreSubscribeItem;\n};\nexport const VersionedRemoteStatementStoreSubscribeItem: Codec;\n/** Versioned envelope for [`RemoteStatementStoreSubscribeRequest`]. */\nexport type VersionedRemoteStatementStoreSubscribeRequest = \n/** Version 1 payload. */\n{\n tag: \"V1\";\n value: RemoteStatementStoreSubscribeRequest;\n};\nexport const VersionedRemoteStatementStoreSubscribeRequest: Codec;\n/** Where a product-rendered body lives, and the id that names it there. */\nexport type RenderContext = \n/** A message in a chat room. */\n{\n tag: \"ChatMessage\";\n value: {\n roomId: string;\n messageId: string;\n messageType: string;\n };\n}\n/** A candidate answered to an input query. */\n | {\n tag: \"InputWidget\";\n value: {\n candidateId: string;\n };\n}\n/** A card face in the host's Pocket collection. */\n | {\n tag: \"PocketCard\";\n value: {\n cardId: string;\n };\n};\nexport const RenderContext: Codec;\n/**\n * A node in a product-rendered tree. Container variants recurse through\n * `children`.\n */\nexport type RendererNode = \n/** Draws nothing. */\n{\n tag: \"Nil\";\n value?: undefined;\n}\n/** A text run. */\n | {\n tag: \"String\";\n value: {\n text: string;\n };\n}\n/** Generic container. */\n | {\n tag: \"Box\";\n value: {\n modifiers: Array;\n props: BoxProps;\n children: Array;\n };\n}\n/** Vertical layout. */\n | {\n tag: \"Column\";\n value: {\n modifiers: Array;\n props: ColumnProps;\n children: Array;\n };\n}\n/** Horizontal layout. */\n | {\n tag: \"Row\";\n value: {\n modifiers: Array;\n props: RowProps;\n children: Array;\n };\n}\n/** Flexible space. */\n | {\n tag: \"Spacer\";\n value: {\n modifiers: Array;\n };\n}\n/** Styled text. */\n | {\n tag: \"Text\";\n value: {\n modifiers: Array;\n props: TextProps;\n children: Array;\n };\n}\n/** Interactive button. */\n | {\n tag: \"Button\";\n value: {\n modifiers: Array;\n props: ButtonProps;\n children: Array;\n };\n}\n/** Single-line text input. */\n | {\n tag: \"TextField\";\n value: {\n modifiers: Array;\n props: TextFieldProps;\n };\n}\n/** Image, sized by modifiers. */\n | {\n tag: \"Image\";\n value: {\n modifiers: Array;\n props: ImageProps;\n };\n}\n/** Applies its effect to its children. */\n | {\n tag: \"Effect\";\n value: {\n props: EffectProps;\n children: Array;\n };\n};\nexport const RendererNode: Codec;\n/** Error from [`crate::api::ResourceAllocation::request`]. */\nexport type ResourceAllocationError = \n/** Catch-all. */\n{\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const ResourceAllocationError: Codec;\n/**\n * Locates a ring for ring VRF operations using only identifiers that are\n * stable across membership changes.\n */\nexport interface RingLocation {\n /** Genesis hash of the chain hosting the ring. */\n chainId: GenesisHash;\n /** Path addressing the ring within the chain. */\n junctions: Array;\n}\nexport const RingLocation: Codec;\n/** A single step in a [`RingLocation`] path, addressing a ring within a chain. */\nexport type RingLocationJunction = \n/** Pallet instance hosting the ring collection. */\n{\n tag: \"PalletInstance\";\n value: number;\n}\n/** Ring collection identifier within the pallet. */\n | {\n tag: \"CollectionId\";\n value: HexString;\n};\nexport const RingLocationJunction: Codec;\n/** How much of a registry entry the caller asks for. */\nexport type RingVrfKeyDisclosure = \"Anonymized\" | \"PublicKey\";\nexport const RingVrfKeyDisclosure: Codec;\n/** Ring-VRF member public key. */\nexport type RingVrfPublicKey = HexString;\nexport const RingVrfPublicKey: Codec;\n/** Properties of a `Row`. */\nexport interface RowProps {\n /** Cross-axis alignment of children. */\n verticalAlignment?: VerticalAlignment;\n /** Main-axis distribution of children. */\n horizontalArrangement?: Arrangement;\n}\nexport const RowProps: Codec;\n/** One entry of a runtime's supported API list. */\nexport interface RuntimeApi {\n /** Runtime API name. */\n name: string;\n /** Runtime API version. */\n version: number;\n}\nexport const RuntimeApi: Codec;\n/** Runtime version information for a block's runtime. */\nexport interface RuntimeSpec {\n /** Specification name. */\n specName: string;\n /** Implementation name. */\n implName: string;\n /** Spec version number. */\n specVersion: number;\n /** Implementation version. */\n implVersion: number;\n /** Transaction format version. */\n transactionVersion?: number;\n /** Supported runtime APIs. */\n apis: Array;\n}\nexport const RuntimeSpec: Codec;\n/** Runtime attached to follow events, either a decoded spec or a decode error. */\nexport type RuntimeType = \n/** Runtime spec decoded successfully. */\n{\n tag: \"Valid\";\n value: RuntimeSpec;\n}\n/** The runtime could not be decoded. */\n | {\n tag: \"Invalid\";\n value: {\n error: string;\n };\n};\nexport const RuntimeType: Codec;\n/** Outline of a background or border. */\nexport type Shape = \n/** Rounded corners with the given radius. */\n{\n tag: \"Rounded\";\n value: Size;\n}\n/** Circular shape. */\n | {\n tag: \"Circle\";\n value?: undefined;\n}\n/** Square corners. */\n | {\n tag: \"Square\";\n value?: undefined;\n};\nexport const Shape: Codec;\n/** A statement with a required (not optional) proof. */\nexport interface SignedStatement {\n /** Required cryptographic proof. */\n proof: StatementProof;\n /** Optional decryption key. */\n decryptionKey?: HexString;\n /** Optional Unix timestamp expiry. */\n expiry?: bigint;\n /** Optional channel. */\n channel?: HexString;\n /** [u8; 32] tags. */\n topics: Array;\n /** Optional data payload. */\n data?: HexString;\n}\nexport const SignedStatement: Codec;\n/** A size in logical pixels, SCALE-encoded as `Compact`. */\nexport type Size = number | bigint;\nexport const Size: Codec;\n/** A statement with optional proof and metadata. */\nexport interface Statement {\n /** Optional cryptographic proof. */\n proof?: StatementProof;\n /** Optional decryption key. */\n decryptionKey?: HexString;\n /** Optional Unix timestamp expiry. */\n expiry?: bigint;\n /** Optional channel. */\n channel?: HexString;\n /** [u8; 32] tags. */\n topics: Array;\n /** Optional data payload. */\n data?: HexString;\n}\nexport const Statement: Codec;\n/** Cryptographic proof for a statement. */\nexport type StatementProof = \n/** Sr25519 signature proof. */\n{\n tag: \"Sr25519\";\n value: {\n signature: HexString;\n signer: HexString;\n };\n}\n/** Ed25519 signature proof. */\n | {\n tag: \"Ed25519\";\n value: {\n signature: HexString;\n signer: HexString;\n };\n}\n/** ECDSA signature proof. */\n | {\n tag: \"Ecdsa\";\n value: {\n signature: HexString;\n signer: HexString;\n };\n}\n/** On-chain event proof. */\n | {\n tag: \"OnChain\";\n value: {\n who: HexString;\n blockHash: HexString;\n event: bigint;\n };\n};\nexport const StatementProof: Codec;\n/** A single key query within a chain-head storage request. */\nexport interface StorageQueryItem {\n /** Storage key to query. */\n key: HexString;\n /** What to return. */\n queryType: StorageQueryType;\n}\nexport const StorageQueryItem: Codec;\n/** What a chain-head storage query returns for a key. */\nexport type StorageQueryType = \"Value\" | \"Hash\" | \"ClosestDescendantMerkleValue\" | \"DescendantsValues\" | \"DescendantsHashes\";\nexport const StorageQueryType: Codec;\n/** Result for one queried storage key. */\nexport interface StorageResultItem {\n /** The queried key. */\n key: HexString;\n /** Value, if requested. */\n value?: HexString;\n /** Hash, if requested. */\n hash?: HexString;\n /** Merkle value, if requested. */\n closestDescendantMerkleValue?: HexString;\n}\nexport const StorageResultItem: Codec;\n/** Properties of a `TextField`. */\nexport interface TextFieldProps {\n /** Current value. */\n text: string;\n /** Shown when the value is empty. */\n placeholder?: string;\n /** Field label. */\n label?: string;\n /** Whether the field accepts input. Absent leaves the default to the host. */\n enabled?: boolean;\n /**\n * Action triggered on every value change. The action carries the new\n * value as UTF-8 bytes, with no length prefix.\n */\n valueChangeAction?: string;\n}\nexport const TextFieldProps: Codec;\n/** Properties of a `Text`. */\nexport interface TextProps {\n /** Typography preset. */\n style?: TypographyStyle;\n /** Text color. */\n color?: ColorToken;\n}\nexport const TextProps: Codec;\n/** Identifies a named theme. */\nexport type ThemeName = \n/** A custom named theme. */\n{\n tag: \"Custom\";\n value: string;\n}\n/** The host's default theme. */\n | {\n tag: \"Default\";\n value?: undefined;\n};\nexport const ThemeName: Codec;\n/** Light or dark variant. */\nexport type ThemeVariant = \"Light\" | \"Dark\";\nexport const ThemeVariant: Codec;\n/** 32-byte statement topic. */\nexport type Topic = HexString;\nexport const Topic: Codec;\n/** A signed extension for a transaction payload. */\nexport interface TxPayloadExtension {\n /** Extension name (e.g., `\"CheckSpecVersion\"`). */\n id: string;\n /** SCALE-encoded extra data (in extrinsic body). */\n extra: HexString;\n /** SCALE-encoded implicit data (signed, not in body). */\n additionalSigned: HexString;\n}\nexport const TxPayloadExtension: Codec;\n/** Typography presets, resolved by the host's design system. */\nexport type TypographyStyle = \"HeadlineLarge\" | \"TitleMediumRegular\" | \"BodyLargeRegular\" | \"BodyMediumRegular\" | \"BodySmallRegular\";\nexport const TypographyStyle: Codec;\n/** User's authentication state. */\nexport type HostAccountConnectionStatusSubscribeItem = \"Disconnected\" | \"Connected\";\nexport const HostAccountConnectionStatusSubscribeItem: Codec;\n/** Error returned when ring VRF proof creation fails. */\nexport type HostAccountCreateProofError = \n/** Ring not available at the specified location. */\n{\n tag: \"RingNotFound\";\n value?: undefined;\n}\n/** The registered member key is not a member of the requested ring. */\n | {\n tag: \"NotMember\";\n value?: undefined;\n}\n/** The key handle is not registered. */\n | {\n tag: \"KeyNotRegistered\";\n value?: undefined;\n}\n/** The key handle is not registered for the requested ring. */\n | {\n tag: \"KeyNotInRing\";\n value?: undefined;\n}\n/** The foreign key owner has not allowlisted the caller. */\n | {\n tag: \"NotAllowlisted\";\n value?: undefined;\n}\n/** User or host rejected. */\n | {\n tag: \"Rejected\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostAccountCreateProofError: Codec;\n/** Request to create a ring VRF proof. */\nexport interface HostAccountCreateProofRequest {\n /** Ring-VRF key handle naming the member key to use. */\n keyHandle: ProductAccountId;\n /** Product-scoped context the derived alias is bound to. */\n context: ProductProofContext;\n /** Ring to generate the proof against. */\n ringLocation: RingLocation;\n /** Opaque message bound into the proof. */\n message: HexString;\n}\nexport const HostAccountCreateProofRequest: Codec;\n/**\n * Response containing a ring VRF proof and the values needed to verify it\n * against a downstream precompile.\n */\nexport interface HostAccountCreateProofResponse {\n /** Variable-length ring VRF proof bytes. */\n proof: HexString;\n /** Alias derived for the request's context. */\n contextualAlias: ContextualAlias;\n /** Index of the selected member key within the ring. */\n ringIndex: number;\n /** Ring revision the proof was generated against. */\n ringRevision: number;\n}\nexport const HostAccountCreateProofResponse: Codec;\n/** Error returned when contextual alias derivation fails. */\nexport type HostAccountGetAliasError = \n/** Ring not available at the specified location. */\n{\n tag: \"RingNotFound\";\n value?: undefined;\n}\n/** The registered member key is not a member of the requested ring. */\n | {\n tag: \"NotMember\";\n value?: undefined;\n}\n/** The key handle is not registered. */\n | {\n tag: \"KeyNotRegistered\";\n value?: undefined;\n}\n/** The key handle is not registered for the requested ring. */\n | {\n tag: \"KeyNotInRing\";\n value?: undefined;\n}\n/** User or host rejected. */\n | {\n tag: \"Rejected\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostAccountGetAliasError: Codec;\n/** Request to retrieve the contextual alias for a context and ring. */\nexport interface HostAccountGetAliasRequest {\n /** Ring-VRF key handle naming the member key to use. */\n keyHandle: ProductAccountId;\n /** Product-scoped context to derive the alias for. */\n context: ProductProofContext;\n /** Ring whose member key the host should use; matches `create_proof`. */\n ringLocation: RingLocation;\n}\nexport const HostAccountGetAliasRequest: Codec;\n/** Error returned when credential/account requests fail. */\nexport type HostAccountGetError = \n/** User is not logged in. */\n{\n tag: \"NotConnected\";\n value?: undefined;\n}\n/** User or host rejected the request. */\n | {\n tag: \"Rejected\";\n value?: undefined;\n}\n/** Domain identifier is invalid. */\n | {\n tag: \"DomainNotValid\";\n value?: undefined;\n}\n/** Catch-all error with reason. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostAccountGetError: Codec;\n/** Request to retrieve a product-scoped account. */\nexport interface HostAccountGetRequest {\n /** Product account to retrieve. */\n productAccountId: ProductAccountId;\n}\nexport const HostAccountGetRequest: Codec;\n/** Response containing a product-scoped account. */\nexport interface HostAccountGetResponse {\n /** Retrieved product account. */\n account: ProductAccount;\n}\nexport const HostAccountGetResponse: Codec;\n/** Error returned when listing ring-VRF keys fails. */\nexport type HostAccountListRingVrfKeysError = \n/** User is not logged in. */\n{\n tag: \"NotConnected\";\n value?: undefined;\n}\n/** User or host rejected. */\n | {\n tag: \"Rejected\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostAccountListRingVrfKeysError: Codec;\n/** Request to list registered ring-VRF keys for an owner product. */\nexport interface HostAccountListRingVrfKeysRequest {\n /** Product whose registry entries should be listed. */\n owner: string;\n /** Disclosure level requested by the caller. */\n disclosure: RingVrfKeyDisclosure;\n}\nexport const HostAccountListRingVrfKeysRequest: Codec;\n/** Error returned when ring-VRF key registration fails. */\nexport type HostAccountRegisterRingVrfKeyError = \n/** User is not logged in. */\n{\n tag: \"NotConnected\";\n value?: undefined;\n}\n/** Ring not available at the specified location. */\n | {\n tag: \"RingNotFound\";\n value?: undefined;\n}\n/** User or host rejected. */\n | {\n tag: \"Rejected\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostAccountRegisterRingVrfKeyError: Codec;\n/** Request to register a ring-VRF key owned by the calling product. */\nexport interface HostAccountRegisterRingVrfKeyRequest {\n /** Key derivation index within the caller's ring-VRF domain. */\n index: DerivationIndex;\n /** Ring this key is declared for. */\n ring: RingLocation;\n}\nexport const HostAccountRegisterRingVrfKeyRequest: Codec;\n/** Error returned when direct ring-VRF key signing fails. */\nexport type HostAccountRingVrfSignError = \n/** User is not logged in. */\n{\n tag: \"NotConnected\";\n value?: undefined;\n}\n/** The key handle is not registered. */\n | {\n tag: \"KeyNotRegistered\";\n value?: undefined;\n}\n/** The foreign key owner has not allowlisted the caller. */\n | {\n tag: \"NotAllowlisted\";\n value?: undefined;\n}\n/** User or host rejected. */\n | {\n tag: \"Rejected\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostAccountRingVrfSignError: Codec;\n/** Request to sign bytes with a registered ring-VRF key. */\nexport interface HostAccountRingVrfSignRequest {\n /** Registered key handle. */\n keyHandle: ProductAccountId;\n /** Opaque message to sign. */\n message: HexString;\n}\nexport const HostAccountRingVrfSignRequest: Codec;\n/** Error returned when VRF signing fails. */\nexport type HostAccountSignVrfError = \n/** User is not logged in. */\n{\n tag: \"NotConnected\";\n value?: undefined;\n}\n/** User or host rejected the signing confirmation. */\n | {\n tag: \"Rejected\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostAccountSignVrfError: Codec;\n/**\n * Request to produce an sr25519 VRF signature from a product account over a\n * caller-supplied Merlin transcript.\n */\nexport interface HostAccountSignVrfRequest {\n /** Account whose key signs the VRF. */\n account: ProductAccountId;\n /** Root domain-separation label: `Transcript::new(transcript_label)`. */\n transcriptLabel: HexString;\n /** Transcript items replayed in order as `append_message(label, value)`. */\n items: Array;\n}\nexport const HostAccountSignVrfRequest: Codec;\n/** A chat action received from the host. */\nexport interface HostChatActionSubscribeItem {\n /** Room where the action occurred. */\n roomId: string;\n /** Peer who initiated the action. */\n peer: string;\n /** The action payload. */\n payload: ChatActionPayload;\n}\nexport const HostChatActionSubscribeItem: Codec;\n/** Chat room registration error. */\nexport type HostChatCreateRoomError = \n/** Not allowed. */\n{\n tag: \"PermissionDenied\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostChatCreateRoomError: Codec;\n/** Request to create a chat room. */\nexport interface HostChatCreateRoomRequest {\n /** Unique room identifier. */\n roomId: string;\n /** Room display name. */\n name: string;\n /** URL or base64 image. */\n icon: string;\n}\nexport const HostChatCreateRoomRequest: Codec;\n/** Result of a room registration. */\nexport interface HostChatCreateRoomResponse {\n /** `New` or `Exists`. */\n status: ChatRoomRegistrationStatus;\n}\nexport const HostChatCreateRoomResponse: Codec;\n/** Item containing the current chat rooms. */\nexport interface HostChatListSubscribeItem {\n /** Chat rooms the product participates in. */\n rooms: Array;\n}\nexport const HostChatListSubscribeItem: Codec;\n/** Chat message posting error. */\nexport type HostChatPostMessageError = \n/** Message exceeded size limit. */\n{\n tag: \"MessageTooLarge\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostChatPostMessageError: Codec;\n/** Request to post a message to a chat room. */\nexport interface HostChatPostMessageRequest {\n /** Room to post to. */\n roomId: string;\n /** Message content. */\n payload: ChatMessageContent;\n}\nexport const HostChatPostMessageRequest: Codec;\n/** Result of posting a message. */\nexport interface HostChatPostMessageResponse {\n /**\n * Host-assigned message id, and the correlation key for any action the\n * message carries: a trigger names it in [`ActionTrigger::message_id`].\n */\n messageId: string;\n}\nexport const HostChatPostMessageResponse: Codec;\n/** Chat bot registration error. */\nexport type HostChatRegisterBotError = \n/** Not allowed. */\n{\n tag: \"PermissionDenied\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostChatRegisterBotError: Codec;\n/** Request to register a chat bot. */\nexport interface HostChatRegisterBotRequest {\n /** Unique bot identifier. */\n botId: string;\n /** Bot display name. */\n name: string;\n /** URL or base64 image. */\n icon: string;\n}\nexport const HostChatRegisterBotRequest: Codec;\n/** Result of a bot registration. */\nexport interface HostChatRegisterBotResponse {\n /** `New` or `Exists`. */\n status: ChatBotRegistrationStatus;\n}\nexport const HostChatRegisterBotResponse: Codec;\n/** Request to create a cheque from a local purse to a receivable. */\nexport interface HostCoinPaymentCreateChequeRequest {\n /** Source purse. */\n from: CoinPaymentPurseId;\n /** Destination receivable. */\n to: CoinPaymentReceivable;\n /** Payment amount. */\n amount: CoinPaymentBalance;\n}\nexport const HostCoinPaymentCreateChequeRequest: Codec;\n/** Created cheque response. */\nexport interface HostCoinPaymentCreateChequeResponse {\n /** Encrypted cheque. */\n cheque: CoinPaymentCheque;\n}\nexport const HostCoinPaymentCreateChequeResponse: Codec;\n/** Request to create a new firewalled CoinPayment purse. */\nexport interface HostCoinPaymentCreatePurseRequest {\n /** Human-readable purse name. */\n name: string;\n}\nexport const HostCoinPaymentCreatePurseRequest: Codec;\n/** Created purse identifier. */\nexport interface HostCoinPaymentCreatePurseResponse {\n /** Assigned purse identifier. */\n purse: CoinPaymentPurseId;\n}\nexport const HostCoinPaymentCreatePurseResponse: Codec;\n/** Request to create a fresh receivable for a purse. */\nexport interface HostCoinPaymentCreateReceivableRequest {\n /** Target purse for future deposits. */\n into: CoinPaymentPurseId;\n}\nexport const HostCoinPaymentCreateReceivableRequest: Codec;\n/** Created receivable response. */\nexport interface HostCoinPaymentCreateReceivableResponse {\n /** Receivable public key. */\n receivable: CoinPaymentReceivable;\n}\nexport const HostCoinPaymentCreateReceivableResponse: Codec;\n/** Request to delete a purse after draining its balance. */\nexport interface HostCoinPaymentDeletePurseRequest {\n /** Purse to delete. */\n target: CoinPaymentPurseId;\n /** Purse that receives drained funds. */\n drainInto: CoinPaymentPurseId;\n}\nexport const HostCoinPaymentDeletePurseRequest: Codec;\n/** Request to deposit a cheque into the purse associated with its receivable. */\nexport interface HostCoinPaymentDepositRequest {\n /** Cheque to deposit. */\n cheque: CoinPaymentCheque;\n}\nexport const HostCoinPaymentDepositRequest: Codec;\n/** Stream item for `host_coin_payment_listen_for`. */\nexport type HostCoinPaymentListenForItem = \n/** Handoff channel suitable for inclusion in an invoice. */\n{\n tag: \"Channel\";\n value: CoinPaymentTransmissionChannel;\n}\n/** Cheque received through the handoff channel. */\n | {\n tag: \"Cheque\";\n value: CoinPaymentCheque;\n};\nexport const HostCoinPaymentListenForItem: Codec;\n/** Request to listen for a cheque delivered to a receivable. */\nexport interface HostCoinPaymentListenForRequest {\n /** Receivable to listen for. */\n receivable: CoinPaymentReceivable;\n}\nexport const HostCoinPaymentListenForRequest: Codec;\n/** Request to query product-visible purse metadata. */\nexport interface HostCoinPaymentQueryPurseRequest {\n /** Purse to query. */\n purse: CoinPaymentPurseId;\n}\nexport const HostCoinPaymentQueryPurseRequest: Codec;\n/** Product-visible purse metadata response. */\nexport interface HostCoinPaymentQueryPurseResponse {\n /** Purse information. */\n info: CoinPaymentPurseInfo;\n}\nexport const HostCoinPaymentQueryPurseResponse: Codec;\n/** Request to transfer balance between local purses. */\nexport interface HostCoinPaymentRebalancePurseRequest {\n /** Source purse. */\n from: CoinPaymentPurseId;\n /** Destination purse. */\n to: CoinPaymentPurseId;\n /** Amount to move. */\n amount: CoinPaymentBalance;\n}\nexport const HostCoinPaymentRebalancePurseRequest: Codec;\n/** Request to refund coins associated with a receivable. */\nexport interface HostCoinPaymentRefundRequest {\n /** Receivable to refund. */\n receivable: CoinPaymentReceivable;\n}\nexport const HostCoinPaymentRefundRequest: Codec;\n/** Transaction creation error. */\nexport type HostCreateTransactionError = \n/** Payload could not be deserialized. */\n{\n tag: \"FailedToDecode\";\n value?: undefined;\n}\n/** User rejected. */\n | {\n tag: \"Rejected\";\n value?: undefined;\n}\n/** Unsupported payload version or extension. */\n | {\n tag: \"NotSupported\";\n value: {\n reason: string;\n };\n}\n/** Not authenticated. */\n | {\n tag: \"PermissionDenied\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostCreateTransactionError: Codec;\n/** Response containing a created transaction. */\nexport interface HostCreateTransactionResponse {\n /**\n * SCALE-encoded transaction, signed unless the request supplied its own\n * V5 `VerifyMultiSignature` extension.\n */\n transaction: HexString;\n}\nexport const HostCreateTransactionResponse: Codec;\n/** Response containing a transaction created with a non-product account. */\nexport interface HostCreateTransactionWithLegacyAccountResponse {\n /**\n * SCALE-encoded transaction, signed unless the request supplied its own\n * V5 `VerifyMultiSignature` extension.\n */\n transaction: HexString;\n}\nexport const HostCreateTransactionWithLegacyAccountResponse: Codec;\n/** Error from [`crate::api::Entropy::derive`] (RFC 0007). */\nexport type HostDeriveEntropyError = \n/** Catch-all. */\n{\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostDeriveEntropyError: Codec;\n/**\n * Request to derive deterministic per-product entropy (RFC 0007).\n *\n * The host derives 32 bytes from product-scoped seed material and `context`.\n * Repeated calls with the same `context` for the same product yield the same\n * entropy.\n */\nexport interface HostDeriveEntropyRequest {\n /** Domain-separated derivation context. */\n context: HexString;\n}\nexport const HostDeriveEntropyRequest: Codec;\n/** Response carrying 32 bytes of deterministically derived entropy. */\nexport interface HostDeriveEntropyResponse {\n /** 32 bytes of derived entropy. */\n entropy: HexString;\n}\nexport const HostDeriveEntropyResponse: Codec;\n/**\n * Device-capability permission requested from the host (RFC 0002).\n *\n * Lasting grants and denials survive app restarts. A host may also offer a\n * one-use grant, held in memory until a permission-gated operation consumes it.\n *\n * That decision is about this product. The OS grant behind it belongs to the\n * host application and can move independently, so a host that can read OS\n * state has the capability resolve only while both allow it: a stored grant\n * whose OS grant was revoked answers `granted: false` without a prompt. An OS\n * grant that is merely undetermined does not change the answer, because the OS\n * resolves its own gate when the capability is used.\n */\nexport type HostDevicePermissionRequest = \"Notifications\" | \"Camera\" | \"Microphone\" | \"Bluetooth\" | \"NFC\" | \"Location\" | \"Clipboard\" | \"OpenUrl\" | \"Biometrics\";\nexport const HostDevicePermissionRequest: Codec;\n/** Outcome of a device-permission request. */\nexport interface HostDevicePermissionResponse {\n /** Whether the permission was granted. */\n granted: boolean;\n}\nexport const HostDevicePermissionResponse: Codec;\n/** Request to query whether a feature is supported by the host. */\nexport type HostFeatureSupportedRequest = \n/** Ask whether the host can interact with the chain identified by genesis hash. */\n{\n tag: \"Chain\";\n value: {\n genesisHash: HexString;\n };\n};\nexport const HostFeatureSupportedRequest: Codec;\n/** Response to a feature-support query. */\nexport interface HostFeatureSupportedResponse {\n /** Whether the feature is supported. */\n supported: boolean;\n}\nexport const HostFeatureSupportedResponse: Codec;\n/** Response containing all legacy (user-imported) accounts owned by the user. */\nexport interface HostGetLegacyAccountsResponse {\n /** Legacy accounts. */\n accounts: Array;\n}\nexport const HostGetLegacyAccountsResponse: Codec;\n/** Response containing the product context bound to the current host runtime. */\nexport interface HostGetProductContextResponse {\n /** Full canonical identifier used for authorization and account derivation. */\n productId: string;\n}\nexport const HostGetProductContextResponse: Codec;\n/** Error from [`crate::api::Account::get_user_id`]. */\nexport type HostGetUserIdError = \n/** User denied the identity disclosure request. */\n{\n tag: \"PermissionDenied\";\n value?: undefined;\n}\n/** User is not logged in. */\n | {\n tag: \"NotConnected\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostGetUserIdError: Codec;\n/** The user's primary DotNS account identity. */\nexport interface HostGetUserIdResponse {\n /** The user's primary DotNS username. */\n primaryUsername: string;\n}\nexport const HostGetUserIdResponse: Codec;\n/**\n * Error from [`crate::api::System::handshake`] (RFC 0009).\n *\n * The handshake is the first call on a fresh connection; it does not require\n * user authentication and is used to negotiate the wire codec version.\n */\nexport type HostHandshakeError = \n/** Host did not complete the handshake in time. */\n{\n tag: \"Timeout\";\n value?: undefined;\n}\n/** Host does not speak the codec version requested by the product. */\n | {\n tag: \"UnsupportedProtocolVersion\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: GenericError;\n};\nexport const HostHandshakeError: Codec;\n/** Wire-codec negotiation payload sent by the product (RFC 0009). */\nexport interface HostHandshakeRequest {\n /** Wire codec version requested by the product. */\n codecVersion: number;\n}\nexport const HostHandshakeRequest: Codec;\n/** A change to a subscribed storage key, pushed to the subscriber. */\nexport interface HostLocalStorageChangeItem {\n /** Value after the change. `Some` on write, `None` after clear. */\n value?: HexString;\n}\nexport const HostLocalStorageChangeItem: Codec;\n/** Request to clear a local storage key. */\nexport interface HostLocalStorageClearRequest {\n /** Storage key to clear. */\n key: string;\n}\nexport const HostLocalStorageClearRequest: Codec;\n/** Local storage operation error. */\nexport type V01HostLocalStorageReadError = \n/** Storage quota exceeded. */\n{\n tag: \"Full\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const V01HostLocalStorageReadError: Codec;\n/** Request to read a local storage value. */\nexport interface V01HostLocalStorageReadRequest {\n /** Storage key to read. */\n key: string;\n}\nexport const V01HostLocalStorageReadRequest: Codec;\n/** Response containing an optional local storage value. */\nexport interface HostLocalStorageReadResponse {\n /** Stored value, if present. */\n value?: HexString;\n}\nexport const HostLocalStorageReadResponse: Codec;\n/** Request to subscribe to changes of one local storage key. */\nexport interface HostLocalStorageSubscribeRequest {\n /** Storage key to observe. */\n key: string;\n}\nexport const HostLocalStorageSubscribeRequest: Codec;\n/** Request to write a value into local storage. */\nexport interface HostLocalStorageWriteRequest {\n /** Storage key to write. */\n key: string;\n /** Value to store at the key. */\n value: HexString;\n}\nexport const HostLocalStorageWriteRequest: Codec;\n/** Locale the host currently presents its interface in, pushed to subscribers. */\nexport interface HostLocaleSubscribeItem {\n /**\n * BCP 47 language tag, such as `en`, `pt-BR` or `zh-Hans`. The set is\n * open: a product that does not ship the tag chooses its own fallback.\n */\n languageTag: string;\n}\nexport const HostLocaleSubscribeItem: Codec;\n/** Error from [`crate::api::System::navigate_to`]. */\nexport type HostNavigateToError = \n/**\n * The target host is not authorized for outbound access: the user answered\n * no to the prompt, a stored decision already refused it, or no prompt\n * could be put to the user.\n */\n{\n tag: \"PermissionDenied\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostNavigateToError: Codec;\n/** Request to navigate the host to an external URL. */\nexport interface HostNavigateToRequest {\n /** URL to open. */\n url: string;\n}\nexport const HostNavigateToRequest: Codec;\n/**\n * Error from [`crate::api::Payment::balance_subscribe`].\n *\n * See [RFC 0006].\n *\n * [RFC 0006]: https://github.com/paritytech/triangle-js-sdks/pull/94\n */\nexport type HostPaymentBalanceSubscribeError = \n/** User denied the balance disclosure request. */\n{\n tag: \"PermissionDenied\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostPaymentBalanceSubscribeError: Codec;\n/**\n * Current payment balance state pushed to subscribers.\n *\n * See [RFC 0006].\n *\n * [RFC 0006]: https://github.com/paritytech/triangle-js-sdks/pull/94\n */\nexport interface HostPaymentBalanceSubscribeItem {\n /** Balance that can be spent right now. */\n available: Balance;\n}\nexport const HostPaymentBalanceSubscribeItem: Codec;\n/** Request to subscribe to payment balance updates. */\nexport interface HostPaymentBalanceSubscribeRequest {\n /** Optional purse selector. `None` means MAIN_PURSE. */\n purse?: CoinPaymentPurseId;\n}\nexport const HostPaymentBalanceSubscribeRequest: Codec;\n/**\n * Error from [`crate::api::Payment::request`].\n *\n * See [RFC 0006].\n *\n * [RFC 0006]: https://github.com/paritytech/triangle-js-sdks/pull/94\n */\nexport type HostPaymentError = \n/** User rejected the payment request. */\n{\n tag: \"Rejected\";\n value?: undefined;\n}\n/** User's available balance is not sufficient for the requested amount. */\n | {\n tag: \"InsufficientBalance\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostPaymentError: Codec;\n/** Request to initiate a payment to another account. */\nexport interface HostPaymentRequest {\n /** Optional purse selector. `None` means MAIN_PURSE. */\n from?: CoinPaymentPurseId;\n /** Amount to pay. */\n amount: Balance;\n /** Destination account. */\n destination: HexString;\n}\nexport const HostPaymentRequest: Codec;\n/**\n * Receipt returned after a successful payment request.\n *\n * See [RFC 0006].\n *\n * [RFC 0006]: https://github.com/paritytech/triangle-js-sdks/pull/94\n */\nexport interface HostPaymentResponse {\n /** The assigned payment identifier. */\n id: string;\n}\nexport const HostPaymentResponse: Codec;\n/**\n * Error from [`crate::api::Payment::status_subscribe`].\n *\n * See [RFC 0006].\n *\n * [RFC 0006]: https://github.com/paritytech/triangle-js-sdks/pull/94\n */\nexport type HostPaymentStatusSubscribeError = \n/** Payment ID was not found or does not belong to the current product. */\n{\n tag: \"PaymentNotFound\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostPaymentStatusSubscribeError: Codec;\n/**\n * Payment lifecycle status pushed to subscribers.\n *\n * Once a terminal state (`Completed` or `Failed`) is reached, the host\n * delivers it and may close the subscription.\n *\n * See [RFC 0006].\n *\n * [RFC 0006]: https://github.com/paritytech/triangle-js-sdks/pull/94\n */\nexport type HostPaymentStatusSubscribeItem = \n/** Payment is being processed. */\n{\n tag: \"Processing\";\n value?: undefined;\n}\n/** Payment has been settled successfully. */\n | {\n tag: \"Completed\";\n value?: undefined;\n}\n/** Payment has failed. */\n | {\n tag: \"Failed\";\n value: {\n reason: string;\n };\n};\nexport const HostPaymentStatusSubscribeItem: Codec;\n/** Request to subscribe to a payment status. */\nexport interface HostPaymentStatusSubscribeRequest {\n /** Payment identifier to watch. */\n paymentId: string;\n}\nexport const HostPaymentStatusSubscribeRequest: Codec;\n/**\n * Error from [`crate::api::Payment::top_up`].\n *\n * See [RFC 0006].\n *\n * [RFC 0006]: https://github.com/paritytech/triangle-js-sdks/pull/94\n */\nexport type HostPaymentTopUpError = \n/** The source account does not hold sufficient funds. */\n{\n tag: \"InsufficientFunds\";\n value?: undefined;\n}\n/** The source account was not found or is invalid. */\n | {\n tag: \"InvalidSource\";\n value?: undefined;\n}\n/** Some coins were claimed but the total fell short of the requested amount. */\n | {\n tag: \"PartialPayment\";\n value: {\n credited: Balance;\n };\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostPaymentTopUpError: Codec;\n/** Request to top up the product payment balance. */\nexport interface HostPaymentTopUpRequest {\n /** Optional purse selector. `None` means MAIN_PURSE. */\n into?: CoinPaymentPurseId;\n /** Amount to top up. */\n amount: Balance;\n /** Funding source for the top-up. */\n source: PaymentTopUpSource;\n}\nexport const HostPaymentTopUpRequest: Codec;\n/** The calling product's cards: the whole set on subscribe and after every change. */\nexport interface HostPocketListSubscribeItem {\n /** Cards currently in Pocket for the calling product. */\n cards: Array;\n}\nexport const HostPocketListSubscribeItem: Codec;\n/** Card removal failure. */\nexport type HostPocketRemoveCardError = \n/** The card is privileged and stays in Pocket. */\n{\n tag: \"Privileged\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostPocketRemoveCardError: Codec;\n/** Request to remove one of the calling product's cards. */\nexport interface HostPocketRemoveCardRequest {\n /** Card to remove. A card that is not present is already removed. */\n cardId: string;\n}\nexport const HostPocketRemoveCardRequest: Codec;\n/** Profile disclosure failure. */\nexport type HostProfileDiscloseError = \n/** The reference is empty, too long, or not printable ASCII. */\n{\n tag: \"InvalidReference\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostProfileDiscloseError: Codec;\n/**\n * Request to give the user's chat contacts a profile reference.\n *\n * The reference is a bearer capability for everyone the host relays it to.\n * The host stores it as the user's own and never parses it.\n */\nexport interface HostProfileDiscloseRequest {\n /** Opaque profile reference, e.g. a Seity contacts reference. */\n reference: string;\n}\nexport const HostProfileDiscloseRequest: Codec;\n/** Contact profile presentation failure. */\nexport type HostProfilePresentContactError = \n/** This contact has not shared a profile with the user. */\n{\n tag: \"NotShared\";\n value?: undefined;\n}\n/** The host holds a reference it cannot parse. */\n | {\n tag: \"InvalidReference\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostProfilePresentContactError: Codec;\n/**\n * Request to show a chat contact's profile in host-owned UI.\n *\n * The product names the contact, never a reference: the host looks up the\n * reference that contact's host sent, so the product cannot read, keep or\n * substitute it.\n */\nexport interface HostProfilePresentContactRequest {\n /** The contact's authenticated root identity, as the chat API names it. */\n peerIdentity: HexString;\n}\nexport const HostProfilePresentContactRequest: Codec;\n/** Profile presentation failure. */\nexport type HostProfilePresentError = \n/** The reference is malformed or names a format this host cannot open. */\n{\n tag: \"InvalidReference\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostProfilePresentError: Codec;\n/**\n * Request to show a profile the calling product references in host-owned UI.\n *\n * The reference is a bearer capability: whoever holds it can read the profile\n * it names. The host resolves and renders it itself, so profile bytes, the\n * avatar image included, never reach the product.\n */\nexport interface HostProfilePresentRequest {\n /** Opaque profile reference, e.g. a Seity `#` blob reference. */\n reference: string;\n}\nexport const HostProfilePresentRequest: Codec;\n/** Profile retraction failure. */\nexport type HostProfileRetractError = \n/** Another product disclosed the reference the host holds. */\n{\n tag: \"NotDiscloser\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostProfileRetractError: Codec;\n/** Request to cancel a previously scheduled notification. */\nexport interface HostPushNotificationCancelRequest {\n /** The notification identifier returned by [`HostPushNotificationResponse`]. */\n id: NotificationId;\n}\nexport const HostPushNotificationCancelRequest: Codec;\n/** Push notification error. */\nexport type HostPushNotificationError = \n/** The host-wide queue of pending scheduled notifications is full. */\n{\n tag: \"ScheduleLimitReached\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostPushNotificationError: Codec;\n/**\n * Push notification payload.\n *\n * When `scheduled_at` is `Some`, the notification is deferred to the given\n * wall-clock instant (Unix milliseconds UTC). `None` fires immediately,\n * preserving prior behaviour. See [RFC 0019].\n *\n * [RFC 0019]: https://github.com/paritytech/host-rust-core/blob/main/docs/rfcs/0019-scheduled-notifications.md\n */\nexport interface HostPushNotificationRequest {\n /** Notification text. */\n text: string;\n /** Optional URL to open on tap. */\n deeplink?: string;\n /**\n * Optional Unix timestamp in milliseconds (UTC) at which the notification\n * should fire. `None` fires immediately.\n */\n scheduledAt?: bigint;\n}\nexport const HostPushNotificationRequest: Codec;\n/** Successful push notification response carrying the assigned id. */\nexport interface HostPushNotificationResponse {\n /** Host-assigned notification identifier. */\n id: NotificationId;\n}\nexport const HostPushNotificationResponse: Codec;\n/** An action triggered inside a product-rendered body. */\nexport interface HostRendererActionSubscribeItem {\n /** Where the body lives. */\n context: RenderContext;\n /** Which action was triggered, as named in the renderer tree. */\n actionId: string;\n /**\n * Data the node attached to the action. A `Button` press carries an\n * empty payload; a `TextField` value change carries the UTF-8 bytes of\n * the new value, with no length prefix.\n */\n payload: HexString;\n}\nexport const HostRendererActionSubscribeItem: Codec;\n/** Login request error. */\nexport type HostRequestLoginError = \n/** Catch-all. */\n{\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostRequestLoginError: Codec;\n/** Request to present the host login flow. */\nexport interface HostRequestLoginRequest {\n /** Optional human-readable reason shown in the login UI. */\n reason?: string;\n}\nexport const HostRequestLoginRequest: Codec;\n/** Result of a login request. */\nexport type HostRequestLoginResponse = \"Success\" | \"AlreadyConnected\" | \"Rejected\";\nexport const HostRequestLoginResponse: Codec;\n/** Batched resource pre-allocation request (RFC 0010). */\nexport interface HostRequestResourceAllocationRequest {\n /** Resources to allocate. */\n resources: Array;\n}\nexport const HostRequestResourceAllocationRequest: Codec;\n/** Per-resource outcomes for a batched allocation request (RFC 0010). */\nexport interface HostRequestResourceAllocationResponse {\n /** Per-resource allocation outcomes, in the same order as the request. */\n outcomes: Array;\n}\nexport const HostRequestResourceAllocationResponse: Codec;\n/** Signing operation error. */\nexport type HostSignPayloadError = \n/** Payload could not be deserialized. */\n{\n tag: \"FailedToDecode\";\n value?: undefined;\n}\n/** User rejected signing. */\n | {\n tag: \"Rejected\";\n value?: undefined;\n}\n/** Not authenticated. */\n | {\n tag: \"PermissionDenied\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostSignPayloadError: Codec;\n/** Request to sign an extrinsic payload with a product account. */\nexport interface HostSignPayloadRequest {\n /** Product account that will sign this payload. */\n account: ProductAccountId;\n /** The extrinsic payload to sign. */\n payload: HostSignPayloadData;\n}\nexport const HostSignPayloadRequest: Codec;\n/** Result of a signing operation. */\nexport interface HostSignPayloadResponse {\n /** The cryptographic signature. */\n signature: HexString;\n /** Full signed transaction, if requested. */\n signedTransaction?: HexString;\n}\nexport const HostSignPayloadResponse: Codec;\n/**\n * Sign a Substrate extrinsic payload with a non-product (legacy) account.\n * Contains the same fields as [`HostSignPayloadRequest`] minus `address`\n * (replaced by `signer`).\n */\nexport interface HostSignPayloadWithLegacyAccountRequest {\n /** Signer address (SS58 or hex) of the legacy account. */\n signer: string;\n /** The extrinsic payload to sign. */\n payload: HostSignPayloadData;\n}\nexport const HostSignPayloadWithLegacyAccountRequest: Codec;\n/** A raw signing request pairing an account with the payload to sign. */\nexport interface HostSignRawRequest {\n /** Product account that will sign this payload. */\n account: ProductAccountId;\n /** The payload to sign. */\n payload: RawPayload;\n}\nexport const HostSignRawRequest: Codec;\n/**\n * Sign raw bytes with a non-product (legacy) account. The signer field\n * identifies which legacy account to use.\n */\nexport interface HostSignRawWithLegacyAccountRequest {\n /** Signer address (SS58 or hex) of the legacy account. */\n signer: string;\n /** The data to sign. */\n payload: RawPayload;\n}\nexport const HostSignRawWithLegacyAccountRequest: Codec;\n/** Current theme state pushed to subscribers. */\nexport interface HostThemeSubscribeItem {\n /** Theme name. */\n name: ThemeName;\n /** Light or dark variant. */\n variant: ThemeVariant;\n}\nexport const HostThemeSubscribeItem: Codec;\n/** Request to begin a pending operation. */\nexport interface HostWorkerBeginOperationRequest {\n /** Optional label for host logs and UI. */\n label?: string;\n}\nexport const HostWorkerBeginOperationRequest: Codec;\n/** Response carrying the id of a newly begun operation. */\nexport interface HostWorkerBeginOperationResponse {\n /** Id to pass to `end_operation`. */\n id: OperationId;\n}\nexport const HostWorkerBeginOperationResponse: Codec;\n/** Request to end a pending operation. */\nexport interface HostWorkerEndOperationRequest {\n /** Id returned by `begin_operation`. */\n id: OperationId;\n}\nexport const HostWorkerEndOperationRequest: Codec;\n/** A body the host needs drawn. */\nexport interface ProductRendererRenderRequest {\n /** Where the body lives. */\n context: RenderContext;\n /** Product-defined payload, opaque to the host. */\n payload: HexString;\n}\nexport const ProductRendererRenderRequest: Codec;\n/** Request to fetch the body of a pinned block. */\nexport interface RemoteChainHeadBodyRequest {\n /** Chain genesis hash. */\n genesisHash: HexString;\n /** Follow subscription identifier. */\n followSubscriptionId: string;\n /** Block hash. */\n hash: HexString;\n}\nexport const RemoteChainHeadBodyRequest: Codec;\n/** Response to a body request; results arrive as follow events. */\nexport interface RemoteChainHeadBodyResponse {\n /** Started operation result. */\n operation: OperationStartedResult;\n}\nexport const RemoteChainHeadBodyResponse: Codec;\n/** Request to invoke a runtime call at a pinned block. */\nexport interface RemoteChainHeadCallRequest {\n /** Chain genesis hash. */\n genesisHash: HexString;\n /** Follow subscription identifier. */\n followSubscriptionId: string;\n /** Block hash. */\n hash: HexString;\n /** Runtime API function name. */\n function: string;\n /** SCALE-encoded call parameters. */\n callParameters: HexString;\n}\nexport const RemoteChainHeadCallRequest: Codec;\n/** Response to a runtime call request; the output arrives as a follow event. */\nexport interface RemoteChainHeadCallResponse {\n /** Started operation result. */\n operation: OperationStartedResult;\n}\nexport const RemoteChainHeadCallResponse: Codec;\n/** Request to continue a paused chain-head operation. */\nexport interface RemoteChainHeadContinueRequest {\n /** Chain genesis hash. */\n genesisHash: HexString;\n /** Follow subscription identifier. */\n followSubscriptionId: string;\n /** Operation identifier. */\n operationId: string;\n}\nexport const RemoteChainHeadContinueRequest: Codec;\n/** Event emitted on a chain-head follow subscription. */\nexport type RemoteChainHeadFollowItem = \n/** First event of the subscription, describing the current finalized blocks. */\n{\n tag: \"Initialized\";\n value: {\n finalizedBlockHashes: Array;\n finalizedBlockRuntime?: RuntimeType;\n };\n}\n/** A new non-finalized block was announced. */\n | {\n tag: \"NewBlock\";\n value: {\n blockHash: HexString;\n parentBlockHash: HexString;\n newRuntime?: RuntimeType;\n };\n}\n/** The best block has changed. */\n | {\n tag: \"BestBlockChanged\";\n value: {\n bestBlockHash: HexString;\n };\n}\n/** One or more blocks were finalized. */\n | {\n tag: \"Finalized\";\n value: {\n finalizedBlockHashes: Array;\n prunedBlockHashes: Array;\n };\n}\n/** A body operation completed. */\n | {\n tag: \"OperationBodyDone\";\n value: {\n operationId: string;\n value: Array;\n };\n}\n/** A runtime call operation completed. */\n | {\n tag: \"OperationCallDone\";\n value: {\n operationId: string;\n output: HexString;\n };\n}\n/** A storage operation produced a batch of results. */\n | {\n tag: \"OperationStorageItems\";\n value: {\n operationId: string;\n items: Array;\n };\n}\n/** A storage operation finished emitting results. */\n | {\n tag: \"OperationStorageDone\";\n value: {\n operationId: string;\n };\n}\n/** A storage operation is paused until the product requests continuation. */\n | {\n tag: \"OperationWaitingForContinue\";\n value: {\n operationId: string;\n };\n}\n/** The operation failed because the required data was not accessible; it can be retried. */\n | {\n tag: \"OperationInaccessible\";\n value: {\n operationId: string;\n };\n}\n/** The operation failed with an error. */\n | {\n tag: \"OperationError\";\n value: {\n operationId: string;\n error: string;\n };\n}\n/** The subscription was stopped by the host and is no longer valid. */\n | {\n tag: \"Stop\";\n value?: undefined;\n};\nexport const RemoteChainHeadFollowItem: Codec;\n/** Request to start a chain-head follow subscription. */\nexport interface RemoteChainHeadFollowRequest {\n /** Chain genesis hash. */\n genesisHash: HexString;\n /** Whether to include runtime information in events. */\n withRuntime: boolean;\n}\nexport const RemoteChainHeadFollowRequest: Codec;\n/** Request to fetch the header of a pinned block. */\nexport interface RemoteChainHeadHeaderRequest {\n /** Chain genesis hash. */\n genesisHash: HexString;\n /** Follow subscription identifier. */\n followSubscriptionId: string;\n /** Block hash. */\n hash: HexString;\n}\nexport const RemoteChainHeadHeaderRequest: Codec;\n/** Response containing the requested block header. */\nexport interface RemoteChainHeadHeaderResponse {\n /** SCALE-encoded block header. */\n header?: HexString;\n}\nexport const RemoteChainHeadHeaderResponse: Codec;\n/** Request to stop an in-progress chain-head operation. */\nexport interface RemoteChainHeadStopOperationRequest {\n /** Chain genesis hash. */\n genesisHash: HexString;\n /** Follow subscription identifier. */\n followSubscriptionId: string;\n /** Operation identifier. */\n operationId: string;\n}\nexport const RemoteChainHeadStopOperationRequest: Codec;\n/** Request to query storage at a pinned block. */\nexport interface RemoteChainHeadStorageRequest {\n /** Chain genesis hash. */\n genesisHash: HexString;\n /** Follow subscription identifier. */\n followSubscriptionId: string;\n /** Block hash. */\n hash: HexString;\n /** Storage items to query. */\n items: Array;\n /** Optional child trie. */\n childTrie?: HexString;\n}\nexport const RemoteChainHeadStorageRequest: Codec;\n/** Response to a storage request; results arrive as follow events. */\nexport interface RemoteChainHeadStorageResponse {\n /** Started operation result. */\n operation: OperationStartedResult;\n}\nexport const RemoteChainHeadStorageResponse: Codec;\n/** Request to release pinned blocks. */\nexport interface RemoteChainHeadUnpinRequest {\n /** Chain genesis hash. */\n genesisHash: HexString;\n /** Follow subscription identifier. */\n followSubscriptionId: string;\n /** Block hashes to unpin. */\n hashes: Array;\n}\nexport const RemoteChainHeadUnpinRequest: Codec;\n/** Error from [`crate::api::Chain::get_chain_info`]. */\nexport type RemoteChainInfoError = \n/** The host does not serve the requested chain. */\n{\n tag: \"NotSupported\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: GenericError;\n};\nexport const RemoteChainInfoError: Codec;\n/** Request to resolve one chain identifier against the host's environment. */\nexport interface RemoteChainInfoRequest {\n /** Chain to resolve. */\n chain: ChainIdentifier;\n}\nexport const RemoteChainInfoRequest: Codec;\n/** Response carrying the resolved chain data. */\nexport interface RemoteChainInfoResponse {\n /** Ecosystem the host is configured for, e.g. \"polkadot\", \"kusama\", \"paseo\". */\n network: string;\n /** Chain this response resolves, echoed from the request. */\n chain: ChainIdentifier;\n /** Genesis hash identifying the chain in all chain-scoped calls. */\n genesisHash: HexString;\n}\nexport const RemoteChainInfoResponse: Codec;\n/** Request for the display name of a chain. */\nexport interface RemoteChainSpecChainNameRequest {\n /** Chain genesis hash. */\n genesisHash: HexString;\n}\nexport const RemoteChainSpecChainNameRequest: Codec;\n/** Response containing the chain display name. */\nexport interface RemoteChainSpecChainNameResponse {\n /** Chain display name. */\n chainName: string;\n}\nexport const RemoteChainSpecChainNameResponse: Codec;\n/** Request for the canonical genesis hash of a chain. */\nexport interface RemoteChainSpecGenesisHashRequest {\n /** Chain genesis hash requested by the product. */\n genesisHash: HexString;\n}\nexport const RemoteChainSpecGenesisHashRequest: Codec;\n/** Response containing the canonical genesis hash. */\nexport interface RemoteChainSpecGenesisHashResponse {\n /** Chain genesis hash. */\n genesisHash: HexString;\n}\nexport const RemoteChainSpecGenesisHashResponse: Codec;\n/** Request for the JSON-encoded properties of a chain. */\nexport interface RemoteChainSpecPropertiesRequest {\n /** Chain genesis hash. */\n genesisHash: HexString;\n}\nexport const RemoteChainSpecPropertiesRequest: Codec;\n/** Response containing the chain properties. */\nexport interface RemoteChainSpecPropertiesResponse {\n /** JSON-encoded properties. */\n properties: string;\n}\nexport const RemoteChainSpecPropertiesResponse: Codec;\n/** Request to broadcast a signed transaction. */\nexport interface RemoteChainTransactionBroadcastRequest {\n /** Chain genesis hash. */\n genesisHash: HexString;\n /** Signed transaction bytes. */\n transaction: HexString;\n}\nexport const RemoteChainTransactionBroadcastRequest: Codec;\n/** Response to a transaction broadcast request. */\nexport interface RemoteChainTransactionBroadcastResponse {\n /** Broadcast operation identifier, if available. */\n operationId?: string;\n}\nexport const RemoteChainTransactionBroadcastResponse: Codec;\n/** Request to stop broadcasting a transaction. */\nexport interface RemoteChainTransactionStopRequest {\n /** Chain genesis hash. */\n genesisHash: HexString;\n /** Operation identifier of the broadcast to stop. */\n operationId: string;\n}\nexport const RemoteChainTransactionStopRequest: Codec;\n/** remote-permission request (RFC 0002). */\nexport interface RemotePermissionRequest {\n /** Permission requested by the product. */\n permission: RemotePermission;\n}\nexport const RemotePermissionRequest: Codec;\n/** Outcome of a remote-permission request. */\nexport interface RemotePermissionResponse {\n /** Whether the permission was granted. */\n granted: boolean;\n}\nexport const RemotePermissionResponse: Codec;\n/** Item containing an optional preimage lookup result. */\nexport interface RemotePreimageLookupSubscribeItem {\n /** Preimage data, if found. */\n value?: HexString;\n}\nexport const RemotePreimageLookupSubscribeItem: Codec;\n/** Request to subscribe to preimage lookup results. */\nexport interface RemotePreimageLookupSubscribeRequest {\n /** Hash of the preimage. */\n key: HexString;\n}\nexport const RemotePreimageLookupSubscribeRequest: Codec;\n/** Statement proof creation error. */\nexport type RemoteStatementStoreCreateProofError = \n/** Signing operation failed. */\n{\n tag: \"UnableToSign\";\n value?: undefined;\n}\n/** Account not recognized. */\n | {\n tag: \"UnknownAccount\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const RemoteStatementStoreCreateProofError: Codec;\n/** Request to create a cryptographic proof for a statement. */\nexport interface RemoteStatementStoreCreateProofRequest {\n /** Product account that should create the proof. */\n productAccountId: ProductAccountId;\n /** Statement to prove. */\n statement: Statement;\n}\nexport const RemoteStatementStoreCreateProofRequest: Codec;\n/** Response containing a statement proof. */\nexport interface RemoteStatementStoreCreateProofResponse {\n /** Created statement proof. */\n proof: StatementProof;\n}\nexport const RemoteStatementStoreCreateProofResponse: Codec;\n/**\n * Page of signed statements delivered by the statement store subscription\n * (RFC 0008). The `is_complete` flag distinguishes the historical-dump phase\n * (`false`) from the live-update phase (`true`).\n */\nexport interface RemoteStatementStoreSubscribeItem {\n /** Signed statements matching the subscription. */\n statements: Array;\n /**\n * `false` while the host is still streaming the historical dump (more\n * pages to follow). `true` once the dump is complete; all subsequent\n * pages are also `true` and carry only newly-arrived statements.\n */\n isComplete: boolean;\n}\nexport const RemoteStatementStoreSubscribeItem: Codec;\n/** Request to subscribe to statements via a topic filter (RFC 0008). */\nexport type RemoteStatementStoreSubscribeRequest = \n/** AND: statement must contain every listed topic. */\n{\n tag: \"MatchAll\";\n value: Array;\n}\n/** OR: statement must contain at least one listed topic. */\n | {\n tag: \"MatchAny\";\n value: Array;\n};\nexport const RemoteStatementStoreSubscribeRequest: Codec;\n/** Local storage read failure. */\nexport type HostLocalStorageReadError = \n/** Storage quota exceeded. */\n{\n tag: \"Full\";\n value?: undefined;\n}\n/**\n * The addressed storage belongs to another product that has not granted\n * this caller the `storage` scope.\n *\n * One variant answers every reason: the product does not resolve, it\n * published no manifest, or its manifest grants this caller nothing.\n * Distinguishing them would make the call a probe for which products exist\n * and which hold data.\n */\n | {\n tag: \"AccessNotGranted\";\n value?: undefined;\n}\n/** Catch-all. */\n | {\n tag: \"Unknown\";\n value: {\n reason: string;\n };\n};\nexport const HostLocalStorageReadError: Codec;\n/**\n * Request to read a local storage value.\n *\n * Storage is private by default: `product: None` addresses the caller's own\n * storage, which is what every v0.1 read resolved to. Naming another product\n * reads that product's storage instead, and succeeds only if that product's\n * manifest grants this caller the `storage` scope.\n */\nexport interface HostLocalStorageReadRequest {\n /**\n * Product whose storage is read. `None`, or the caller's own id, means the\n * caller, and consults no grant.\n */\n product?: string;\n /** Storage key to read. */\n key: string;\n}\nexport const HostLocalStorageReadRequest: Codec;\n/** Failure of a Host-owned Chat operation before a public update is available. */\nexport type HostProductDeviceChatError = \"NotConnected\" | \"AccessNotGranted\" | \"UserRejected\" | \"AllowanceRequired\" | \"PeerNotReady\" | \"OperationConflict\" | \"InvalidRequest\" | \"InvalidStatement\" | \"RecipientNotFound\" | \"InsufficientBalance\" | \"StorageUnavailable\" | \"NetworkUnavailable\" | \"OperationNotFound\" | \"AttachmentsUnavailable\";\nexport const HostProductDeviceChatError: Codec;\n/** An operation on the calling product's Host-owned native Chat device. */\nexport type V02HostProductDeviceChatRequest = \n/** Restore the installation's public device and durable conversation state. */\n{\n tag: \"Initialize\";\n value?: undefined;\n}\n/** Resolve a username in the configured network and send a fresh invitation. */\n | {\n tag: \"Invite\";\n value: {\n username: string;\n text: string;\n };\n}\n/** Authenticate, decrypt and durably process a native statement. */\n | {\n tag: \"Receive\";\n value: {\n statement: SignedStatement;\n };\n}\n/** Accept an invitation previously authenticated and retained by the Host. */\n | {\n tag: \"AcceptInvitation\";\n value: {\n invitationId: HexString;\n };\n}\n/** Reject an invitation previously authenticated and retained by the Host. */\n | {\n tag: \"RejectInvitation\";\n value: {\n invitationId: HexString;\n };\n}\n/** Send ordinary messages to an established, Host-authenticated peer roster. */\n | {\n tag: \"Send\";\n value: {\n peerIdentity: HexString;\n requestId: string;\n messages: Array;\n };\n}\n/** Propose one main-purse payment; this operation always requires Host review. */\n | {\n tag: \"SendPayment\";\n value: {\n peerIdentity: HexString;\n requestId: string;\n amountCents: bigint;\n };\n}\n/** Read a payment's durable status without authorizing another spend. */\n | {\n tag: \"PaymentStatus\";\n value: {\n operationId: HexString;\n };\n}\n/** Resume durable transport work and return newly available public views. */\n | {\n tag: \"Reconcile\";\n value?: undefined;\n}\n/** Select immutable files in trusted Host UI and send native rich content. */\n | {\n tag: \"SendAttachments\";\n value: {\n peerIdentity: HexString;\n requestId: string;\n text?: string;\n };\n}\n/** Resume a private download and present or export through trusted Host UI. */\n | {\n tag: \"OpenAttachment\";\n value: {\n attachmentId: HexString;\n };\n};\nexport const V02HostProductDeviceChatRequest: Codec;\n/** Public updates from a Host-owned Chat operation. */\nexport interface V02HostProductDeviceChatResponse {\n /** Public local device metadata, including its allowance account. */\n device: HostNativeChatDevice;\n /** Current authenticated peers and subscription channels. */\n peers: Array;\n /** Invitations still awaiting a user decision. */\n invitations: Array;\n /** Newly processed safe ordinary messages. */\n messages: Array;\n /** Newly processed native delivery acknowledgments. */\n acknowledgments: Array;\n /** Current public payment statuses belonging to the calling product. */\n payments: Array;\n /** Safe rich-content views and their current private-transfer progress. */\n richMessages: Array;\n}\nexport const V02HostProductDeviceChatResponse: Codec;\n/** An operation using the calling product's non-exportable Host Chat device. */\nexport type HostProductDeviceChatRequest = \n/** Restore public metadata, pending ciphertext, and private file-transfer progress. */\n{\n tag: \"Initialize\";\n value?: undefined;\n}\n/** Independently resolve and bind a peer on the trusted network. */\n | {\n tag: \"Bind\";\n value: {\n username: string;\n };\n}\n/** Validate native plaintext and return signed ciphertext for product delivery. */\n | {\n tag: \"Prepare\";\n value: {\n peerIdentity: HexString;\n route: HostNativeChatRoute;\n plaintext: HexString;\n };\n}\n/** Authenticate and decrypt a complete external native statement, never own output. */\n | {\n tag: \"Open\";\n value: {\n statement: SignedStatement;\n };\n}\n/** Propose one main-purse payment; this operation requires trusted Host review. */\n | {\n tag: \"SendPayment\";\n value: {\n peerIdentity: HexString;\n requestId: string;\n amountCents: bigint;\n };\n}\n/** Read durable payment status without authorizing another spend. */\n | {\n tag: \"PaymentStatus\";\n value: {\n operationId: HexString;\n };\n}\n/** Reconcile payment custody and return opaque statements for product delivery. */\n | {\n tag: \"ReconcilePayments\";\n value?: undefined;\n}\n/** Select files in trusted Host UI and prepare native rich content without delivery. */\n | {\n tag: \"PrepareAttachments\";\n value: {\n peerIdentity: HexString;\n requestId: string;\n text?: string;\n };\n}\n/** Resume a private download and present or export through trusted Host UI. */\n | {\n tag: \"OpenAttachment\";\n value: {\n attachmentId: HexString;\n };\n}\n/** Acknowledge durable product storage of the legacy view and ordinary ciphertext. */\n | {\n tag: \"CommitMigration\";\n value: {\n migrationId: HexString;\n };\n}\n/** Continue a Host-authenticated incoming batch without supplying new ciphertext. */\n | {\n tag: \"ContinueOpen\";\n value: {\n openId: HexString;\n cursor: number;\n };\n}\n/** Continue a bounded snapshot of custody metadata and pending prepared statements. */\n | {\n tag: \"ContinueState\";\n value: {\n stateId: HexString;\n cursor: number;\n };\n}\n/** Read configured raw chain units per native Coinage cent, without spending. */\n | {\n tag: \"PaymentDenomination\";\n value?: undefined;\n};\nexport const HostProductDeviceChatRequest: Codec;\n/** Cryptographic results and custody metadata; products drive delivery and import. */\nexport interface HostProductDeviceChatResponse {\n /** Public local device metadata, including its allowance account. */\n device: HostNativeChatDevice;\n /** Host-authenticated peer and device metadata. */\n peers: Array;\n /** Newly resolved peer binding, when requested. */\n binding?: HostNativeChatBinding;\n /** Authenticated incoming plaintext; incoming payment import is product-owned. */\n opened: Array;\n /** Signed ciphertext for product submission and exact-identity retries. */\n prepared: Array;\n /** Durable public payment status, never outgoing bearer secrets. */\n payments: Array;\n /** Rich-content metadata and trusted private-transfer progress. */\n richMessages: Array;\n /** Legacy public view retained until the product durably commits migration. */\n migration?: V02HostProductDeviceChatResponse;\n /** Snapshot identifier to acknowledge only after persisting its view and ciphertext. */\n migrationId?: HexString;\n /** Continuation of an authenticated incoming batch, when opening is paginated. */\n openPage?: HostNativeChatOpenPage;\n /** Native request identities for invitations in the legacy migration view. */\n migrationInvitations: Array;\n /** Continuation of a bounded public state snapshot, when metadata is paginated. */\n statePage?: HostNativeChatStatePage;\n /**\n * Configured raw chain units per native Coinage cent, only when requested.\n * This is positive denomination metadata, never a balance or fiat price.\n */\n coinageCentsUnit?: bigint;\n}\nexport const HostProductDeviceChatResponse: Codec;\n/** Cross-axis alignment of `Row` children. */\nexport type VerticalAlignment = \"Top\" | \"Center\" | \"Bottom\";\nexport const VerticalAlignment: Codec;\n/** An sr25519 (schnorrkel) VRF signature: the VRF pre-output and its proof. */\nexport interface VrfSignature {\n /** schnorrkel `VRFPreOut` \u2014 the 32-byte VRF output point. */\n preOutput: HexString;\n /** schnorrkel `VRFProof` \u2014 the 64-byte DLEQ proof. */\n proof: HexString;\n}\nexport const VrfSignature: Codec;\n/** One `append_message` call replayed against the signing transcript. */\nexport interface VrfTranscriptItem {\n /** Merlin `append_message` label. */\n label: HexString;\n /** Merlin `append_message` value. */\n value: HexString;\n}\nexport const VrfTranscriptItem: Codec;\n\n}\n\n\n// re-export namespace T at module top level (mirrors index.d.ts `export *`)\n\nexport import AccountId = T.AccountId;\nexport import ActionTrigger = T.ActionTrigger;\nexport import AllocatableResource = T.AllocatableResource;\nexport import AllocationOutcome = T.AllocationOutcome;\nexport import Arrangement = T.Arrangement;\nexport import Background = T.Background;\nexport import Balance = T.Balance;\nexport import BlendingMode = T.BlendingMode;\nexport import BorderStyle = T.BorderStyle;\nexport import BoxProps = T.BoxProps;\nexport import ButtonProps = T.ButtonProps;\nexport import ButtonVariant = T.ButtonVariant;\nexport import Bytes32 = T.Bytes32;\nexport import ChainIdentifier = T.ChainIdentifier;\nexport import ChatAction = T.ChatAction;\nexport import ChatActionLayout = T.ChatActionLayout;\nexport import ChatActionPayload = T.ChatActionPayload;\nexport import ChatActions = T.ChatActions;\nexport import ChatBotRegistrationStatus = T.ChatBotRegistrationStatus;\nexport import ChatCommand = T.ChatCommand;\nexport import ChatCustomMessage = T.ChatCustomMessage;\nexport import ChatFile = T.ChatFile;\nexport import ChatMedia = T.ChatMedia;\nexport import ChatMessageContent = T.ChatMessageContent;\nexport import ChatReaction = T.ChatReaction;\nexport import ChatRichText = T.ChatRichText;\nexport import ChatRoom = T.ChatRoom;\nexport import ChatRoomParticipation = T.ChatRoomParticipation;\nexport import ChatRoomRegistrationStatus = T.ChatRoomRegistrationStatus;\nexport import CoinPaymentBalance = T.CoinPaymentBalance;\nexport import CoinPaymentCheque = T.CoinPaymentCheque;\nexport import CoinPaymentClearingReference = T.CoinPaymentClearingReference;\nexport import CoinPaymentCoinagePubKey = T.CoinPaymentCoinagePubKey;\nexport import CoinPaymentError = T.CoinPaymentError;\nexport import CoinPaymentMerkleRoot = T.CoinPaymentMerkleRoot;\nexport import CoinPaymentProductId = T.CoinPaymentProductId;\nexport import CoinPaymentPurseId = T.CoinPaymentPurseId;\nexport import CoinPaymentPurseInfo = T.CoinPaymentPurseInfo;\nexport import CoinPaymentReceivable = T.CoinPaymentReceivable;\nexport import CoinPaymentStatus = T.CoinPaymentStatus;\nexport import CoinPaymentTimestamp = T.CoinPaymentTimestamp;\nexport import CoinPaymentTransactionHash = T.CoinPaymentTransactionHash;\nexport import CoinPaymentTransmissionChannel = T.CoinPaymentTransmissionChannel;\nexport import ColorToken = T.ColorToken;\nexport import ColumnProps = T.ColumnProps;\nexport import ContentAlignment = T.ContentAlignment;\nexport import ContextualAlias = T.ContextualAlias;\nexport import DerivationIndex = T.DerivationIndex;\nexport import Dimensions = T.Dimensions;\nexport import Effect = T.Effect;\nexport import EffectProps = T.EffectProps;\nexport import GenericError = T.GenericError;\nexport import GenesisHash = T.GenesisHash;\nexport import HorizontalAlignment = T.HorizontalAlignment;\nexport import VersionedHostAccountConnectionStatusSubscribeError = T.VersionedHostAccountConnectionStatusSubscribeError;\nexport import VersionedHostAccountConnectionStatusSubscribeItem = T.VersionedHostAccountConnectionStatusSubscribeItem;\nexport import VersionedHostAccountConnectionStatusSubscribeRequest = T.VersionedHostAccountConnectionStatusSubscribeRequest;\nexport import VersionedHostAccountCreateProofError = T.VersionedHostAccountCreateProofError;\nexport import VersionedHostAccountCreateProofRequest = T.VersionedHostAccountCreateProofRequest;\nexport import VersionedHostAccountCreateProofResponse = T.VersionedHostAccountCreateProofResponse;\nexport import VersionedHostAccountGetAliasError = T.VersionedHostAccountGetAliasError;\nexport import VersionedHostAccountGetAliasRequest = T.VersionedHostAccountGetAliasRequest;\nexport import VersionedHostAccountGetAliasResponse = T.VersionedHostAccountGetAliasResponse;\nexport import VersionedHostAccountGetError = T.VersionedHostAccountGetError;\nexport import VersionedHostAccountGetRequest = T.VersionedHostAccountGetRequest;\nexport import VersionedHostAccountGetResponse = T.VersionedHostAccountGetResponse;\nexport import VersionedHostAccountListRingVrfKeysError = T.VersionedHostAccountListRingVrfKeysError;\nexport import VersionedHostAccountListRingVrfKeysRequest = T.VersionedHostAccountListRingVrfKeysRequest;\nexport import VersionedHostAccountListRingVrfKeysResponse = T.VersionedHostAccountListRingVrfKeysResponse;\nexport import VersionedHostAccountRegisterRingVrfKeyError = T.VersionedHostAccountRegisterRingVrfKeyError;\nexport import VersionedHostAccountRegisterRingVrfKeyRequest = T.VersionedHostAccountRegisterRingVrfKeyRequest;\nexport import VersionedHostAccountRegisterRingVrfKeyResponse = T.VersionedHostAccountRegisterRingVrfKeyResponse;\nexport import VersionedHostAccountRingVrfSignError = T.VersionedHostAccountRingVrfSignError;\nexport import VersionedHostAccountRingVrfSignRequest = T.VersionedHostAccountRingVrfSignRequest;\nexport import VersionedHostAccountRingVrfSignResponse = T.VersionedHostAccountRingVrfSignResponse;\nexport import VersionedHostAccountSignVrfError = T.VersionedHostAccountSignVrfError;\nexport import VersionedHostAccountSignVrfRequest = T.VersionedHostAccountSignVrfRequest;\nexport import VersionedHostAccountSignVrfResponse = T.VersionedHostAccountSignVrfResponse;\nexport import VersionedHostChatActionSubscribeError = T.VersionedHostChatActionSubscribeError;\nexport import VersionedHostChatActionSubscribeItem = T.VersionedHostChatActionSubscribeItem;\nexport import VersionedHostChatActionSubscribeRequest = T.VersionedHostChatActionSubscribeRequest;\nexport import VersionedHostChatCreateRoomError = T.VersionedHostChatCreateRoomError;\nexport import VersionedHostChatCreateRoomRequest = T.VersionedHostChatCreateRoomRequest;\nexport import VersionedHostChatCreateRoomResponse = T.VersionedHostChatCreateRoomResponse;\nexport import VersionedHostChatListSubscribeError = T.VersionedHostChatListSubscribeError;\nexport import VersionedHostChatListSubscribeItem = T.VersionedHostChatListSubscribeItem;\nexport import VersionedHostChatListSubscribeRequest = T.VersionedHostChatListSubscribeRequest;\nexport import VersionedHostChatPostMessageError = T.VersionedHostChatPostMessageError;\nexport import VersionedHostChatPostMessageRequest = T.VersionedHostChatPostMessageRequest;\nexport import VersionedHostChatPostMessageResponse = T.VersionedHostChatPostMessageResponse;\nexport import VersionedHostChatRegisterBotError = T.VersionedHostChatRegisterBotError;\nexport import VersionedHostChatRegisterBotRequest = T.VersionedHostChatRegisterBotRequest;\nexport import VersionedHostChatRegisterBotResponse = T.VersionedHostChatRegisterBotResponse;\nexport import VersionedHostCoinPaymentCreateChequeError = T.VersionedHostCoinPaymentCreateChequeError;\nexport import VersionedHostCoinPaymentCreateChequeRequest = T.VersionedHostCoinPaymentCreateChequeRequest;\nexport import VersionedHostCoinPaymentCreateChequeResponse = T.VersionedHostCoinPaymentCreateChequeResponse;\nexport import VersionedHostCoinPaymentCreatePurseError = T.VersionedHostCoinPaymentCreatePurseError;\nexport import VersionedHostCoinPaymentCreatePurseRequest = T.VersionedHostCoinPaymentCreatePurseRequest;\nexport import VersionedHostCoinPaymentCreatePurseResponse = T.VersionedHostCoinPaymentCreatePurseResponse;\nexport import VersionedHostCoinPaymentCreateReceivableError = T.VersionedHostCoinPaymentCreateReceivableError;\nexport import VersionedHostCoinPaymentCreateReceivableRequest = T.VersionedHostCoinPaymentCreateReceivableRequest;\nexport import VersionedHostCoinPaymentCreateReceivableResponse = T.VersionedHostCoinPaymentCreateReceivableResponse;\nexport import VersionedHostCoinPaymentDeletePurseError = T.VersionedHostCoinPaymentDeletePurseError;\nexport import VersionedHostCoinPaymentDeletePurseItem = T.VersionedHostCoinPaymentDeletePurseItem;\nexport import VersionedHostCoinPaymentDeletePurseRequest = T.VersionedHostCoinPaymentDeletePurseRequest;\nexport import VersionedHostCoinPaymentDepositError = T.VersionedHostCoinPaymentDepositError;\nexport import VersionedHostCoinPaymentDepositItem = T.VersionedHostCoinPaymentDepositItem;\nexport import VersionedHostCoinPaymentDepositRequest = T.VersionedHostCoinPaymentDepositRequest;\nexport import VersionedHostCoinPaymentListenForError = T.VersionedHostCoinPaymentListenForError;\nexport import VersionedHostCoinPaymentListenForItem = T.VersionedHostCoinPaymentListenForItem;\nexport import VersionedHostCoinPaymentListenForRequest = T.VersionedHostCoinPaymentListenForRequest;\nexport import VersionedHostCoinPaymentQueryPurseError = T.VersionedHostCoinPaymentQueryPurseError;\nexport import VersionedHostCoinPaymentQueryPurseRequest = T.VersionedHostCoinPaymentQueryPurseRequest;\nexport import VersionedHostCoinPaymentQueryPurseResponse = T.VersionedHostCoinPaymentQueryPurseResponse;\nexport import VersionedHostCoinPaymentRebalancePurseError = T.VersionedHostCoinPaymentRebalancePurseError;\nexport import VersionedHostCoinPaymentRebalancePurseItem = T.VersionedHostCoinPaymentRebalancePurseItem;\nexport import VersionedHostCoinPaymentRebalancePurseRequest = T.VersionedHostCoinPaymentRebalancePurseRequest;\nexport import VersionedHostCoinPaymentRefundError = T.VersionedHostCoinPaymentRefundError;\nexport import VersionedHostCoinPaymentRefundItem = T.VersionedHostCoinPaymentRefundItem;\nexport import VersionedHostCoinPaymentRefundRequest = T.VersionedHostCoinPaymentRefundRequest;\nexport import VersionedHostCreateTransactionError = T.VersionedHostCreateTransactionError;\nexport import VersionedHostCreateTransactionRequest = T.VersionedHostCreateTransactionRequest;\nexport import VersionedHostCreateTransactionResponse = T.VersionedHostCreateTransactionResponse;\nexport import VersionedHostCreateTransactionWithLegacyAccountError = T.VersionedHostCreateTransactionWithLegacyAccountError;\nexport import VersionedHostCreateTransactionWithLegacyAccountRequest = T.VersionedHostCreateTransactionWithLegacyAccountRequest;\nexport import VersionedHostCreateTransactionWithLegacyAccountResponse = T.VersionedHostCreateTransactionWithLegacyAccountResponse;\nexport import VersionedHostDeriveEntropyError = T.VersionedHostDeriveEntropyError;\nexport import VersionedHostDeriveEntropyRequest = T.VersionedHostDeriveEntropyRequest;\nexport import VersionedHostDeriveEntropyResponse = T.VersionedHostDeriveEntropyResponse;\nexport import VersionedHostDevicePermissionError = T.VersionedHostDevicePermissionError;\nexport import VersionedHostDevicePermissionRequest = T.VersionedHostDevicePermissionRequest;\nexport import VersionedHostDevicePermissionResponse = T.VersionedHostDevicePermissionResponse;\nexport import VersionedHostFeatureSupportedError = T.VersionedHostFeatureSupportedError;\nexport import VersionedHostFeatureSupportedRequest = T.VersionedHostFeatureSupportedRequest;\nexport import VersionedHostFeatureSupportedResponse = T.VersionedHostFeatureSupportedResponse;\nexport import VersionedHostGetLegacyAccountsError = T.VersionedHostGetLegacyAccountsError;\nexport import VersionedHostGetLegacyAccountsRequest = T.VersionedHostGetLegacyAccountsRequest;\nexport import VersionedHostGetLegacyAccountsResponse = T.VersionedHostGetLegacyAccountsResponse;\nexport import VersionedHostGetProductContextError = T.VersionedHostGetProductContextError;\nexport import VersionedHostGetProductContextRequest = T.VersionedHostGetProductContextRequest;\nexport import VersionedHostGetProductContextResponse = T.VersionedHostGetProductContextResponse;\nexport import VersionedHostGetUserIdError = T.VersionedHostGetUserIdError;\nexport import VersionedHostGetUserIdRequest = T.VersionedHostGetUserIdRequest;\nexport import VersionedHostGetUserIdResponse = T.VersionedHostGetUserIdResponse;\nexport import VersionedHostHandshakeError = T.VersionedHostHandshakeError;\nexport import VersionedHostHandshakeRequest = T.VersionedHostHandshakeRequest;\nexport import VersionedHostHandshakeResponse = T.VersionedHostHandshakeResponse;\nexport import HostInfo = T.HostInfo;\nexport import VersionedHostInfoError = T.VersionedHostInfoError;\nexport import VersionedHostInfoRequest = T.VersionedHostInfoRequest;\nexport import VersionedHostInfoResponse = T.VersionedHostInfoResponse;\nexport import VersionedHostLocalStorageChangeItem = T.VersionedHostLocalStorageChangeItem;\nexport import VersionedHostLocalStorageClearError = T.VersionedHostLocalStorageClearError;\nexport import VersionedHostLocalStorageClearRequest = T.VersionedHostLocalStorageClearRequest;\nexport import VersionedHostLocalStorageClearResponse = T.VersionedHostLocalStorageClearResponse;\nexport import VersionedHostLocalStorageReadError = T.VersionedHostLocalStorageReadError;\nexport import VersionedHostLocalStorageReadRequest = T.VersionedHostLocalStorageReadRequest;\nexport import VersionedHostLocalStorageReadResponse = T.VersionedHostLocalStorageReadResponse;\nexport import VersionedHostLocalStorageSubscribeError = T.VersionedHostLocalStorageSubscribeError;\nexport import VersionedHostLocalStorageSubscribeRequest = T.VersionedHostLocalStorageSubscribeRequest;\nexport import VersionedHostLocalStorageWriteError = T.VersionedHostLocalStorageWriteError;\nexport import VersionedHostLocalStorageWriteRequest = T.VersionedHostLocalStorageWriteRequest;\nexport import VersionedHostLocalStorageWriteResponse = T.VersionedHostLocalStorageWriteResponse;\nexport import VersionedHostLocaleSubscribeError = T.VersionedHostLocaleSubscribeError;\nexport import VersionedHostLocaleSubscribeItem = T.VersionedHostLocaleSubscribeItem;\nexport import VersionedHostLocaleSubscribeRequest = T.VersionedHostLocaleSubscribeRequest;\nexport import HostNativeChatAcknowledgment = T.HostNativeChatAcknowledgment;\nexport import HostNativeChatAttachment = T.HostNativeChatAttachment;\nexport import HostNativeChatAttachmentKind = T.HostNativeChatAttachmentKind;\nexport import HostNativeChatAttachmentMetadata = T.HostNativeChatAttachmentMetadata;\nexport import HostNativeChatAttachmentState = T.HostNativeChatAttachmentState;\nexport import HostNativeChatBinding = T.HostNativeChatBinding;\nexport import HostNativeChatDevice = T.HostNativeChatDevice;\nexport import HostNativeChatInvitation = T.HostNativeChatInvitation;\nexport import HostNativeChatMessages = T.HostNativeChatMessages;\nexport import HostNativeChatMigrationInvitation = T.HostNativeChatMigrationInvitation;\nexport import HostNativeChatOpenPage = T.HostNativeChatOpenPage;\nexport import HostNativeChatOpened = T.HostNativeChatOpened;\nexport import HostNativeChatPayment = T.HostNativeChatPayment;\nexport import HostNativeChatPaymentDirection = T.HostNativeChatPaymentDirection;\nexport import HostNativeChatPaymentFailure = T.HostNativeChatPaymentFailure;\nexport import HostNativeChatPaymentState = T.HostNativeChatPaymentState;\nexport import HostNativeChatPeer = T.HostNativeChatPeer;\nexport import HostNativeChatPeerDevice = T.HostNativeChatPeerDevice;\nexport import HostNativeChatPrepared = T.HostNativeChatPrepared;\nexport import HostNativeChatRichMessage = T.HostNativeChatRichMessage;\nexport import HostNativeChatRichMessageKind = T.HostNativeChatRichMessageKind;\nexport import HostNativeChatRoute = T.HostNativeChatRoute;\nexport import HostNativeChatStatePage = T.HostNativeChatStatePage;\nexport import VersionedHostNavigateToError = T.VersionedHostNavigateToError;\nexport import VersionedHostNavigateToRequest = T.VersionedHostNavigateToRequest;\nexport import VersionedHostNavigateToResponse = T.VersionedHostNavigateToResponse;\nexport import VersionedHostPaymentBalanceSubscribeError = T.VersionedHostPaymentBalanceSubscribeError;\nexport import VersionedHostPaymentBalanceSubscribeItem = T.VersionedHostPaymentBalanceSubscribeItem;\nexport import VersionedHostPaymentBalanceSubscribeRequest = T.VersionedHostPaymentBalanceSubscribeRequest;\nexport import VersionedHostPaymentError = T.VersionedHostPaymentError;\nexport import VersionedHostPaymentRequest = T.VersionedHostPaymentRequest;\nexport import VersionedHostPaymentResponse = T.VersionedHostPaymentResponse;\nexport import VersionedHostPaymentStatusSubscribeError = T.VersionedHostPaymentStatusSubscribeError;\nexport import VersionedHostPaymentStatusSubscribeItem = T.VersionedHostPaymentStatusSubscribeItem;\nexport import VersionedHostPaymentStatusSubscribeRequest = T.VersionedHostPaymentStatusSubscribeRequest;\nexport import VersionedHostPaymentTopUpError = T.VersionedHostPaymentTopUpError;\nexport import VersionedHostPaymentTopUpRequest = T.VersionedHostPaymentTopUpRequest;\nexport import VersionedHostPaymentTopUpResponse = T.VersionedHostPaymentTopUpResponse;\nexport import HostPlatform = T.HostPlatform;\nexport import VersionedHostPocketListSubscribeError = T.VersionedHostPocketListSubscribeError;\nexport import VersionedHostPocketListSubscribeItem = T.VersionedHostPocketListSubscribeItem;\nexport import VersionedHostPocketListSubscribeRequest = T.VersionedHostPocketListSubscribeRequest;\nexport import VersionedHostPocketRemoveCardError = T.VersionedHostPocketRemoveCardError;\nexport import VersionedHostPocketRemoveCardRequest = T.VersionedHostPocketRemoveCardRequest;\nexport import VersionedHostPocketRemoveCardResponse = T.VersionedHostPocketRemoveCardResponse;\nexport import VersionedHostProductDeviceChatError = T.VersionedHostProductDeviceChatError;\nexport import VersionedHostProductDeviceChatRequest = T.VersionedHostProductDeviceChatRequest;\nexport import VersionedHostProductDeviceChatResponse = T.VersionedHostProductDeviceChatResponse;\nexport import VersionedHostProfileDiscloseError = T.VersionedHostProfileDiscloseError;\nexport import VersionedHostProfileDiscloseRequest = T.VersionedHostProfileDiscloseRequest;\nexport import VersionedHostProfileDiscloseResponse = T.VersionedHostProfileDiscloseResponse;\nexport import VersionedHostProfilePresentContactError = T.VersionedHostProfilePresentContactError;\nexport import VersionedHostProfilePresentContactRequest = T.VersionedHostProfilePresentContactRequest;\nexport import VersionedHostProfilePresentContactResponse = T.VersionedHostProfilePresentContactResponse;\nexport import VersionedHostProfilePresentError = T.VersionedHostProfilePresentError;\nexport import VersionedHostProfilePresentRequest = T.VersionedHostProfilePresentRequest;\nexport import VersionedHostProfilePresentResponse = T.VersionedHostProfilePresentResponse;\nexport import VersionedHostProfileRetractError = T.VersionedHostProfileRetractError;\nexport import VersionedHostProfileRetractRequest = T.VersionedHostProfileRetractRequest;\nexport import VersionedHostProfileRetractResponse = T.VersionedHostProfileRetractResponse;\nexport import VersionedHostPushNotificationCancelError = T.VersionedHostPushNotificationCancelError;\nexport import VersionedHostPushNotificationCancelRequest = T.VersionedHostPushNotificationCancelRequest;\nexport import VersionedHostPushNotificationCancelResponse = T.VersionedHostPushNotificationCancelResponse;\nexport import VersionedHostPushNotificationError = T.VersionedHostPushNotificationError;\nexport import VersionedHostPushNotificationRequest = T.VersionedHostPushNotificationRequest;\nexport import VersionedHostPushNotificationResponse = T.VersionedHostPushNotificationResponse;\nexport import VersionedHostRendererActionSubscribeError = T.VersionedHostRendererActionSubscribeError;\nexport import VersionedHostRendererActionSubscribeItem = T.VersionedHostRendererActionSubscribeItem;\nexport import VersionedHostRendererActionSubscribeRequest = T.VersionedHostRendererActionSubscribeRequest;\nexport import VersionedHostRequestLoginError = T.VersionedHostRequestLoginError;\nexport import VersionedHostRequestLoginRequest = T.VersionedHostRequestLoginRequest;\nexport import VersionedHostRequestLoginResponse = T.VersionedHostRequestLoginResponse;\nexport import VersionedHostRequestResourceAllocationError = T.VersionedHostRequestResourceAllocationError;\nexport import VersionedHostRequestResourceAllocationRequest = T.VersionedHostRequestResourceAllocationRequest;\nexport import VersionedHostRequestResourceAllocationResponse = T.VersionedHostRequestResourceAllocationResponse;\nexport import HostSignPayloadData = T.HostSignPayloadData;\nexport import VersionedHostSignPayloadError = T.VersionedHostSignPayloadError;\nexport import VersionedHostSignPayloadRequest = T.VersionedHostSignPayloadRequest;\nexport import VersionedHostSignPayloadResponse = T.VersionedHostSignPayloadResponse;\nexport import VersionedHostSignPayloadWithLegacyAccountError = T.VersionedHostSignPayloadWithLegacyAccountError;\nexport import VersionedHostSignPayloadWithLegacyAccountRequest = T.VersionedHostSignPayloadWithLegacyAccountRequest;\nexport import VersionedHostSignPayloadWithLegacyAccountResponse = T.VersionedHostSignPayloadWithLegacyAccountResponse;\nexport import VersionedHostSignRawError = T.VersionedHostSignRawError;\nexport import VersionedHostSignRawRequest = T.VersionedHostSignRawRequest;\nexport import VersionedHostSignRawResponse = T.VersionedHostSignRawResponse;\nexport import VersionedHostSignRawWithLegacyAccountError = T.VersionedHostSignRawWithLegacyAccountError;\nexport import VersionedHostSignRawWithLegacyAccountRequest = T.VersionedHostSignRawWithLegacyAccountRequest;\nexport import VersionedHostSignRawWithLegacyAccountResponse = T.VersionedHostSignRawWithLegacyAccountResponse;\nexport import VersionedHostThemeSubscribeError = T.VersionedHostThemeSubscribeError;\nexport import VersionedHostThemeSubscribeItem = T.VersionedHostThemeSubscribeItem;\nexport import VersionedHostThemeSubscribeRequest = T.VersionedHostThemeSubscribeRequest;\nexport import VersionedHostWorkerBeginOperationError = T.VersionedHostWorkerBeginOperationError;\nexport import VersionedHostWorkerBeginOperationRequest = T.VersionedHostWorkerBeginOperationRequest;\nexport import VersionedHostWorkerBeginOperationResponse = T.VersionedHostWorkerBeginOperationResponse;\nexport import VersionedHostWorkerEndOperationError = T.VersionedHostWorkerEndOperationError;\nexport import VersionedHostWorkerEndOperationRequest = T.VersionedHostWorkerEndOperationRequest;\nexport import VersionedHostWorkerEndOperationResponse = T.VersionedHostWorkerEndOperationResponse;\nexport import HostWorkerOperationError = T.HostWorkerOperationError;\nexport import ImageFit = T.ImageFit;\nexport import ImageProps = T.ImageProps;\nexport import ImageSource = T.ImageSource;\nexport import LegacyAccount = T.LegacyAccount;\nexport import LegacyAccountTxPayload = T.LegacyAccountTxPayload;\nexport import Modifier = T.Modifier;\nexport import NotificationId = T.NotificationId;\nexport import OperationId = T.OperationId;\nexport import OperationStartedResult = T.OperationStartedResult;\nexport import PaymentTopUpSource = T.PaymentTopUpSource;\nexport import PocketCard = T.PocketCard;\nexport import PreimageSubmitError = T.PreimageSubmitError;\nexport import ProductAccount = T.ProductAccount;\nexport import ProductAccountId = T.ProductAccountId;\nexport import ProductAccountTxPayload = T.ProductAccountTxPayload;\nexport import ProductProofContext = T.ProductProofContext;\nexport import VersionedProductRendererRenderError = T.VersionedProductRendererRenderError;\nexport import VersionedProductRendererRenderItem = T.VersionedProductRendererRenderItem;\nexport import VersionedProductRendererRenderRequest = T.VersionedProductRendererRenderRequest;\nexport import RawPayload = T.RawPayload;\nexport import RegisteredRingVrfKey = T.RegisteredRingVrfKey;\nexport import VersionedRemoteChainHeadBodyError = T.VersionedRemoteChainHeadBodyError;\nexport import VersionedRemoteChainHeadBodyRequest = T.VersionedRemoteChainHeadBodyRequest;\nexport import VersionedRemoteChainHeadBodyResponse = T.VersionedRemoteChainHeadBodyResponse;\nexport import VersionedRemoteChainHeadCallError = T.VersionedRemoteChainHeadCallError;\nexport import VersionedRemoteChainHeadCallRequest = T.VersionedRemoteChainHeadCallRequest;\nexport import VersionedRemoteChainHeadCallResponse = T.VersionedRemoteChainHeadCallResponse;\nexport import VersionedRemoteChainHeadContinueError = T.VersionedRemoteChainHeadContinueError;\nexport import VersionedRemoteChainHeadContinueRequest = T.VersionedRemoteChainHeadContinueRequest;\nexport import VersionedRemoteChainHeadContinueResponse = T.VersionedRemoteChainHeadContinueResponse;\nexport import VersionedRemoteChainHeadFollowError = T.VersionedRemoteChainHeadFollowError;\nexport import VersionedRemoteChainHeadFollowItem = T.VersionedRemoteChainHeadFollowItem;\nexport import VersionedRemoteChainHeadFollowRequest = T.VersionedRemoteChainHeadFollowRequest;\nexport import VersionedRemoteChainHeadHeaderError = T.VersionedRemoteChainHeadHeaderError;\nexport import VersionedRemoteChainHeadHeaderRequest = T.VersionedRemoteChainHeadHeaderRequest;\nexport import VersionedRemoteChainHeadHeaderResponse = T.VersionedRemoteChainHeadHeaderResponse;\nexport import VersionedRemoteChainHeadStopOperationError = T.VersionedRemoteChainHeadStopOperationError;\nexport import VersionedRemoteChainHeadStopOperationRequest = T.VersionedRemoteChainHeadStopOperationRequest;\nexport import VersionedRemoteChainHeadStopOperationResponse = T.VersionedRemoteChainHeadStopOperationResponse;\nexport import VersionedRemoteChainHeadStorageError = T.VersionedRemoteChainHeadStorageError;\nexport import VersionedRemoteChainHeadStorageRequest = T.VersionedRemoteChainHeadStorageRequest;\nexport import VersionedRemoteChainHeadStorageResponse = T.VersionedRemoteChainHeadStorageResponse;\nexport import VersionedRemoteChainHeadUnpinError = T.VersionedRemoteChainHeadUnpinError;\nexport import VersionedRemoteChainHeadUnpinRequest = T.VersionedRemoteChainHeadUnpinRequest;\nexport import VersionedRemoteChainHeadUnpinResponse = T.VersionedRemoteChainHeadUnpinResponse;\nexport import VersionedRemoteChainInfoError = T.VersionedRemoteChainInfoError;\nexport import VersionedRemoteChainInfoRequest = T.VersionedRemoteChainInfoRequest;\nexport import VersionedRemoteChainInfoResponse = T.VersionedRemoteChainInfoResponse;\nexport import VersionedRemoteChainSpecChainNameError = T.VersionedRemoteChainSpecChainNameError;\nexport import VersionedRemoteChainSpecChainNameRequest = T.VersionedRemoteChainSpecChainNameRequest;\nexport import VersionedRemoteChainSpecChainNameResponse = T.VersionedRemoteChainSpecChainNameResponse;\nexport import VersionedRemoteChainSpecGenesisHashError = T.VersionedRemoteChainSpecGenesisHashError;\nexport import VersionedRemoteChainSpecGenesisHashRequest = T.VersionedRemoteChainSpecGenesisHashRequest;\nexport import VersionedRemoteChainSpecGenesisHashResponse = T.VersionedRemoteChainSpecGenesisHashResponse;\nexport import VersionedRemoteChainSpecPropertiesError = T.VersionedRemoteChainSpecPropertiesError;\nexport import VersionedRemoteChainSpecPropertiesRequest = T.VersionedRemoteChainSpecPropertiesRequest;\nexport import VersionedRemoteChainSpecPropertiesResponse = T.VersionedRemoteChainSpecPropertiesResponse;\nexport import VersionedRemoteChainTransactionBroadcastError = T.VersionedRemoteChainTransactionBroadcastError;\nexport import VersionedRemoteChainTransactionBroadcastRequest = T.VersionedRemoteChainTransactionBroadcastRequest;\nexport import VersionedRemoteChainTransactionBroadcastResponse = T.VersionedRemoteChainTransactionBroadcastResponse;\nexport import VersionedRemoteChainTransactionStopError = T.VersionedRemoteChainTransactionStopError;\nexport import VersionedRemoteChainTransactionStopRequest = T.VersionedRemoteChainTransactionStopRequest;\nexport import VersionedRemoteChainTransactionStopResponse = T.VersionedRemoteChainTransactionStopResponse;\nexport import RemotePermission = T.RemotePermission;\nexport import VersionedRemotePermissionError = T.VersionedRemotePermissionError;\nexport import VersionedRemotePermissionRequest = T.VersionedRemotePermissionRequest;\nexport import VersionedRemotePermissionResponse = T.VersionedRemotePermissionResponse;\nexport import VersionedRemotePreimageLookupSubscribeError = T.VersionedRemotePreimageLookupSubscribeError;\nexport import VersionedRemotePreimageLookupSubscribeItem = T.VersionedRemotePreimageLookupSubscribeItem;\nexport import VersionedRemotePreimageLookupSubscribeRequest = T.VersionedRemotePreimageLookupSubscribeRequest;\nexport import VersionedRemotePreimageSubmitError = T.VersionedRemotePreimageSubmitError;\nexport import VersionedRemotePreimageSubmitRequest = T.VersionedRemotePreimageSubmitRequest;\nexport import VersionedRemotePreimageSubmitResponse = T.VersionedRemotePreimageSubmitResponse;\nexport import VersionedRemoteStatementStoreCreateProofAuthorizedError = T.VersionedRemoteStatementStoreCreateProofAuthorizedError;\nexport import VersionedRemoteStatementStoreCreateProofAuthorizedRequest = T.VersionedRemoteStatementStoreCreateProofAuthorizedRequest;\nexport import VersionedRemoteStatementStoreCreateProofAuthorizedResponse = T.VersionedRemoteStatementStoreCreateProofAuthorizedResponse;\nexport import VersionedRemoteStatementStoreCreateProofError = T.VersionedRemoteStatementStoreCreateProofError;\nexport import VersionedRemoteStatementStoreCreateProofRequest = T.VersionedRemoteStatementStoreCreateProofRequest;\nexport import VersionedRemoteStatementStoreCreateProofResponse = T.VersionedRemoteStatementStoreCreateProofResponse;\nexport import VersionedRemoteStatementStoreSubmitError = T.VersionedRemoteStatementStoreSubmitError;\nexport import VersionedRemoteStatementStoreSubmitRequest = T.VersionedRemoteStatementStoreSubmitRequest;\nexport import VersionedRemoteStatementStoreSubmitResponse = T.VersionedRemoteStatementStoreSubmitResponse;\nexport import VersionedRemoteStatementStoreSubscribeError = T.VersionedRemoteStatementStoreSubscribeError;\nexport import VersionedRemoteStatementStoreSubscribeItem = T.VersionedRemoteStatementStoreSubscribeItem;\nexport import VersionedRemoteStatementStoreSubscribeRequest = T.VersionedRemoteStatementStoreSubscribeRequest;\nexport import RenderContext = T.RenderContext;\nexport import RendererNode = T.RendererNode;\nexport import ResourceAllocationError = T.ResourceAllocationError;\nexport import RingLocation = T.RingLocation;\nexport import RingLocationJunction = T.RingLocationJunction;\nexport import RingVrfKeyDisclosure = T.RingVrfKeyDisclosure;\nexport import RingVrfPublicKey = T.RingVrfPublicKey;\nexport import RowProps = T.RowProps;\nexport import RuntimeApi = T.RuntimeApi;\nexport import RuntimeSpec = T.RuntimeSpec;\nexport import RuntimeType = T.RuntimeType;\nexport import Shape = T.Shape;\nexport import SignedStatement = T.SignedStatement;\nexport import Size = T.Size;\nexport import Statement = T.Statement;\nexport import StatementProof = T.StatementProof;\nexport import StorageQueryItem = T.StorageQueryItem;\nexport import StorageQueryType = T.StorageQueryType;\nexport import StorageResultItem = T.StorageResultItem;\nexport import TextFieldProps = T.TextFieldProps;\nexport import TextProps = T.TextProps;\nexport import ThemeName = T.ThemeName;\nexport import ThemeVariant = T.ThemeVariant;\nexport import Topic = T.Topic;\nexport import TxPayloadExtension = T.TxPayloadExtension;\nexport import TypographyStyle = T.TypographyStyle;\nexport import HostAccountConnectionStatusSubscribeItem = T.HostAccountConnectionStatusSubscribeItem;\nexport import HostAccountCreateProofError = T.HostAccountCreateProofError;\nexport import HostAccountCreateProofRequest = T.HostAccountCreateProofRequest;\nexport import HostAccountCreateProofResponse = T.HostAccountCreateProofResponse;\nexport import HostAccountGetAliasError = T.HostAccountGetAliasError;\nexport import HostAccountGetAliasRequest = T.HostAccountGetAliasRequest;\nexport import HostAccountGetError = T.HostAccountGetError;\nexport import HostAccountGetRequest = T.HostAccountGetRequest;\nexport import HostAccountGetResponse = T.HostAccountGetResponse;\nexport import HostAccountListRingVrfKeysError = T.HostAccountListRingVrfKeysError;\nexport import HostAccountListRingVrfKeysRequest = T.HostAccountListRingVrfKeysRequest;\nexport import HostAccountRegisterRingVrfKeyError = T.HostAccountRegisterRingVrfKeyError;\nexport import HostAccountRegisterRingVrfKeyRequest = T.HostAccountRegisterRingVrfKeyRequest;\nexport import HostAccountRingVrfSignError = T.HostAccountRingVrfSignError;\nexport import HostAccountRingVrfSignRequest = T.HostAccountRingVrfSignRequest;\nexport import HostAccountSignVrfError = T.HostAccountSignVrfError;\nexport import HostAccountSignVrfRequest = T.HostAccountSignVrfRequest;\nexport import HostChatActionSubscribeItem = T.HostChatActionSubscribeItem;\nexport import HostChatCreateRoomError = T.HostChatCreateRoomError;\nexport import HostChatCreateRoomRequest = T.HostChatCreateRoomRequest;\nexport import HostChatCreateRoomResponse = T.HostChatCreateRoomResponse;\nexport import HostChatListSubscribeItem = T.HostChatListSubscribeItem;\nexport import HostChatPostMessageError = T.HostChatPostMessageError;\nexport import HostChatPostMessageRequest = T.HostChatPostMessageRequest;\nexport import HostChatPostMessageResponse = T.HostChatPostMessageResponse;\nexport import HostChatRegisterBotError = T.HostChatRegisterBotError;\nexport import HostChatRegisterBotRequest = T.HostChatRegisterBotRequest;\nexport import HostChatRegisterBotResponse = T.HostChatRegisterBotResponse;\nexport import HostCoinPaymentCreateChequeRequest = T.HostCoinPaymentCreateChequeRequest;\nexport import HostCoinPaymentCreateChequeResponse = T.HostCoinPaymentCreateChequeResponse;\nexport import HostCoinPaymentCreatePurseRequest = T.HostCoinPaymentCreatePurseRequest;\nexport import HostCoinPaymentCreatePurseResponse = T.HostCoinPaymentCreatePurseResponse;\nexport import HostCoinPaymentCreateReceivableRequest = T.HostCoinPaymentCreateReceivableRequest;\nexport import HostCoinPaymentCreateReceivableResponse = T.HostCoinPaymentCreateReceivableResponse;\nexport import HostCoinPaymentDeletePurseRequest = T.HostCoinPaymentDeletePurseRequest;\nexport import HostCoinPaymentDepositRequest = T.HostCoinPaymentDepositRequest;\nexport import HostCoinPaymentListenForItem = T.HostCoinPaymentListenForItem;\nexport import HostCoinPaymentListenForRequest = T.HostCoinPaymentListenForRequest;\nexport import HostCoinPaymentQueryPurseRequest = T.HostCoinPaymentQueryPurseRequest;\nexport import HostCoinPaymentQueryPurseResponse = T.HostCoinPaymentQueryPurseResponse;\nexport import HostCoinPaymentRebalancePurseRequest = T.HostCoinPaymentRebalancePurseRequest;\nexport import HostCoinPaymentRefundRequest = T.HostCoinPaymentRefundRequest;\nexport import HostCreateTransactionError = T.HostCreateTransactionError;\nexport import HostCreateTransactionResponse = T.HostCreateTransactionResponse;\nexport import HostCreateTransactionWithLegacyAccountResponse = T.HostCreateTransactionWithLegacyAccountResponse;\nexport import HostDeriveEntropyError = T.HostDeriveEntropyError;\nexport import HostDeriveEntropyRequest = T.HostDeriveEntropyRequest;\nexport import HostDeriveEntropyResponse = T.HostDeriveEntropyResponse;\nexport import HostDevicePermissionRequest = T.HostDevicePermissionRequest;\nexport import HostDevicePermissionResponse = T.HostDevicePermissionResponse;\nexport import HostFeatureSupportedRequest = T.HostFeatureSupportedRequest;\nexport import HostFeatureSupportedResponse = T.HostFeatureSupportedResponse;\nexport import HostGetLegacyAccountsResponse = T.HostGetLegacyAccountsResponse;\nexport import HostGetProductContextResponse = T.HostGetProductContextResponse;\nexport import HostGetUserIdError = T.HostGetUserIdError;\nexport import HostGetUserIdResponse = T.HostGetUserIdResponse;\nexport import HostHandshakeError = T.HostHandshakeError;\nexport import HostHandshakeRequest = T.HostHandshakeRequest;\nexport import HostLocalStorageChangeItem = T.HostLocalStorageChangeItem;\nexport import HostLocalStorageClearRequest = T.HostLocalStorageClearRequest;\nexport import V01HostLocalStorageReadError = T.V01HostLocalStorageReadError;\nexport import V01HostLocalStorageReadRequest = T.V01HostLocalStorageReadRequest;\nexport import HostLocalStorageReadResponse = T.HostLocalStorageReadResponse;\nexport import HostLocalStorageSubscribeRequest = T.HostLocalStorageSubscribeRequest;\nexport import HostLocalStorageWriteRequest = T.HostLocalStorageWriteRequest;\nexport import HostLocaleSubscribeItem = T.HostLocaleSubscribeItem;\nexport import HostNavigateToError = T.HostNavigateToError;\nexport import HostNavigateToRequest = T.HostNavigateToRequest;\nexport import HostPaymentBalanceSubscribeError = T.HostPaymentBalanceSubscribeError;\nexport import HostPaymentBalanceSubscribeItem = T.HostPaymentBalanceSubscribeItem;\nexport import HostPaymentBalanceSubscribeRequest = T.HostPaymentBalanceSubscribeRequest;\nexport import HostPaymentError = T.HostPaymentError;\nexport import HostPaymentRequest = T.HostPaymentRequest;\nexport import HostPaymentResponse = T.HostPaymentResponse;\nexport import HostPaymentStatusSubscribeError = T.HostPaymentStatusSubscribeError;\nexport import HostPaymentStatusSubscribeItem = T.HostPaymentStatusSubscribeItem;\nexport import HostPaymentStatusSubscribeRequest = T.HostPaymentStatusSubscribeRequest;\nexport import HostPaymentTopUpError = T.HostPaymentTopUpError;\nexport import HostPaymentTopUpRequest = T.HostPaymentTopUpRequest;\nexport import HostPocketListSubscribeItem = T.HostPocketListSubscribeItem;\nexport import HostPocketRemoveCardError = T.HostPocketRemoveCardError;\nexport import HostPocketRemoveCardRequest = T.HostPocketRemoveCardRequest;\nexport import HostProfileDiscloseError = T.HostProfileDiscloseError;\nexport import HostProfileDiscloseRequest = T.HostProfileDiscloseRequest;\nexport import HostProfilePresentContactError = T.HostProfilePresentContactError;\nexport import HostProfilePresentContactRequest = T.HostProfilePresentContactRequest;\nexport import HostProfilePresentError = T.HostProfilePresentError;\nexport import HostProfilePresentRequest = T.HostProfilePresentRequest;\nexport import HostProfileRetractError = T.HostProfileRetractError;\nexport import HostPushNotificationCancelRequest = T.HostPushNotificationCancelRequest;\nexport import HostPushNotificationError = T.HostPushNotificationError;\nexport import HostPushNotificationRequest = T.HostPushNotificationRequest;\nexport import HostPushNotificationResponse = T.HostPushNotificationResponse;\nexport import HostRendererActionSubscribeItem = T.HostRendererActionSubscribeItem;\nexport import HostRequestLoginError = T.HostRequestLoginError;\nexport import HostRequestLoginRequest = T.HostRequestLoginRequest;\nexport import HostRequestLoginResponse = T.HostRequestLoginResponse;\nexport import HostRequestResourceAllocationRequest = T.HostRequestResourceAllocationRequest;\nexport import HostRequestResourceAllocationResponse = T.HostRequestResourceAllocationResponse;\nexport import HostSignPayloadError = T.HostSignPayloadError;\nexport import HostSignPayloadRequest = T.HostSignPayloadRequest;\nexport import HostSignPayloadResponse = T.HostSignPayloadResponse;\nexport import HostSignPayloadWithLegacyAccountRequest = T.HostSignPayloadWithLegacyAccountRequest;\nexport import HostSignRawRequest = T.HostSignRawRequest;\nexport import HostSignRawWithLegacyAccountRequest = T.HostSignRawWithLegacyAccountRequest;\nexport import HostThemeSubscribeItem = T.HostThemeSubscribeItem;\nexport import HostWorkerBeginOperationRequest = T.HostWorkerBeginOperationRequest;\nexport import HostWorkerBeginOperationResponse = T.HostWorkerBeginOperationResponse;\nexport import HostWorkerEndOperationRequest = T.HostWorkerEndOperationRequest;\nexport import ProductRendererRenderRequest = T.ProductRendererRenderRequest;\nexport import RemoteChainHeadBodyRequest = T.RemoteChainHeadBodyRequest;\nexport import RemoteChainHeadBodyResponse = T.RemoteChainHeadBodyResponse;\nexport import RemoteChainHeadCallRequest = T.RemoteChainHeadCallRequest;\nexport import RemoteChainHeadCallResponse = T.RemoteChainHeadCallResponse;\nexport import RemoteChainHeadContinueRequest = T.RemoteChainHeadContinueRequest;\nexport import RemoteChainHeadFollowItem = T.RemoteChainHeadFollowItem;\nexport import RemoteChainHeadFollowRequest = T.RemoteChainHeadFollowRequest;\nexport import RemoteChainHeadHeaderRequest = T.RemoteChainHeadHeaderRequest;\nexport import RemoteChainHeadHeaderResponse = T.RemoteChainHeadHeaderResponse;\nexport import RemoteChainHeadStopOperationRequest = T.RemoteChainHeadStopOperationRequest;\nexport import RemoteChainHeadStorageRequest = T.RemoteChainHeadStorageRequest;\nexport import RemoteChainHeadStorageResponse = T.RemoteChainHeadStorageResponse;\nexport import RemoteChainHeadUnpinRequest = T.RemoteChainHeadUnpinRequest;\nexport import RemoteChainInfoError = T.RemoteChainInfoError;\nexport import RemoteChainInfoRequest = T.RemoteChainInfoRequest;\nexport import RemoteChainInfoResponse = T.RemoteChainInfoResponse;\nexport import RemoteChainSpecChainNameRequest = T.RemoteChainSpecChainNameRequest;\nexport import RemoteChainSpecChainNameResponse = T.RemoteChainSpecChainNameResponse;\nexport import RemoteChainSpecGenesisHashRequest = T.RemoteChainSpecGenesisHashRequest;\nexport import RemoteChainSpecGenesisHashResponse = T.RemoteChainSpecGenesisHashResponse;\nexport import RemoteChainSpecPropertiesRequest = T.RemoteChainSpecPropertiesRequest;\nexport import RemoteChainSpecPropertiesResponse = T.RemoteChainSpecPropertiesResponse;\nexport import RemoteChainTransactionBroadcastRequest = T.RemoteChainTransactionBroadcastRequest;\nexport import RemoteChainTransactionBroadcastResponse = T.RemoteChainTransactionBroadcastResponse;\nexport import RemoteChainTransactionStopRequest = T.RemoteChainTransactionStopRequest;\nexport import RemotePermissionRequest = T.RemotePermissionRequest;\nexport import RemotePermissionResponse = T.RemotePermissionResponse;\nexport import RemotePreimageLookupSubscribeItem = T.RemotePreimageLookupSubscribeItem;\nexport import RemotePreimageLookupSubscribeRequest = T.RemotePreimageLookupSubscribeRequest;\nexport import RemoteStatementStoreCreateProofError = T.RemoteStatementStoreCreateProofError;\nexport import RemoteStatementStoreCreateProofRequest = T.RemoteStatementStoreCreateProofRequest;\nexport import RemoteStatementStoreCreateProofResponse = T.RemoteStatementStoreCreateProofResponse;\nexport import RemoteStatementStoreSubscribeItem = T.RemoteStatementStoreSubscribeItem;\nexport import RemoteStatementStoreSubscribeRequest = T.RemoteStatementStoreSubscribeRequest;\nexport import HostLocalStorageReadError = T.HostLocalStorageReadError;\nexport import HostLocalStorageReadRequest = T.HostLocalStorageReadRequest;\nexport import HostProductDeviceChatError = T.HostProductDeviceChatError;\nexport import V02HostProductDeviceChatRequest = T.V02HostProductDeviceChatRequest;\nexport import V02HostProductDeviceChatResponse = T.V02HostProductDeviceChatResponse;\nexport import HostProductDeviceChatRequest = T.HostProductDeviceChatRequest;\nexport import HostProductDeviceChatResponse = T.HostProductDeviceChatResponse;\nexport import VerticalAlignment = T.VerticalAlignment;\nexport import VrfSignature = T.VrfSignature;\nexport import VrfTranscriptItem = T.VrfTranscriptItem;\n\n// index.d.ts\n\n\n// transport.d.ts\n/**\n * Wire trait discriminant reserved for method-independent protocol errors. No\n * API trait may declare it, so no method is ever addressed here.\n **/\nexport declare const PROTOCOL_ERROR_TRAIT_ID: 255;\n/** Wire method discriminant reserved for method-independent protocol errors. **/\nexport declare const PROTOCOL_ERROR_METHOD_ID: 255;\n/** The peer rejected an outbound frame because it does not support its API. **/\nexport declare class UnsupportedMessageError extends Error {\n /** Trait discriminant of the unsupported outbound frame. **/\n readonly traitId: number;\n /** Method discriminant of the unsupported outbound frame. **/\n readonly methodId: number;\n constructor(traitId: number, methodId: number);\n}\n/** The host connection ended; interrupted operations are not retried. */\nexport declare class ConnectionResetError extends Error {\n constructor(options?: ErrorOptions);\n}\n/** Call result returned when the peer does not recognize a request frame. **/\nexport type UnsupportedCallError = Extract, {\n tag: \"Unsupported\";\n}>;\n/**\n * Handle returned by TrUAPI subscription APIs.\n **/\nexport interface Subscription {\n /**\n * Stop the subscription. Calling this more than once has no additional effect.\n **/\n unsubscribe: () => void;\n /**\n * Transport-assigned request id for the subscription start frame.\n *\n * Methods that accept a `followSubscriptionId` use this value to scope\n * follow-up requests to a specific active subscription.\n **/\n subscriptionId: string;\n}\n/**\n * Terminal error delivered through `Observer.error` for every non-normal\n * subscription end. When the peer interrupted the stream with a typed payload,\n * `reason` carries the decoded `Reason`; otherwise `reason` is `undefined` and\n * the underlying transport/decode error is preserved on `cause`.\n *\n * Discriminate with `error.reason !== undefined` (or `'reason' in error`).\n **/\nexport declare class SubscriptionError extends Error {\n /**\n * Typed payload supplied by the peer when it interrupted the subscription.\n * `undefined` when the stream ended for any other reason (transport close,\n * decode failure, malformed interrupt payload).\n **/\n readonly reason?: Reason;\n constructor(message: string, options?: {\n reason?: Reason;\n cause?: unknown;\n });\n}\n/**\n * Minimal Observable-compatible observer shape used by generated subscription\n * APIs without depending on RxJS.\n *\n * `Reason` is the typed interrupt payload for the originating subscription.\n * Methods without a typed interrupt resolve `Reason` to `never`, leaving\n * `error.reason` typed as `undefined`.\n **/\nexport interface Observer {\n /**\n * Called with each successfully decoded subscription item.\n **/\n next(value: Item): void;\n /**\n * Called once when the stream terminates with an error. Inspect\n * `error.reason` to distinguish a typed peer interrupt from a transport or\n * decode failure (`error.cause` carries the underlying failure in the\n * latter case).\n **/\n error(error: SubscriptionError): void;\n /**\n * Called once when the peer normally completes the stream.\n **/\n complete(): void;\n}\ndeclare global {\n interface SymbolConstructor {\n readonly observable: unique symbol;\n }\n}\n/**\n * Minimal Observable-compatible object returned by generated subscription APIs.\n *\n * Implements the ES Observable interop protocol so that consumers can pass\n * an instance straight to `rxjs.from(...)`.\n **/\nexport interface ObservableLike {\n /**\n * Start the stream and receive `next`, `error`, and `complete` callbacks.\n **/\n subscribe(observer?: Partial>): Subscription;\n /**\n * Observable interop hook. Returns `this`.\n **/\n [Symbol.observable](): ObservableLike;\n}\n/**\n * Product-side handler for a subscription the native host initiates.\n *\n * It receives the decoded request and two callbacks: `send` delivers one item\n * to the host, and `interrupt` ends the stream, cleanly when called with no\n * argument and with the method's interrupt value otherwise. The returned\n * teardown, if any, runs once the stream ends: on the host's stop frame, on\n * `interrupt`, when the transport closes, or when the host restarts the same\n * request id.\n **/\nexport type HostInitiatedSubscriptionHandler = (request: Request, send: (item: Item) => void, interrupt: (reason?: Reason) => void) => (() => void) | void;\n/**\n * Wire discriminant pair addressing a method. One id addresses a method\n * regardless of shape (request/response, or a subscription's four phases):\n * which leg of the exchange a frame carries is the wire's own `messageType`\n * byte, not a separate id per leg.\n **/\nexport interface MethodIds {\n /**\n * Wire trait discriminant.\n **/\n trait: number;\n /**\n * Wire method discriminant within the trait.\n **/\n method: number;\n /**\n * Whether this method's legs follow the request/response shape or the\n * subscription shape (`\"subscription\"` covers both plain and result\n * subscriptions, which share the same four-leg wire shape). The one piece\n * of shape a payload-blind reader needs to interpret a frame's own\n * `messageType` byte without decoding the payload.\n **/\n kind: \"request\" | \"subscription\";\n}\n/**\n * Per-call options every generated request method accepts as its last\n * argument.\n **/\nexport interface CallOptions {\n /** See {@link RequestParams.signal}. **/\n signal?: AbortSignal;\n}\n/**\n * Options accepted by `TrUApiTransport.request`.\n **/\nexport interface RequestParams {\n /**\n * Wire discriminants for this request method.\n **/\n ids: MethodIds;\n /**\n * SCALE-encoded request wrapper payload bytes (its own `V` tag is the\n * wire's only version signal), constructed by the generated caller.\n **/\n payload: Uint8Array;\n /**\n * Decode a `Response`-leg frame's raw payload bytes into the typed Ok/Err\n * outcome. Implementations decode `Result<{Method}Response,\n * CallError<{Method}Error>>` directly. The transport unwraps the result\n * into `ResultAsync`.\n **/\n decodeResponse: (payload: Uint8Array) => ResultPayload;\n /**\n * Withdraw the call. Aborting sends a `Cancel` frame on this method's own\n * address; the promise still settles on the response the host sends, which\n * for a call the host stopped is `CallError::Cancelled`. A signal already\n * aborted when the call is made sends nothing and rejects immediately.\n *\n * A host that predates the `Cancel` leg drops the frame, so an aborted call\n * against one settles on its deadline instead. There is no way to detect that\n * first: `system.featureSupported` answers only about chains, so an abort\n * against an older host is indistinguishable from one it honoured.\n **/\n signal?: AbortSignal;\n}\n/**\n * Options accepted by `TrUApiTransport.subscribeRaw`.\n **/\nexport interface SubscribeRawParams {\n /**\n * Wire discriminants for this subscription method.\n **/\n ids: MethodIds;\n /**\n * SCALE-encoded `Start`-leg payload bytes: the request wrapper's own\n * encoding, or empty bytes for a method with no request at all,\n * constructed by the generated caller.\n **/\n payload: Uint8Array;\n /**\n * Called with a `Receive`-leg frame's raw payload bytes.\n **/\n onReceive: (payload: Uint8Array) => void;\n /**\n * Called with an `Interrupt`-leg frame's raw payload bytes.\n **/\n onInterrupt?: (payload: Uint8Array) => void;\n /**\n * Called when a transport-level error or unsupported start frame terminates\n * the subscription.\n **/\n onClose?: (error: Error) => void;\n}\n/** Product-side registration for one host-initiated subscription method. **/\nexport interface HostInitiatedSubscriptionRegistration {\n /** Install or replace the handler used for future start frames. **/\n setHandler(handler: HostInitiatedSubscriptionHandler): {\n unsubscribe(): void;\n };\n}\n/** Options used to register a host-initiated subscription method. **/\nexport interface RegisterHostInitiatedSubscriptionParams {\n /** Wire discriminants for the host-initiated subscription. **/\n ids: MethodIds;\n /**\n * Decode a `Start`-leg frame's raw payload bytes into the typed request.\n **/\n decodeRequest(payload: Uint8Array): Request;\n /**\n * Encode one product emission as a `Receive`-leg frame's raw payload bytes.\n **/\n encodeItem(item: Item): Uint8Array;\n /**\n * Encode an `Interrupt`-leg frame's raw payload bytes: the stream's clean\n * end when `reason` is omitted, and the method's interrupt value otherwise.\n **/\n encodeInterrupt(reason?: Reason): Uint8Array;\n /**\n * Exact payload used when the transport ends a stream the product's handler\n * never got to serve.\n **/\n declinePayload: Uint8Array;\n /** Number of starts retained before a handler is installed. **/\n bufferCapacity: number;\n}\n/**\n * Byte-level transport used by generated client stubs.\n **/\nexport interface TrUApiTransport {\n /**\n * Send a one-shot request and resolve with the typed Ok/Err outcome.\n **/\n request(params: RequestParams): ResultAsync;\n /**\n * Start a subscription and return a handle that can stop it.\n **/\n subscribeRaw(params: SubscribeRawParams): Subscription;\n /** Register product-side handling for a host-initiated subscription. **/\n registerHostInitiatedSubscription(params: RegisterHostInitiatedSubscriptionParams): HostInitiatedSubscriptionRegistration;\n /**\n * Tear down the transport and release the listeners it registered on the\n * underlying `WireProvider`. Pending requests reject and live subscriptions\n * receive `onClose`. Idempotent.\n *\n * The provider itself is left alone; the caller decides whether to also\n * call `provider.dispose()` (long-lived hosts that swap providers will\n * typically dispose the transport but keep the provider).\n **/\n dispose(): void;\n}\n/**\n * Tagged payload inside a TrUAPI wire frame.\n **/\nexport interface Payload {\n /**\n * Wire-table trait discriminant: first byte of the `(trait, method)` pair.\n **/\n traitId: number;\n /**\n * Wire-table method discriminant within the trait: second byte of the pair.\n **/\n methodId: number;\n /**\n * Which leg of the method's exchange this frame carries: `Request`/`Start`\n * = 0, `Response`/`Receive` = 1, `Interrupt` = 2, `Stop` = 3. Third byte of\n * the wire frame \u2014 readable generically, without decoding `value`.\n **/\n messageType: number;\n /**\n * SCALE-encoded payload body: that leg's own versioned wrapper, with no\n * further tag identifying direction or version beyond the wrapper's own.\n **/\n value: Uint8Array;\n}\n/** See {@link Payload.messageType}. */\nexport declare const MESSAGE_TYPE_REQUEST = 0;\n/** See {@link Payload.messageType}. */\nexport declare const MESSAGE_TYPE_START = 0;\n/** See {@link Payload.messageType}. */\nexport declare const MESSAGE_TYPE_RESPONSE = 1;\n/** See {@link Payload.messageType}. */\nexport declare const MESSAGE_TYPE_RECEIVE = 1;\n/** See {@link Payload.messageType}. */\nexport declare const MESSAGE_TYPE_INTERRUPT = 2;\n/** See {@link Payload.messageType}. */\nexport declare const MESSAGE_TYPE_STOP = 3;\n/**\n * A request's withdrawal, correlated by the same `requestId` and carrying no\n * payload. The call still settles with exactly one response; this only fires\n * the handler's cancellation token on the far side.\n **/\nexport declare const MESSAGE_TYPE_CANCEL = 4;\n/**\n * Top-level TrUAPI wire message.\n **/\nexport interface ProtocolMessage {\n /**\n * Request id used to correlate request/response and subscription frames.\n **/\n requestId: string;\n /**\n * Tagged SCALE payload carried by this frame.\n **/\n payload: Payload;\n}\n/**\n * Raw SCALE-wire-frame pipe abstraction used by the transport. A `WireProvider`\n * is the low-level channel (a `MessagePort` or iframe `postMessage` link) that\n * carries encoded frames between the product and the host.\n **/\nexport interface WireProvider {\n /**\n * Send a complete SCALE-encoded wire frame to the peer.\n **/\n postMessage(message: Uint8Array): void;\n /**\n * Register a callback for inbound SCALE-encoded wire frames.\n **/\n subscribe(callback: (message: Uint8Array) => void): () => void;\n /**\n * Register a callback for provider-level close or failure events.\n *\n * Providers keep a terminal close reason. The callback fires at most once\n * for an active subscription, and fires immediately when registered after\n * the provider has already closed.\n **/\n subscribeClose?(callback: (error: Error) => void): () => void;\n /** End current operations while keeping the provider available for new work. */\n subscribeReset?(callback: (error: Error) => void): () => void;\n /**\n * Release provider resources and close the underlying pipe.\n **/\n dispose(): void;\n}\n/**\n * A {@link WireProvider} backed by a WebSocket, which reports when its socket\n * is up. Awaiting {@link WebSocketWireProvider.opened} is optional: frames\n * posted earlier are queued and flushed on open.\n **/\nexport interface WebSocketWireProvider extends WireProvider {\n /** Resolves once the socket is open, rejects if it never connects. */\n opened: Promise;\n}\n/**\n * Encode a `ProtocolMessage` into a SCALE wire frame.\n **/\nexport declare function encodeWireMessage(message: ProtocolMessage): Result;\n/**\n * Decode a SCALE wire frame into a `ProtocolMessage`.\n **/\nexport declare function decodeWireMessage(message: Uint8Array): Result;\n/**\n * Create a provider for the child side of an iframe `postMessage` channel.\n *\n * `target` is the `Window` the provider posts to (typically `window.parent`);\n * `hostOrigin` is the pinned `targetOrigin` for outbound frames and the\n * required `event.origin` of inbound frames. The provider only delivers\n * frames whose `event.source === target` and `event.origin === hostOrigin`,\n * so it cannot be coerced by an unrelated frame parent.\n **/\nexport declare function createIframeProvider(options: {\n target: Window;\n hostOrigin: string;\n}): WireProvider;\n/**\n * Create a provider from a web or Electron `MessagePort`.\n **/\nexport declare function createMessagePortProvider(port: MessagePort | Promise): WireProvider;\n/**\n * Wire provider over a binary WebSocket, one message per SCALE frame.\n *\n * This is the transport a host exposes on a loopback socket: the Rust core's\n * `ws-bridge`, and `truapi-host signing-host --frame-listen`. The frame bytes\n * are identical to what the {@link createMessagePortProvider} path carries, so\n * this is a pipe and nothing more.\n *\n * Frames posted before the socket opens are queued and flushed on open, so a\n * caller never has to await {@link WebSocketWireProvider.opened} first.\n **/\nexport declare function createWebSocketProvider(url: string): WebSocketWireProvider;\n/** Capture native socket APIs before product code installs network gates. */\nexport declare function createWebSocketProviderFactory(): (url: string) => WebSocketWireProvider;\n\n\n// client.d.ts\nexport type { Subscription, TrUApiTransport };\n/** A request received no matching response before its transport deadline. */\nexport declare class RequestTimeoutError extends Error {\n /** Transport-assigned request identifier. */\n readonly requestId: string;\n /** Trait discriminant of the unanswered request. */\n readonly traitId: number;\n /** Method discriminant of the unanswered request. */\n readonly methodId: number;\n /** Deadline that elapsed, in milliseconds. */\n readonly timeoutMs: number;\n constructor(requestId: string, traitId: number, methodId: number, timeoutMs: number);\n}\n/**\n * Options accepted when constructing a transport.\n */\nexport interface CreateTransportOptions {\n /** Request ID namespace when multiple transports share a connection. Defaults to `p:`. */\n requestIdPrefix?: string;\n /** Wait for connection readiness before sending a request or starting a subscription. */\n prepare?: (ids: MethodIds) => Promise;\n /** Replace a failed connection after a malformed frame; otherwise the transport closes permanently. */\n onProtocolError?: (error: Error) => void;\n /**\n * Maximum time to wait for a matching response before rejecting the request.\n *\n * Defaults to 120 seconds. This bounds dead hosts and missed transport\n * handshakes while leaving interactive approval flows enough time to finish.\n * The handshake keeps its own shorter deadline, since a codec mismatch means\n * no answer is ever coming.\n */\n requestTimeoutMs?: number;\n}\n/**\n * Build a `TrUApiTransport` on top of a `WireProvider`, adding request/response\n * correlation and subscription start/receive/stop lifecycle handling.\n */\nexport declare function createTransport(provider: WireProvider, options?: CreateTransportOptions): TrUApiTransport;\n\n\n// generated/index.d.ts\n\n\n// generated/client.d.ts\nexport { ResultAsync, SubscriptionError };\nexport type { CallOptions, HostInitiatedSubscriptionHandler, ObservableLike, Observer, Result, Subscription, TrUApiTransport };\nexport declare const TRUAPI_VERSION: 2;\nexport declare const TRUAPI_CODEC_VERSION: 3;\nexport declare const TRUAPI_WIRE_SCHEMA_HASH: \"5e0d5318926dc17f\";\n/** Account lookup, aliasing, and proof generation. */\nexport declare class AccountClient {\n #private;\n constructor(transport: TrUApiTransport);\n /** Subscribe to account connection status changes. */\n connectionStatusSubscribe(): ObservableLike>;\n /** Retrieve a product-scoped account. */\n getAccount(request: T.HostAccountGetRequest, options?: CallOptions): ResultAsync>;\n /** Retrieve the contextual alias for a context and ring. */\n getAccountAlias(request: T.HostAccountGetAliasRequest, options?: CallOptions): ResultAsync>;\n /** Generate a ring VRF proof with an explicitly registered member key. */\n createAccountProof(request: T.HostAccountCreateProofRequest, options?: CallOptions): ResultAsync>;\n /**\n * Produce an sr25519 (schnorrkel) VRF signature from a product account.\n *\n * The host builds a Merlin transcript from `transcriptLabel` and `items`\n * and signs it with the account's key, returning the VRF pre-output and\n * proof. Authorized like signing: local when `AutoSigning` covers the\n * account, otherwise a per-call user confirmation.\n */\n signVrf(request: T.HostAccountSignVrfRequest, options?: CallOptions): ResultAsync>;\n /** Register a ring-VRF key owned by the calling product. */\n registerRingVrfKey(request: T.HostAccountRegisterRingVrfKeyRequest, options?: CallOptions): ResultAsync>;\n /** List registered ring-VRF keys owned by a product. */\n listRingVrfKeys(request: T.HostAccountListRingVrfKeysRequest, options?: CallOptions): ResultAsync, S.CallErrorValue>;\n /** Sign bytes directly with a registered ring-VRF member key. */\n ringVrfSign(request: T.HostAccountRingVrfSignRequest, options?: CallOptions): ResultAsync>;\n /**\n * Use a non-exportable Host Chat device for native cryptographic operations\n * and reviewed main-purse payments. The product owns native lifecycle frames,\n * subscriptions, delivery, retries, history, and acknowledgments.\n *\n * `Bind` resolves the peer independently. `Prepare` validates native plaintext\n * and returns signed ciphertext for product submission. `Open` authenticates\n * complete external statements and rejects reflected local output; it is not\n * an arbitrary decryption primitive. Incoming plaintext can contain incoming\n * bearer coin keys: persist the import intent securely and use generic payment\n * top-up before acknowledging. Wallet/device keys and outgoing main-purse\n * coin secrets never leave the Host.\n *\n * `Initialize` also advances private file transfers. Persist any legacy\n * migration view and ordinary prepared statements before `CommitMigration`.\n * `ContinueOpen` retrieves the next bounded page of an authenticated batch.\n * `ContinueState` retrieves remaining pages of a stable public state snapshot;\n * persist every page before committing its migration.\n *\n * Method 11 (the former raw-crypto interface) and method 12's former V1 actor\n * operations are retired, not forwarded. This boundary uses V2 payloads.\n */\n deviceChat(request: T.HostProductDeviceChatRequest, options?: CallOptions): ResultAsync>;\n /**\n * List non-product accounts the user owns.\n *\n * Current hosts do not expose non-product accounts, so the list is empty.\n */\n getLegacyAccounts(options?: CallOptions): ResultAsync>;\n /** Fetch the user's primary identity. */\n getUserId(options?: CallOptions): ResultAsync>;\n /**\n * Request the host to present the login flow to the user.\n *\n * Products should call this in response to a user action (e.g. tapping a\n * \"Sign in\" button), not automatically on load.\n */\n requestLogin(request: T.HostRequestLoginRequest, options?: CallOptions): ResultAsync>;\n}\n/** Chain interaction methods. */\nexport declare class ChainClient {\n #private;\n constructor(transport: TrUApiTransport);\n /** Follow the chain head and receive block events. */\n followHeadSubscribe({ request }: {\n request: T.RemoteChainHeadFollowRequest;\n }): ObservableLike>;\n /** Fetch a block header. */\n getHeadHeader(request: T.RemoteChainHeadHeaderRequest, options?: CallOptions): ResultAsync>;\n /** Fetch a block body. */\n getHeadBody(request: T.RemoteChainHeadBodyRequest, options?: CallOptions): ResultAsync>;\n /** Query runtime storage at a specific block. */\n getHeadStorage(request: T.RemoteChainHeadStorageRequest, options?: CallOptions): ResultAsync>;\n /** Invoke a runtime call at a specific block. */\n callHead(request: T.RemoteChainHeadCallRequest, options?: CallOptions): ResultAsync>;\n /** Release pinned blocks. */\n unpinHead(request: T.RemoteChainHeadUnpinRequest, options?: CallOptions): ResultAsync>;\n /** Continue a paused chain-head operation. */\n continueHead(request: T.RemoteChainHeadContinueRequest, options?: CallOptions): ResultAsync>;\n /** Stop a chain-head operation. */\n stopHeadOperation(request: T.RemoteChainHeadStopOperationRequest, options?: CallOptions): ResultAsync>;\n /** Fetch the canonical genesis hash for a chain. */\n getSpecGenesisHash(request: T.RemoteChainSpecGenesisHashRequest, options?: CallOptions): ResultAsync>;\n /** Fetch the display name of a chain. */\n getSpecChainName(request: T.RemoteChainSpecChainNameRequest, options?: CallOptions): ResultAsync>;\n /** Fetch the JSON-encoded properties of a chain. */\n getSpecProperties(request: T.RemoteChainSpecPropertiesRequest, options?: CallOptions): ResultAsync>;\n /** Broadcast a signed transaction. */\n broadcastTransaction(request: T.RemoteChainTransactionBroadcastRequest, options?: CallOptions): ResultAsync>;\n /** Stop a transaction broadcast. */\n stopTransaction(request: T.RemoteChainTransactionStopRequest, options?: CallOptions): ResultAsync>;\n /**\n * Resolve a chain identifier to its genesis hash against the host's\n * configured environment (RFC 0026).\n */\n getChainInfo(request: T.RemoteChainInfoRequest, options?: CallOptions): ResultAsync>;\n}\n/** Chat room, bot, and message APIs. */\nexport declare class ChatClient {\n #private;\n constructor(transport: TrUApiTransport);\n /** Create a chat room. */\n createRoom(request: T.HostChatCreateRoomRequest, options?: CallOptions): ResultAsync>;\n /** Register a chat bot. */\n registerBot(request: T.HostChatRegisterBotRequest, options?: CallOptions): ResultAsync>;\n /** Subscribe to the list of chat rooms. */\n listSubscribe(): ObservableLike>;\n /**\n * Post a message to a chat room.\n *\n * The host bounds and screens what it forwards. Message text is capped at\n * 16 KiB and keeps line breaks and tabs, but is rejected for other\n * control characters and for bidirectional overrides. Identifiers and\n * display names are normalized and screened. A message carries at most 32\n * actions and 32 media items, a custom payload at most 256 KiB, and a URL\n * at most 2 KiB which must be `https` or an inline raster image. A\n * rejection reports `MessageTooLarge` when the body or custom payload is\n * over budget, and `Unknown` with a reason naming the field otherwise.\n *\n * The returned `messageId` is the correlation key for any action the\n * message carries: a later `actionSubscribe` trigger names it.\n */\n postMessage(request: T.HostChatPostMessageRequest, options?: CallOptions): ResultAsync>;\n /** Subscribe to received chat actions. */\n actionSubscribe(): ObservableLike>;\n}\n/**\n * CoinPayment operations.\n *\n * RFC 0017 describes `Resolvable` values for long-running operations.\n * TrUAPI represents those as subscriptions whose items are the RFC status\n * updates.\n */\nexport declare class CoinPaymentClient {\n #private;\n constructor(transport: TrUApiTransport);\n /** Create a new firewalled CoinPayment purse. */\n createPurse(request: T.HostCoinPaymentCreatePurseRequest, options?: CallOptions): ResultAsync>;\n /** Query product-visible purse metadata and balance. */\n queryPurse(request: T.HostCoinPaymentQueryPurseRequest, options?: CallOptions): ResultAsync>;\n /** Transfer balance between local purses. */\n rebalancePurse({ request }: {\n request: T.HostCoinPaymentRebalancePurseRequest;\n }): ObservableLike>;\n /** Delete a purse after draining its balance into another local purse. */\n deletePurse({ request }: {\n request: T.HostCoinPaymentDeletePurseRequest;\n }): ObservableLike>;\n /** Create a receivable public key for depositing into a purse. */\n createReceivable(request: T.HostCoinPaymentCreateReceivableRequest, options?: CallOptions): ResultAsync>;\n /** Create a cheque paying from a local purse to a receivable. */\n createCheque(request: T.HostCoinPaymentCreateChequeRequest, options?: CallOptions): ResultAsync>;\n /** Claim coins from a cheque into the receivable's purse. */\n deposit({ request }: {\n request: T.HostCoinPaymentDepositRequest;\n }): ObservableLike>;\n /** Attempt to return coins associated with a receivable. */\n refund({ request }: {\n request: T.HostCoinPaymentRefundRequest;\n }): ObservableLike>;\n /** Listen for a cheque delivered through a standard transmission channel. */\n listenForPayment({ request }: {\n request: T.HostCoinPaymentListenForRequest;\n }): ObservableLike>;\n}\n/** Deterministic entropy derivation. */\nexport declare class EntropyClient {\n #private;\n constructor(transport: TrUApiTransport);\n /** Derive deterministic entropy. */\n derive(request: T.HostDeriveEntropyRequest, options?: CallOptions): ResultAsync>;\n}\n/** Local key/value storage scoped to the calling product. */\nexport declare class LocalStorageClient {\n #private;\n constructor(transport: TrUApiTransport);\n /** Read a value by key. */\n read(request: T.HostLocalStorageReadRequest, options?: CallOptions): ResultAsync>;\n /** Write a value to a key. */\n write(request: T.HostLocalStorageWriteRequest, options?: CallOptions): ResultAsync>;\n /** Clear a value by key. */\n clear(request: T.HostLocalStorageClearRequest, options?: CallOptions): ResultAsync>;\n /**\n * Subscribe to changes of one key in the product's own storage namespace.\n *\n * Emits the current value immediately, then one item per later write or\n * clear of the key by any of the product's runtimes. A write that leaves\n * the stored bytes unchanged emits nothing.\n */\n subscribe({ request }: {\n request: T.HostLocalStorageSubscribeRequest;\n }): ObservableLike>;\n}\n/** Host locale subscription. */\nexport declare class LocaleClient {\n #private;\n constructor(transport: TrUApiTransport);\n /** Subscribe to the host's selected locale. */\n subscribe(): ObservableLike>;\n}\n/** Notification methods for locally-rendered push notifications. */\nexport declare class NotificationsClient {\n #private;\n constructor(transport: TrUApiTransport);\n /**\n * Send a push notification to the user.\n *\n * Returns a [`NotificationId`](crate::v01::NotificationId) that can be\n * passed to [`cancel_push_notification`](Self::cancel_push_notification)\n * to retract a scheduled notification. When `scheduled_at` is set the host\n * persists the notification across restarts and fires it through the\n * platform-native scheduler. See [RFC 0019].\n *\n * [RFC 0019]: https://github.com/paritytech/host-rust-core/blob/main/docs/rfcs/0019-scheduled-notifications.md\n */\n sendPushNotification(request: T.HostPushNotificationRequest, options?: CallOptions): ResultAsync>;\n /**\n * Cancels a previously issued push notification.\n *\n * Cancellation is idempotent: returns `Ok(())` whether the notification is\n * still pending, already fired, or was never issued. See [RFC 0019].\n *\n * [RFC 0019]: https://github.com/paritytech/host-rust-core/blob/main/docs/rfcs/0019-scheduled-notifications.md\n */\n cancelPushNotification(request: T.HostPushNotificationCancelRequest, options?: CallOptions): ResultAsync>;\n}\n/** Payment request and balance/status subscription methods. */\nexport declare class PaymentClient {\n #private;\n constructor(transport: TrUApiTransport);\n /** Subscribe to payment balance updates. */\n balanceSubscribe({ request }: {\n request: T.HostPaymentBalanceSubscribeRequest;\n }): ObservableLike>;\n /** Request a payment from the user. */\n request(request: T.HostPaymentRequest, options?: CallOptions): ResultAsync>;\n /** Subscribe to payment lifecycle updates for a specific payment. */\n statusSubscribe({ request }: {\n request: T.HostPaymentStatusSubscribeRequest;\n }): ObservableLike>;\n /** Top up the user's payment balance. */\n topUp(request: T.HostPaymentTopUpRequest, options?: CallOptions): ResultAsync>;\n}\n/** Permission request methods. */\nexport declare class PermissionsClient {\n #private;\n constructor(transport: TrUApiTransport);\n /** Request a device-capability permission from the user. */\n requestDevicePermission(request: T.HostDevicePermissionRequest, options?: CallOptions): ResultAsync>;\n /**\n * Request a remote-operation permission.\n *\n * This example makes live requests to Frankfurter after permission is granted.\n */\n requestRemotePermission(request: T.RemotePermissionRequest, options?: CallOptions): ResultAsync>;\n}\n/**\n * Pocket cards backed by the calling product.\n *\n * The host owns the collection: a product observes its own cards and may\n * remove them, but cannot add one.\n */\nexport declare class PocketClient {\n #private;\n constructor(transport: TrUApiTransport);\n /**\n * Subscribe to the calling product's cards.\n *\n * Emits the whole set on subscribe and again after every change.\n */\n listSubscribe(): ObservableLike>;\n /**\n * Remove one of the calling product's cards.\n *\n * Removing a card that is not present succeeds. A privileged card is\n * refused with `Privileged`.\n */\n removeCard(request: T.HostPocketRemoveCardRequest, options?: CallOptions): ResultAsync>;\n}\n/** Preimage lookup and submission methods. */\nexport declare class PreimageClient {\n #private;\n constructor(transport: TrUApiTransport);\n /** Subscribe to preimage lookups for a given key. */\n lookupSubscribe({ request }: {\n request: T.RemotePreimageLookupSubscribeRequest;\n }): ObservableLike>;\n /** Submit a preimage. Returns the preimage key (hash) on success. */\n submit(request: HexString, options?: CallOptions): ResultAsync>;\n}\n/**\n * Profiles shown in host-owned UI.\n *\n * The product hands over an opaque reference; the host resolves, decrypts and\n * renders it. Profile bytes never return to the product.\n */\nexport declare class ProfileClient {\n #private;\n constructor(transport: TrUApiTransport);\n /**\n * Show the referenced profile in host-owned UI.\n *\n * Resolves once the host has taken the presentation, not when the user\n * dismisses it. Loading and fetch failures are shown to the user, not\n * returned; a reference this host cannot parse is `InvalidReference`.\n */\n present(request: T.HostProfilePresentRequest, options?: CallOptions): ResultAsync>;\n /**\n * Give the user's chat contacts this reference to their profile.\n *\n * The host stores it as the user's own and relays it to each contact,\n * replacing whatever it sent before; the product never learns who they\n * are. App executions only. A reference this core cannot screen is\n * `InvalidReference`.\n */\n disclose(request: T.HostProfileDiscloseRequest, options?: CallOptions): ResultAsync>;\n /**\n * Withdraw the reference this product disclosed. Contacts are told to\n * drop what they hold. A product that did not disclose it is refused.\n */\n retract(options?: CallOptions): ResultAsync>;\n /**\n * Show a chat contact's profile in host-owned UI.\n *\n * The product names the contact; the host looks up the reference that\n * contact shared and presents it as `present` would. The reference never\n * reaches the product. A contact who shared nothing is `NotShared`.\n */\n presentContact(request: T.HostProfilePresentContactRequest, options?: CallOptions): ResultAsync>;\n}\n/** Product-rendered bodies and the actions triggered inside them. */\nexport declare class RendererClient {\n #private;\n constructor(transport: TrUApiTransport);\n /**\n * Streams renderer trees for one product-rendered body. Each item\n * replaces the previous tree. The stream stays open while the body is\n * displayed so the product can redraw in place.\n */\n onRender(handler: HostInitiatedSubscriptionHandler>): {\n unsubscribe(): void;\n };\n /** Subscribe to actions triggered inside this product's rendered bodies. */\n actionSubscribe(): ObservableLike>;\n}\n/** Resource pre-allocation (allowance management). */\nexport declare class ResourceAllocationClient {\n #private;\n constructor(transport: TrUApiTransport);\n /** Request the host to pre-allocate one or more resources. */\n request(request: T.HostRequestResourceAllocationRequest, options?: CallOptions): ResultAsync>;\n}\n/** Signing operations. */\nexport declare class SigningClient {\n #private;\n constructor(transport: TrUApiTransport);\n /**\n * Construct a transaction for a product account.\n *\n * Served locally without a user confirmation when an RFC-0010 `AutoSigning`\n * grant covers the account; otherwise each call is confirmed by the user.\n *\n * Under Extrinsic V5, omitting `VerifyMultiSignature` from `extensions`\n * lets the host sign with the signer's key. Listing it \u2014 as `Disabled`,\n * with a proof in a later extension \u2014 encodes the given bytes verbatim and\n * returns an unsigned transaction.\n */\n createTransaction(request: T.ProductAccountTxPayload, options?: CallOptions): ResultAsync>;\n /**\n * Construct a transaction for a non-product (legacy) account.\n *\n * The V5 `VerifyMultiSignature` rule is the same as\n * [`Signing::create_transaction`]: omit it and the host signs, list it and\n * the given bytes are used with no host signature.\n */\n createTransactionWithLegacyAccount(request: T.LegacyAccountTxPayload, options?: CallOptions): ResultAsync>;\n /** Sign raw bytes with a non-product account. */\n signRawWithLegacyAccount(request: T.HostSignRawWithLegacyAccountRequest, options?: CallOptions): ResultAsync>;\n /** Sign an extrinsic payload with a non-product account. */\n signPayloadWithLegacyAccount(request: T.HostSignPayloadWithLegacyAccountRequest, options?: CallOptions): ResultAsync>;\n /**\n * Sign raw bytes or a message.\n *\n * Served locally without a user confirmation when an RFC-0010 `AutoSigning`\n * grant covers the account; otherwise each call is confirmed by the user.\n */\n signRaw(request: T.HostSignRawRequest, options?: CallOptions): ResultAsync>;\n /**\n * Sign an extrinsic payload.\n *\n * Served locally without a user confirmation when an RFC-0010 `AutoSigning`\n * grant covers the account; otherwise each call is confirmed by the user.\n */\n signPayload(request: T.HostSignPayloadRequest, options?: CallOptions): ResultAsync>;\n /**\n * Sign the supplied data without adding or removing a watermark.\n *\n * Temporary compatibility API for runtime ownership proofs, including the\n * 32-byte Resources alias used by Humanity. Payload decoding matches\n * watermarked signing, but the decoded bytes are signed exactly as supplied.\n * This permits transaction-shaped data and requires signing authorization\n * and explicit user confirmation.\n *\n * @deprecated Temporary unwatermarked signing; migrate to watermarked signing when the runtime supports it. This API will be removed. See \n */\n signRawUnwatermarkedDeprecated(request: T.HostSignRawRequest, options?: CallOptions): ResultAsync>;\n /**\n * Sign the supplied data without adding or removing a watermark.\n *\n * Temporary compatibility API for runtime ownership proofs, including the\n * 32-byte Resources alias used by Humanity. Payload decoding matches\n * watermarked signing, but the decoded bytes are signed exactly as supplied.\n * This permits transaction-shaped data and requires signing authorization\n * and explicit user confirmation.\n *\n * @deprecated Temporary unwatermarked signing; migrate to watermarked signing when the runtime supports it. This API will be removed. See \n */\n signRawUnwatermarkedDeprecatedWithLegacyAccount(request: T.HostSignRawWithLegacyAccountRequest, options?: CallOptions): ResultAsync>;\n}\n/** Statement store methods. */\nexport declare class StatementStoreClient {\n #private;\n constructor(transport: TrUApiTransport);\n /** Subscribe to statements matching a topic filter. */\n subscribe({ request }: {\n request: T.RemoteStatementStoreSubscribeRequest;\n }): ObservableLike>;\n /**\n * Create a proof for a statement.\n *\n * **Deprecated:** use [`create_proof_authorized`](Self::create_proof_authorized)\n * instead, which uses a pre-allocated allowance account and does not\n * require a per-call signing prompt. Pairing hosts may reject this method\n * when their signing channel cannot sign statement proof payloads exactly.\n */\n createProof(request: T.RemoteStatementStoreCreateProofRequest, options?: CallOptions): ResultAsync>;\n /**\n * Create a proof for a statement using a pre-allocated allowance account,\n * bypassing the per-call signing prompt.\n */\n createProofAuthorized(request: T.Statement, options?: CallOptions): ResultAsync>;\n /**\n * Submit a signed statement to the network. The request body is the\n * [`SignedStatement`](crate::v01::SignedStatement) directly (no wrapping\n * struct), matching upstream `triangle-js-sdks`.\n */\n submit(request: T.SignedStatement, options?: CallOptions): ResultAsync>;\n}\n/**\n * General-purpose TrUAPI methods for handshake, feature detection,\n * navigation, and runtime information.\n */\nexport declare class SystemClient {\n #private;\n constructor(transport: TrUApiTransport);\n /** Negotiate the wire codec version with the product. */\n handshake(options?: CallOptions): ResultAsync>;\n /** Query whether the host supports a specific feature. */\n featureSupported(request: T.HostFeatureSupportedRequest, options?: CallOptions): ResultAsync>;\n /**\n * Request the host to open a URL.\n *\n * An `http` or `https` URL outside the ecosystem needs a\n * `RemotePermission::Remote` grant for the target host, and prompts for one\n * on first use. dotNS names, `localhost`, and the app-handoff schemes\n * (`mailto:`, `tel:`, `polkadot:`, `dot:`) consume no grant. The grant is\n * per host and shared with outbound data access to that host, so approving\n * one covers the other.\n */\n navigateTo(request: T.HostNavigateToRequest, options?: CallOptions): ResultAsync>;\n /**\n * Report the host's identity and version.\n *\n * Returns the host's platform, name, and version so a product knows\n * exactly which host \u2014 and which build of it \u2014 is running it: for\n * adapting to the host, telemetry, and attributing behaviour to a\n * concrete build in diagnostics and bug reports.\n */\n info(options?: CallOptions): ResultAsync>;\n /** Return the product context bound to the current host runtime. */\n getProductContext(options?: CallOptions): ResultAsync>;\n}\n/** Host theme subscription. */\nexport declare class ThemeClient {\n #private;\n constructor(transport: TrUApiTransport);\n /** Subscribe to host theme changes. */\n subscribe(): ObservableLike>;\n}\n/**\n * Worker background-operation APIs.\n *\n * The host keeps a product's worker running while it holds at least one open\n * operation, which is how a worker outlives the surface that started it.\n */\nexport declare class WorkerClient {\n #private;\n constructor(transport: TrUApiTransport);\n /** Begin a pending operation. */\n beginOperation(request: T.HostWorkerBeginOperationRequest, options?: CallOptions): ResultAsync>;\n /**\n * End a pending operation. Idempotent: an unknown or already-ended id\n * succeeds, so a retry after an ambiguous failure is safe.\n */\n endOperation(request: T.HostWorkerEndOperationRequest, options?: CallOptions): ResultAsync>;\n}\nexport interface TrUApiClient {\n readonly account: AccountClient;\n readonly chain: ChainClient;\n readonly chat: ChatClient;\n readonly coinPayment: CoinPaymentClient;\n readonly entropy: EntropyClient;\n readonly localStorage: LocalStorageClient;\n readonly locale: LocaleClient;\n readonly notifications: NotificationsClient;\n readonly payment: PaymentClient;\n readonly permissions: PermissionsClient;\n readonly pocket: PocketClient;\n readonly preimage: PreimageClient;\n readonly profile: ProfileClient;\n readonly renderer: RendererClient;\n readonly resourceAllocation: ResourceAllocationClient;\n readonly signing: SigningClient;\n readonly statementStore: StatementStoreClient;\n readonly system: SystemClient;\n readonly theme: ThemeClient;\n readonly worker: WorkerClient;\n}\nexport type Client = TrUApiClient;\n/** Creates the generated client facade by binding each service namespace to the\n * shared transport instance. */\nexport declare function createClient(transport: TrUApiTransport): TrUApiClient;\n\n\n// development.d.ts\n/** Same as `HostAccountCreateProofRequest`, with the 32-byte context given raw. */\nexport interface DevelopmentCreateProofRequest extends Omit {\n /** The exact 32 bytes the proof is bound to, as `0x`-prefixed hex. */\n context: HexString;\n}\n/**\n * `account.createAccountProof` with a verbatim 32-byte proof context instead of\n * a product-namespaced one.\n *\n */\nexport declare function development_createAccountProof(client: Pick, request: DevelopmentCreateProofRequest): ResultAsync>;\n"; diff --git a/vendor/truapi/dist/playground/codegen/truapi-dts.js b/vendor/truapi/dist/playground/codegen/truapi-dts.js index ecfc5c1e0..c47ab1bd9 100644 --- a/vendor/truapi/dist/playground/codegen/truapi-dts.js +++ b/vendor/truapi/dist/playground/codegen/truapi-dts.js @@ -2433,6 +2433,54 @@ export type VersionedHostProductDeviceChatResponse = value: HostProductDeviceChatResponse; }; export const VersionedHostProductDeviceChatResponse: Codec; +/** Versioned envelope for [\`HostProfileDiscloseError\`]. */ +export type VersionedHostProfileDiscloseError = +/** Version 1 payload. */ +{ + tag: "V1"; + value: HostProfileDiscloseError; +}; +export const VersionedHostProfileDiscloseError: Codec; +/** Versioned envelope for [\`HostProfileDiscloseRequest\`]. */ +export type VersionedHostProfileDiscloseRequest = +/** Version 1 payload. */ +{ + tag: "V1"; + value: HostProfileDiscloseRequest; +}; +export const VersionedHostProfileDiscloseRequest: Codec; +/** Versioned envelope for [\`HostProfileDiscloseResponse\`]. */ +export type VersionedHostProfileDiscloseResponse = +/** Version 1 (no payload). */ +{ + tag: "V1"; + value?: undefined; +}; +export const VersionedHostProfileDiscloseResponse: Codec; +/** Versioned envelope for [\`HostProfilePresentContactError\`]. */ +export type VersionedHostProfilePresentContactError = +/** Version 1 payload. */ +{ + tag: "V1"; + value: HostProfilePresentContactError; +}; +export const VersionedHostProfilePresentContactError: Codec; +/** Versioned envelope for [\`HostProfilePresentContactRequest\`]. */ +export type VersionedHostProfilePresentContactRequest = +/** Version 1 payload. */ +{ + tag: "V1"; + value: HostProfilePresentContactRequest; +}; +export const VersionedHostProfilePresentContactRequest: Codec; +/** Versioned envelope for [\`HostProfilePresentContactResponse\`]. */ +export type VersionedHostProfilePresentContactResponse = +/** Version 1 (no payload). */ +{ + tag: "V1"; + value?: undefined; +}; +export const VersionedHostProfilePresentContactResponse: Codec; /** Versioned envelope for [\`HostProfilePresentError\`]. */ export type VersionedHostProfilePresentError = /** Version 1 payload. */ @@ -2457,6 +2505,30 @@ export type VersionedHostProfilePresentResponse = value?: undefined; }; export const VersionedHostProfilePresentResponse: Codec; +/** Versioned envelope for [\`HostProfileRetractError\`]. */ +export type VersionedHostProfileRetractError = +/** Version 1 payload. */ +{ + tag: "V1"; + value: HostProfileRetractError; +}; +export const VersionedHostProfileRetractError: Codec; +/** Versioned envelope for [\`HostProfileRetractRequest\`]. */ +export type VersionedHostProfileRetractRequest = +/** Version 1 (no payload). */ +{ + tag: "V1"; + value?: undefined; +}; +export const VersionedHostProfileRetractRequest: Codec; +/** Versioned envelope for [\`HostProfileRetractResponse\`]. */ +export type VersionedHostProfileRetractResponse = +/** Version 1 (no payload). */ +{ + tag: "V1"; + value?: undefined; +}; +export const VersionedHostProfileRetractResponse: Codec; /** Versioned envelope for [\`HostPushNotificationCancelError\`]. */ export type VersionedHostPushNotificationCancelError = /** Version 1 payload. */ @@ -5008,6 +5080,64 @@ export interface HostPocketRemoveCardRequest { cardId: string; } export const HostPocketRemoveCardRequest: Codec; +/** Profile disclosure failure. */ +export type HostProfileDiscloseError = +/** The reference is empty, too long, or not printable ASCII. */ +{ + tag: "InvalidReference"; + value?: undefined; +} +/** Catch-all. */ + | { + tag: "Unknown"; + value: { + reason: string; + }; +}; +export const HostProfileDiscloseError: Codec; +/** + * Request to give the user's chat contacts a profile reference. + * + * The reference is a bearer capability for everyone the host relays it to. + * The host stores it as the user's own and never parses it. + */ +export interface HostProfileDiscloseRequest { + /** Opaque profile reference, e.g. a Seity contacts reference. */ + reference: string; +} +export const HostProfileDiscloseRequest: Codec; +/** Contact profile presentation failure. */ +export type HostProfilePresentContactError = +/** This contact has not shared a profile with the user. */ +{ + tag: "NotShared"; + value?: undefined; +} +/** The host holds a reference it cannot parse. */ + | { + tag: "InvalidReference"; + value?: undefined; +} +/** Catch-all. */ + | { + tag: "Unknown"; + value: { + reason: string; + }; +}; +export const HostProfilePresentContactError: Codec; +/** + * Request to show a chat contact's profile in host-owned UI. + * + * The product names the contact, never a reference: the host looks up the + * reference that contact's host sent, so the product cannot read, keep or + * substitute it. + */ +export interface HostProfilePresentContactRequest { + /** The contact's authenticated root identity, as the chat API names it. */ + peerIdentity: HexString; +} +export const HostProfilePresentContactRequest: Codec; /** Profile presentation failure. */ export type HostProfilePresentError = /** The reference is malformed or names a format this host cannot open. */ @@ -5035,6 +5165,21 @@ export interface HostProfilePresentRequest { reference: string; } export const HostProfilePresentRequest: Codec; +/** Profile retraction failure. */ +export type HostProfileRetractError = +/** Another product disclosed the reference the host holds. */ +{ + tag: "NotDiscloser"; + value?: undefined; +} +/** Catch-all. */ + | { + tag: "Unknown"; + value: { + reason: string; + }; +}; +export const HostProfileRetractError: Codec; /** Request to cancel a previously scheduled notification. */ export interface HostPushNotificationCancelRequest { /** The notification identifier returned by [\`HostPushNotificationResponse\`]. */ @@ -6129,9 +6274,18 @@ export import VersionedHostPocketRemoveCardResponse = T.VersionedHostPocketRemov export import VersionedHostProductDeviceChatError = T.VersionedHostProductDeviceChatError; export import VersionedHostProductDeviceChatRequest = T.VersionedHostProductDeviceChatRequest; export import VersionedHostProductDeviceChatResponse = T.VersionedHostProductDeviceChatResponse; +export import VersionedHostProfileDiscloseError = T.VersionedHostProfileDiscloseError; +export import VersionedHostProfileDiscloseRequest = T.VersionedHostProfileDiscloseRequest; +export import VersionedHostProfileDiscloseResponse = T.VersionedHostProfileDiscloseResponse; +export import VersionedHostProfilePresentContactError = T.VersionedHostProfilePresentContactError; +export import VersionedHostProfilePresentContactRequest = T.VersionedHostProfilePresentContactRequest; +export import VersionedHostProfilePresentContactResponse = T.VersionedHostProfilePresentContactResponse; export import VersionedHostProfilePresentError = T.VersionedHostProfilePresentError; export import VersionedHostProfilePresentRequest = T.VersionedHostProfilePresentRequest; export import VersionedHostProfilePresentResponse = T.VersionedHostProfilePresentResponse; +export import VersionedHostProfileRetractError = T.VersionedHostProfileRetractError; +export import VersionedHostProfileRetractRequest = T.VersionedHostProfileRetractRequest; +export import VersionedHostProfileRetractResponse = T.VersionedHostProfileRetractResponse; export import VersionedHostPushNotificationCancelError = T.VersionedHostPushNotificationCancelError; export import VersionedHostPushNotificationCancelRequest = T.VersionedHostPushNotificationCancelRequest; export import VersionedHostPushNotificationCancelResponse = T.VersionedHostPushNotificationCancelResponse; @@ -6363,8 +6517,13 @@ export import HostPaymentTopUpRequest = T.HostPaymentTopUpRequest; export import HostPocketListSubscribeItem = T.HostPocketListSubscribeItem; export import HostPocketRemoveCardError = T.HostPocketRemoveCardError; export import HostPocketRemoveCardRequest = T.HostPocketRemoveCardRequest; +export import HostProfileDiscloseError = T.HostProfileDiscloseError; +export import HostProfileDiscloseRequest = T.HostProfileDiscloseRequest; +export import HostProfilePresentContactError = T.HostProfilePresentContactError; +export import HostProfilePresentContactRequest = T.HostProfilePresentContactRequest; export import HostProfilePresentError = T.HostProfilePresentError; export import HostProfilePresentRequest = T.HostProfilePresentRequest; +export import HostProfileRetractError = T.HostProfileRetractError; export import HostPushNotificationCancelRequest = T.HostPushNotificationCancelRequest; export import HostPushNotificationError = T.HostPushNotificationError; export import HostPushNotificationRequest = T.HostPushNotificationRequest; @@ -6884,7 +7043,7 @@ export { ResultAsync, SubscriptionError }; export type { CallOptions, HostInitiatedSubscriptionHandler, ObservableLike, Observer, Result, Subscription, TrUApiTransport }; export declare const TRUAPI_VERSION: 2; export declare const TRUAPI_CODEC_VERSION: 3; -export declare const TRUAPI_WIRE_SCHEMA_HASH: "c8972ad11436a788"; +export declare const TRUAPI_WIRE_SCHEMA_HASH: "5e0d5318926dc17f"; /** Account lookup, aliasing, and proof generation. */ export declare class AccountClient { #private; @@ -7199,6 +7358,28 @@ export declare class ProfileClient { * returned; a reference this host cannot parse is \`InvalidReference\`. */ present(request: T.HostProfilePresentRequest, options?: CallOptions): ResultAsync>; + /** + * Give the user's chat contacts this reference to their profile. + * + * The host stores it as the user's own and relays it to each contact, + * replacing whatever it sent before; the product never learns who they + * are. App executions only. A reference this core cannot screen is + * \`InvalidReference\`. + */ + disclose(request: T.HostProfileDiscloseRequest, options?: CallOptions): ResultAsync>; + /** + * Withdraw the reference this product disclosed. Contacts are told to + * drop what they hold. A product that did not disclose it is refused. + */ + retract(options?: CallOptions): ResultAsync>; + /** + * Show a chat contact's profile in host-owned UI. + * + * The product names the contact; the host looks up the reference that + * contact shared and presents it as \`present\` would. The reference never + * reaches the product. A contact who shared nothing is \`NotShared\`. + */ + presentContact(request: T.HostProfilePresentContactRequest, options?: CallOptions): ResultAsync>; } /** Product-rendered bodies and the actions triggered inside them. */ export declare class RendererClient {