@parity/truapi 0.1.0 → 0.3.0

package/dist/playground/codegen/services.js

@@ -5,48 +5,79 @@ export const services = [
             {
                 name: "connection_status_subscribe",
                 type: "subscription",
+                signature: "connectionStatusSubscribe(): ObservableLike<HostAccountConnectionStatusSubscribeItem>",
+                docUrl: "api/account/trait.Account.html#method.connection_status_subscribe",
                 description: "Subscribe to account connection status changes.",
-                noParams: true,
+                exampleSource: 'import { from, take } from "rxjs";\n\nfrom(truapi.account.connectionStatusSubscribe())\n  .pipe(take(1))\n  .subscribe({\n    next: (status) => console.log(status),\n    error: (error) => console.error(error),\n    complete: () => console.log("completed"),\n  });',
+                responseType: "host-account-connection-status-subscribe-item",
             },
             {
                 name: "get_account",
                 type: "unary",
+                signature: "getAccount(request: HostAccountGetRequest): Promise<Result<HostAccountGetResponse, HostAccountGetError>>",
+                docUrl: "api/account/trait.Account.html#method.get_account",
                 description: "Retrieve a product-scoped account.",
                 requestDescription: "HostAccountGetRequest",
-                defaultRequest: '{\n  "productAccountId": {\n    "derivationIndex": 0,\n    "dotNsIdentifier": "truapi-playground.dot"\n  }\n}',
+                exampleSource: 'const result = await truapi.account.getAccount({\n  productAccountId: {\n    dotNsIdentifier: "truapi-playground.dot",\n    derivationIndex: 0,\n  },\n});\nresult.match(\n  (value) => console.log(value),\n  (error) => console.error(error),\n);',
+                requestType: "host-account-get-request",
+                responseType: "host-account-get-response",
+                errorType: "host-account-get-error",
             },
             {
                 name: "get_account_alias",
                 type: "unary",
+                signature: "getAccountAlias(request: HostAccountGetAliasRequest): Promise<Result<HostAccountGetAliasResponse, HostAccountGetError>>",
+                docUrl: "api/account/trait.Account.html#method.get_account_alias",
                 description: "Retrieve a contextual alias for a product account.",
                 requestDescription: "HostAccountGetAliasRequest",
-                defaultRequest: '{\n  "productAccountId": {\n    "derivationIndex": 0,\n    "dotNsIdentifier": "truapi-playground.dot"\n  }\n}',
+                exampleSource: 'const result = await truapi.account.getAccountAlias({\n  productAccountId: {\n    dotNsIdentifier: "truapi-playground.dot",\n    derivationIndex: 0,\n  },\n});\nresult.match(\n  (value) => console.log(value),\n  (error) => console.error(error),\n);',
+                requestType: "host-account-get-alias-request",
+                responseType: "host-account-get-alias-response",
+                errorType: "host-account-get-error",
             },
             {
                 name: "create_account_proof",
                 type: "unary",
+                signature: "createAccountProof(request: HostAccountCreateProofRequest): Promise<Result<HostAccountCreateProofResponse, HostAccountCreateProofError>>",
+                docUrl: "api/account/trait.Account.html#method.create_account_proof",
                 description: "Generate a ring VRF proof for a product account.",
                 requestDescription: "HostAccountCreateProofRequest",
-                defaultRequest: '{\n  "context": "0x",\n  "productAccountId": {\n    "derivationIndex": 0,\n    "dotNsIdentifier": "truapi-playground.dot"\n  },\n  "ringLocation": {\n    "genesisHash": "0xd6eec26135305a8ad257a20d003357284c8aa03d0bdb2b357ab0a22371e11ef2",\n    "hints": {\n      "palletInstance": 42\n    },\n    "ringRootHash": "0xd6eec26135305a8ad257a20d003357284c8aa03d0bdb2b357ab0a22371e11ef2"\n  }\n}',
+                exampleSource: 'import { PASEO_NEXT_V2_ASSET_HUB } from "@parity/truapi";\n\nconst result = await truapi.account.createAccountProof({\n  productAccountId: {\n    dotNsIdentifier: "truapi-playground.dot",\n    derivationIndex: 0,\n  },\n  ringLocation: {\n    genesisHash: PASEO_NEXT_V2_ASSET_HUB.genesis,\n    ringRootHash: "0xd6eec26135305a8ad257a20d003357284c8aa03d0bdb2b357ab0a22371e11ef2",\n    hints: { palletInstance: 42 },\n  },\n  context: "0x",\n});\nresult.match(\n  (value) => console.log(value),\n  (error) => console.error(error),\n);',
+                requestType: "host-account-create-proof-request",
+                responseType: "host-account-create-proof-response",
+                errorType: "host-account-create-proof-error",
             },
             {
                 name: "get_legacy_accounts",
                 type: "unary",
+                signature: "getLegacyAccounts(): Promise<Result<HostGetLegacyAccountsResponse, HostAccountGetError>>",
+                docUrl: "api/account/trait.Account.html#method.get_legacy_accounts",
                 description: "List non-product accounts the user owns.",
-                noParams: true,
+                exampleSource: "const result = await truapi.account.getLegacyAccounts();\nresult.match(\n  (value) => console.log(value),\n  (error) => console.error(error),\n);",
+                responseType: "host-get-legacy-accounts-response",
+                errorType: "host-account-get-error",
             },
             {
                 name: "get_user_id",
                 type: "unary",
+                signature: "getUserId(): Promise<Result<HostGetUserIdResponse, HostGetUserIdError>>",
+                docUrl: "api/account/trait.Account.html#method.get_user_id",
                 description: "Fetch the user's primary identity.",
-                noParams: true,
+                exampleSource: "const result = await truapi.account.getUserId();\nresult.match(\n  (value) => console.log(value),\n  (error) => console.error(error),\n);",
+                responseType: "host-get-user-id-response",
+                errorType: "host-get-user-id-error",
             },
             {
                 name: "request_login",
                 type: "unary",
+                signature: "requestLogin(request: HostRequestLoginRequest): Promise<Result<HostRequestLoginResponse, HostRequestLoginError>>",
+                docUrl: "api/account/trait.Account.html#method.request_login",
                 description: 'Request the host to present the login flow to the user.\n\nProducts should call this in response to a user action (e.g. tapping a\n"Sign in" button), not automatically on load.',
                 requestDescription: "HostRequestLoginRequest",
-                defaultRequest: '{\n  "reason": "Sign in to vote on Referendum #42"\n}',
+                exampleSource: 'const result = await truapi.account.requestLogin({\n  reason: "Sign in to vote on Referendum #42",\n});\nresult.match(\n  (value) => console.log(value),\n  (error) => console.error(error),\n);',
+                requestType: "host-request-login-request",
+                responseType: "host-request-login-response",
+                errorType: "host-request-login-error",
             },
         ],
     },
@@ -56,93 +87,153 @@ export const services = [
             {
                 name: "follow_head_subscribe",
                 type: "subscription",
+                signature: "followHeadSubscribe(request: RemoteChainHeadFollowRequest): ObservableLike<RemoteChainHeadFollowItem>",
+                docUrl: "api/chain/trait.Chain.html#method.follow_head_subscribe",
                 description: "Follow the chain head and receive block events.",
                 requestDescription: "RemoteChainHeadFollowRequest",
-                defaultRequest: '{\n  "genesisHash": "0xd6eec26135305a8ad257a20d003357284c8aa03d0bdb2b357ab0a22371e11ef2",\n  "withRuntime": false\n}',
+                exampleSource: 'import { PASEO_NEXT_V2_ASSET_HUB } from "@parity/truapi";\n\nimport { from, take } from "rxjs";\n\nfrom(\n  truapi.chain.followHeadSubscribe({\n    request: {\n      genesisHash: PASEO_NEXT_V2_ASSET_HUB.genesis,\n      withRuntime: false,\n    },\n  }),\n)\n  .pipe(take(3))\n  .subscribe({\n    next: (item) => console.log(item),\n    error: (error) => console.error(error),\n    complete: () => console.log("completed"),\n  });',
+                requestType: "remote-chain-head-follow-request",
+                responseType: "remote-chain-head-follow-item",
             },
             {
                 name: "get_head_header",
                 type: "unary",
+                signature: "getHeadHeader(request: RemoteChainHeadHeaderRequest): Promise<Result<RemoteChainHeadHeaderResponse, GenericError>>",
+                docUrl: "api/chain/trait.Chain.html#method.get_head_header",
                 description: "Fetch a block header.",
                 requestDescription: "RemoteChainHeadHeaderRequest",
-                defaultRequest: '{\n  "followSubscriptionId": "",\n  "genesisHash": "0xd6eec26135305a8ad257a20d003357284c8aa03d0bdb2b357ab0a22371e11ef2",\n  "hash": "0x0000000000000000000000000000000000000000000000000000000000000000"\n}',
+                exampleSource: 'import { PASEO_NEXT_V2_ASSET_HUB } from "@parity/truapi";\n\nimport { firstValueFrom, mergeMap } from "rxjs";\n\nconst result = await firstValueFrom(\n  withChainHeadFollow({\n    genesisHash: PASEO_NEXT_V2_ASSET_HUB.genesis,\n  }).pipe(\n    mergeMap(({ genesisHash, followSubscriptionId, hash }) =>\n      truapi.chain.getHeadHeader({ genesisHash, followSubscriptionId, hash }),\n    ),\n  ),\n);\nresult.match(\n  (value) => console.log(value),\n  (error) => console.error(error),\n);',
+                requestType: "remote-chain-head-header-request",
+                responseType: "remote-chain-head-header-response",
+                errorType: "generic-error",
             },
             {
                 name: "get_head_body",
                 type: "unary",
+                signature: "getHeadBody(request: RemoteChainHeadBodyRequest): Promise<Result<RemoteChainHeadBodyResponse, GenericError>>",
+                docUrl: "api/chain/trait.Chain.html#method.get_head_body",
                 description: "Fetch a block body.",
                 requestDescription: "RemoteChainHeadBodyRequest",
-                defaultRequest: '{\n  "followSubscriptionId": "",\n  "genesisHash": "0xd6eec26135305a8ad257a20d003357284c8aa03d0bdb2b357ab0a22371e11ef2",\n  "hash": "0x0000000000000000000000000000000000000000000000000000000000000000"\n}',
+                exampleSource: 'import { PASEO_NEXT_V2_ASSET_HUB } from "@parity/truapi";\n\nimport { firstValueFrom, mergeMap } from "rxjs";\n\nconst result = await firstValueFrom(\n  withChainHeadFollow({\n    genesisHash: PASEO_NEXT_V2_ASSET_HUB.genesis,\n  }).pipe(\n    mergeMap(({ genesisHash, followSubscriptionId, hash }) =>\n      truapi.chain.getHeadBody({ genesisHash, followSubscriptionId, hash }),\n    ),\n  ),\n);\nresult.match(\n  (value) => console.log(value),\n  (error) => console.error(error),\n);',
+                requestType: "remote-chain-head-body-request",
+                responseType: "remote-chain-head-body-response",
+                errorType: "generic-error",
             },
             {
                 name: "get_head_storage",
                 type: "unary",
+                signature: "getHeadStorage(request: RemoteChainHeadStorageRequest): Promise<Result<RemoteChainHeadStorageResponse, GenericError>>",
+                docUrl: "api/chain/trait.Chain.html#method.get_head_storage",
                 description: "Query runtime storage at a specific block.",
                 requestDescription: "RemoteChainHeadStorageRequest",
-                defaultRequest: '{\n  "followSubscriptionId": "",\n  "genesisHash": "0xd6eec26135305a8ad257a20d003357284c8aa03d0bdb2b357ab0a22371e11ef2",\n  "hash": "0x0000000000000000000000000000000000000000000000000000000000000000",\n  "items": [\n    {\n      "key": "0x26aa394eea5630e07c48ae0c9558cef7",\n      "queryType": "Value"\n    }\n  ]\n}',
+                exampleSource: 'import { PASEO_NEXT_V2_ASSET_HUB } from "@parity/truapi";\n\nimport { firstValueFrom, mergeMap } from "rxjs";\n\nconst result = await firstValueFrom(\n  withChainHeadFollow({\n    genesisHash: PASEO_NEXT_V2_ASSET_HUB.genesis,\n  }).pipe(\n    mergeMap(({ genesisHash, followSubscriptionId, hash }) =>\n      truapi.chain.getHeadStorage({\n        genesisHash,\n        followSubscriptionId,\n        hash,\n        items: [{ key: "0x26aa394eea5630e07c48ae0c9558cef7", queryType: "Value" }],\n      }),\n    ),\n  ),\n);\nresult.match(\n  (value) => console.log(value),\n  (error) => console.error(error),\n);',
+                requestType: "remote-chain-head-storage-request",
+                responseType: "remote-chain-head-storage-response",
+                errorType: "generic-error",
             },
             {
                 name: "call_head",
                 type: "unary",
+                signature: "callHead(request: RemoteChainHeadCallRequest): Promise<Result<RemoteChainHeadCallResponse, GenericError>>",
+                docUrl: "api/chain/trait.Chain.html#method.call_head",
                 description: "Invoke a runtime call at a specific block.",
                 requestDescription: "RemoteChainHeadCallRequest",
-                defaultRequest: '{\n  "callParameters": "0x",\n  "followSubscriptionId": "",\n  "function": "Core_version",\n  "genesisHash": "0xd6eec26135305a8ad257a20d003357284c8aa03d0bdb2b357ab0a22371e11ef2",\n  "hash": "0x0000000000000000000000000000000000000000000000000000000000000000"\n}',
+                exampleSource: 'import { PASEO_NEXT_V2_ASSET_HUB } from "@parity/truapi";\n\nimport { firstValueFrom, mergeMap } from "rxjs";\n\nconst result = await firstValueFrom(\n  withChainHeadFollow({\n    genesisHash: PASEO_NEXT_V2_ASSET_HUB.genesis,\n    withRuntime: true,\n  }).pipe(\n    mergeMap(({ genesisHash, followSubscriptionId, hash }) =>\n      truapi.chain.callHead({\n        genesisHash,\n        followSubscriptionId,\n        hash,\n        function: "Core_version",\n        callParameters: "0x",\n      }),\n    ),\n  ),\n);\nresult.match(\n  (value) => console.log(value),\n  (error) => console.error(error),\n);',
+                requestType: "remote-chain-head-call-request",
+                responseType: "remote-chain-head-call-response",
+                errorType: "generic-error",
             },
             {
                 name: "unpin_head",
                 type: "unary",
+                signature: "unpinHead(request: RemoteChainHeadUnpinRequest): Promise<Result<undefined, GenericError>>",
+                docUrl: "api/chain/trait.Chain.html#method.unpin_head",
                 description: "Release pinned blocks.",
                 requestDescription: "RemoteChainHeadUnpinRequest",
-                defaultRequest: '{\n  "followSubscriptionId": "",\n  "genesisHash": "0xd6eec26135305a8ad257a20d003357284c8aa03d0bdb2b357ab0a22371e11ef2",\n  "hashes": [\n    "0x0000000000000000000000000000000000000000000000000000000000000000"\n  ]\n}',
+                exampleSource: 'import { PASEO_NEXT_V2_ASSET_HUB } from "@parity/truapi";\n\nimport { firstValueFrom, mergeMap } from "rxjs";\n\nconst result = await firstValueFrom(\n  withChainHeadFollow({\n    genesisHash: PASEO_NEXT_V2_ASSET_HUB.genesis,\n  }).pipe(\n    mergeMap(({ genesisHash, followSubscriptionId, hash }) =>\n      truapi.chain.unpinHead({\n        genesisHash,\n        followSubscriptionId,\n        hashes: [hash],\n      }),\n    ),\n  ),\n);\nresult.match(\n  () => console.log("ok"),\n  (error) => console.error(error),\n);',
+                requestType: "remote-chain-head-unpin-request",
+                errorType: "generic-error",
             },
             {
                 name: "continue_head",
                 type: "unary",
+                signature: "continueHead(request: RemoteChainHeadContinueRequest): Promise<Result<undefined, GenericError>>",
+                docUrl: "api/chain/trait.Chain.html#method.continue_head",
                 description: "Continue a paused chain-head operation.",
                 requestDescription: "RemoteChainHeadContinueRequest",
-                defaultRequest: '{\n  "followSubscriptionId": "",\n  "genesisHash": "0xd6eec26135305a8ad257a20d003357284c8aa03d0bdb2b357ab0a22371e11ef2",\n  "operationId": "op-id"\n}',
+                exampleSource: 'import { PASEO_NEXT_V2_ASSET_HUB } from "@parity/truapi";\n\nimport { firstValueFrom, mergeMap } from "rxjs";\n\nconst result = await firstValueFrom(\n  withChainHeadFollow({\n    genesisHash: PASEO_NEXT_V2_ASSET_HUB.genesis,\n  }).pipe(\n    mergeMap(({ genesisHash, followSubscriptionId }) =>\n      truapi.chain.continueHead({\n        genesisHash,\n        followSubscriptionId,\n        operationId: "op-id",\n      }),\n    ),\n  ),\n);\nresult.match(\n  () => console.log("ok"),\n  (error) => console.error(error),\n);',
+                requestType: "remote-chain-head-continue-request",
+                errorType: "generic-error",
             },
             {
                 name: "stop_head_operation",
                 type: "unary",
+                signature: "stopHeadOperation(request: RemoteChainHeadStopOperationRequest): Promise<Result<undefined, GenericError>>",
+                docUrl: "api/chain/trait.Chain.html#method.stop_head_operation",
                 description: "Stop a chain-head operation.",
                 requestDescription: "RemoteChainHeadStopOperationRequest",
-                defaultRequest: '{\n  "followSubscriptionId": "",\n  "genesisHash": "0xd6eec26135305a8ad257a20d003357284c8aa03d0bdb2b357ab0a22371e11ef2",\n  "operationId": "op-id"\n}',
+                exampleSource: 'import { PASEO_NEXT_V2_ASSET_HUB } from "@parity/truapi";\n\nimport { firstValueFrom, mergeMap } from "rxjs";\n\nconst result = await firstValueFrom(\n  withChainHeadFollow({\n    genesisHash: PASEO_NEXT_V2_ASSET_HUB.genesis,\n  }).pipe(\n    mergeMap(({ genesisHash, followSubscriptionId }) =>\n      truapi.chain.stopHeadOperation({\n        genesisHash,\n        followSubscriptionId,\n        operationId: "op-id",\n      }),\n    ),\n  ),\n);\nresult.match(\n  () => console.log("ok"),\n  (error) => console.error(error),\n);',
+                requestType: "remote-chain-head-stop-operation-request",
+                errorType: "generic-error",
             },
             {
                 name: "get_spec_genesis_hash",
                 type: "unary",
+                signature: "getSpecGenesisHash(request: RemoteChainSpecGenesisHashRequest): Promise<Result<RemoteChainSpecGenesisHashResponse, GenericError>>",
+                docUrl: "api/chain/trait.Chain.html#method.get_spec_genesis_hash",
                 description: "Fetch the canonical genesis hash for a chain.",
                 requestDescription: "RemoteChainSpecGenesisHashRequest",
-                defaultRequest: '{\n  "genesisHash": "0xd6eec26135305a8ad257a20d003357284c8aa03d0bdb2b357ab0a22371e11ef2"\n}',
+                exampleSource: 'import { PASEO_NEXT_V2_ASSET_HUB } from "@parity/truapi";\n\nconst result = await truapi.chain.getSpecGenesisHash({\n  genesisHash: PASEO_NEXT_V2_ASSET_HUB.genesis,\n});\nresult.match(\n  (value) => console.log(value),\n  (error) => console.error(error),\n);',
+                requestType: "remote-chain-spec-genesis-hash-request",
+                responseType: "remote-chain-spec-genesis-hash-response",
+                errorType: "generic-error",
             },
             {
                 name: "get_spec_chain_name",
                 type: "unary",
+                signature: "getSpecChainName(request: RemoteChainSpecChainNameRequest): Promise<Result<RemoteChainSpecChainNameResponse, GenericError>>",
+                docUrl: "api/chain/trait.Chain.html#method.get_spec_chain_name",
                 description: "Fetch the display name of a chain.",
                 requestDescription: "RemoteChainSpecChainNameRequest",
-                defaultRequest: '{\n  "genesisHash": "0xd6eec26135305a8ad257a20d003357284c8aa03d0bdb2b357ab0a22371e11ef2"\n}',
+                exampleSource: 'import { PASEO_NEXT_V2_ASSET_HUB } from "@parity/truapi";\n\nconst result = await truapi.chain.getSpecChainName({\n  genesisHash: PASEO_NEXT_V2_ASSET_HUB.genesis,\n});\nresult.match(\n  (value) => console.log(value),\n  (error) => console.error(error),\n);',
+                requestType: "remote-chain-spec-chain-name-request",
+                responseType: "remote-chain-spec-chain-name-response",
+                errorType: "generic-error",
             },
             {
                 name: "get_spec_properties",
                 type: "unary",
+                signature: "getSpecProperties(request: RemoteChainSpecPropertiesRequest): Promise<Result<RemoteChainSpecPropertiesResponse, GenericError>>",
+                docUrl: "api/chain/trait.Chain.html#method.get_spec_properties",
                 description: "Fetch the JSON-encoded properties of a chain.",
                 requestDescription: "RemoteChainSpecPropertiesRequest",
-                defaultRequest: '{\n  "genesisHash": "0xd6eec26135305a8ad257a20d003357284c8aa03d0bdb2b357ab0a22371e11ef2"\n}',
+                exampleSource: 'import { PASEO_NEXT_V2_ASSET_HUB } from "@parity/truapi";\n\nconst result = await truapi.chain.getSpecProperties({\n  genesisHash: PASEO_NEXT_V2_ASSET_HUB.genesis,\n});\nresult.match(\n  (value) => console.log(value),\n  (error) => console.error(error),\n);',
+                requestType: "remote-chain-spec-properties-request",
+                responseType: "remote-chain-spec-properties-response",
+                errorType: "generic-error",
             },
             {
                 name: "broadcast_transaction",
                 type: "unary",
+                signature: "broadcastTransaction(request: RemoteChainTransactionBroadcastRequest): Promise<Result<RemoteChainTransactionBroadcastResponse, GenericError>>",
+                docUrl: "api/chain/trait.Chain.html#method.broadcast_transaction",
                 description: "Broadcast a signed transaction.",
                 requestDescription: "RemoteChainTransactionBroadcastRequest",
-                defaultRequest: '{\n  "genesisHash": "0xd6eec26135305a8ad257a20d003357284c8aa03d0bdb2b357ab0a22371e11ef2",\n  "transaction": "0x"\n}',
+                exampleSource: 'import { PASEO_NEXT_V2_ASSET_HUB } from "@parity/truapi";\n\nconst result = await truapi.chain.broadcastTransaction({\n  genesisHash: PASEO_NEXT_V2_ASSET_HUB.genesis,\n  transaction: "0x",\n});\nresult.match(\n  (value) => console.log(value),\n  (error) => console.error(error),\n);',
+                requestType: "remote-chain-transaction-broadcast-request",
+                responseType: "remote-chain-transaction-broadcast-response",
+                errorType: "generic-error",
             },
             {
                 name: "stop_transaction",
                 type: "unary",
+                signature: "stopTransaction(request: RemoteChainTransactionStopRequest): Promise<Result<undefined, GenericError>>",
+                docUrl: "api/chain/trait.Chain.html#method.stop_transaction",
                 description: "Stop a transaction broadcast.",
                 requestDescription: "RemoteChainTransactionStopRequest",
-                defaultRequest: '{\n  "genesisHash": "0xd6eec26135305a8ad257a20d003357284c8aa03d0bdb2b357ab0a22371e11ef2",\n  "operationId": "op-id"\n}',
+                exampleSource: 'import { PASEO_NEXT_V2_ASSET_HUB } from "@parity/truapi";\n\nconst result = await truapi.chain.stopTransaction({\n  genesisHash: PASEO_NEXT_V2_ASSET_HUB.genesis,\n  operationId: "op-id",\n});\nresult.match(\n  () => console.log("ok"),\n  (error) => console.error(error),\n);',
+                requestType: "remote-chain-transaction-stop-request",
+                errorType: "generic-error",
             },
         ],
     },
@@ -152,42 +243,67 @@ export const services = [
             {
                 name: "create_room",
                 type: "unary",
+                signature: "createRoom(request: HostChatCreateRoomRequest): Promise<Result<HostChatCreateRoomResponse, HostChatCreateRoomError>>",
+                docUrl: "api/chat/trait.Chat.html#method.create_room",
                 description: "Create a chat room.",
                 requestDescription: "HostChatCreateRoomRequest",
-                defaultRequest: '{\n  "icon": "",\n  "name": "Test Room",\n  "roomId": "test-room"\n}',
+                exampleSource: 'const result = await truapi.chat.createRoom({\n  roomId: "test-room",\n  name: "Test Room",\n  icon: "",\n});\nresult.match(\n  (value) => console.log(value),\n  (error) => console.error(error),\n);',
+                requestType: "host-chat-create-room-request",
+                responseType: "host-chat-create-room-response",
+                errorType: "host-chat-create-room-error",
             },
             {
                 name: "register_bot",
                 type: "unary",
+                signature: "registerBot(request: HostChatRegisterBotRequest): Promise<Result<HostChatRegisterBotResponse, HostChatRegisterBotError>>",
+                docUrl: "api/chat/trait.Chat.html#method.register_bot",
                 description: "Register a chat bot.",
                 requestDescription: "HostChatRegisterBotRequest",
-                defaultRequest: '{\n  "botId": "test-bot",\n  "icon": "",\n  "name": "Test Bot"\n}',
+                exampleSource: 'const result = await truapi.chat.registerBot({\n  botId: "test-bot",\n  name: "Test Bot",\n  icon: "",\n});\nresult.match(\n  (value) => console.log(value),\n  (error) => console.error(error),\n);',
+                requestType: "host-chat-register-bot-request",
+                responseType: "host-chat-register-bot-response",
+                errorType: "host-chat-register-bot-error",
             },
             {
                 name: "list_subscribe",
                 type: "subscription",
+                signature: "listSubscribe(): ObservableLike<HostChatListSubscribeItem>",
+                docUrl: "api/chat/trait.Chat.html#method.list_subscribe",
                 description: "Subscribe to the list of chat rooms.",
-                noParams: true,
+                exampleSource: 'import { from, take } from "rxjs";\n\nfrom(truapi.chat.listSubscribe())\n  .pipe(take(1))\n  .subscribe({\n    next: (rooms) => console.log(rooms),\n    error: (error) => console.error(error),\n    complete: () => console.log("completed"),\n  });',
+                responseType: "host-chat-list-subscribe-item",
             },
             {
                 name: "post_message",
                 type: "unary",
+                signature: "postMessage(request: HostChatPostMessageRequest): Promise<Result<HostChatPostMessageResponse, HostChatPostMessageError>>",
+                docUrl: "api/chat/trait.Chat.html#method.post_message",
                 description: "Post a message to a chat room.",
                 requestDescription: "HostChatPostMessageRequest",
-                defaultRequest: '{\n  "payload": {\n    "tag": "Text",\n    "value": {\n      "text": "Hello from playground!"\n    }\n  },\n  "roomId": "test-room"\n}',
+                exampleSource: 'const result = await truapi.chat.postMessage({\n  roomId: "test-room",\n  payload: { tag: "Text", value: { text: "Hello from playground!" } },\n});\nresult.match(\n  (value) => console.log(value),\n  (error) => console.error(error),\n);',
+                requestType: "host-chat-post-message-request",
+                responseType: "host-chat-post-message-response",
+                errorType: "host-chat-post-message-error",
             },
             {
                 name: "action_subscribe",
                 type: "subscription",
+                signature: "actionSubscribe(): ObservableLike<HostChatActionSubscribeItem>",
+                docUrl: "api/chat/trait.Chat.html#method.action_subscribe",
                 description: "Subscribe to received chat actions.",
-                noParams: true,
+                exampleSource: 'import { from, take } from "rxjs";\n\nfrom(truapi.chat.actionSubscribe())\n  .pipe(take(1))\n  .subscribe({\n    next: (action) => console.log(action),\n    error: (error) => console.error(error),\n    complete: () => console.log("completed"),\n  });',
+                responseType: "host-chat-action-subscribe-item",
             },
             {
                 name: "custom_message_render_subscribe",
                 type: "subscription",
+                signature: "customMessageRenderSubscribe(request: ProductChatCustomMessageRenderSubscribeRequest): ObservableLike<CustomRendererNode>",
+                docUrl: "api/chat/trait.Chat.html#method.custom_message_render_subscribe",
                 description: "Subscribe to custom message render requests from the host. Each\nemitted item is a [`CustomRendererNode`](crate::v01::CustomRendererNode)\ntree describing the rendered UI.",
                 requestDescription: "ProductChatCustomMessageRenderSubscribeRequest",
-                defaultRequest: '{\n  "messageId": "msg-1",\n  "messageType": "custom-render-demo",\n  "payload": "0x"\n}',
+                exampleSource: 'import { from, take } from "rxjs";\n\nfrom(\n  truapi.chat.customMessageRenderSubscribe({\n    request: {\n      messageId: "msg-1",\n      messageType: "custom-render-demo",\n      payload: "0x",\n    },\n  }),\n)\n  .pipe(take(1))\n  .subscribe({\n    next: (node) => console.log(node),\n    error: (error) => console.error(error),\n    complete: () => console.log("completed"),\n  });',
+                requestType: "product-chat-custom-message-render-subscribe-request",
+                responseType: "custom-renderer-node",
             },
         ],
     },
@@ -197,28 +313,14 @@ export const services = [
             {
                 name: "derive",
                 type: "unary",
+                signature: "derive(request: HostDeriveEntropyRequest): Promise<Result<HostDeriveEntropyResponse, HostDeriveEntropyError>>",
+                docUrl: "api/entropy/trait.Entropy.html#method.derive",
                 description: "Derive deterministic entropy.",
                 requestDescription: "HostDeriveEntropyRequest",
-                defaultRequest: '{\n  "context": "0x70726f647563742d6b6579"\n}',
-            },
-        ],
-    },
-    {
-        name: "JSON-RPC",
-        methods: [
-            {
-                name: "send_message",
-                type: "unary",
-                description: "Send a JSON-RPC message.",
-                requestDescription: "HostJsonrpcMessageSendRequest",
-                defaultRequest: '{\n  "genesisHash": "0xd6eec26135305a8ad257a20d003357284c8aa03d0bdb2b357ab0a22371e11ef2",\n  "message": "{\\"jsonrpc\\":\\"2.0\\",\\"id\\":1,\\"method\\":\\"system_name\\",\\"params\\":[]}"\n}',
-            },
-            {
-                name: "subscribe_messages",
-                type: "subscription",
-                description: "Subscribe to inbound JSON-RPC messages.",
-                requestDescription: "HostJsonrpcMessageSubscribeRequest",
-                defaultRequest: '{\n  "genesisHash": "0xd6eec26135305a8ad257a20d003357284c8aa03d0bdb2b357ab0a22371e11ef2"\n}',
+                exampleSource: 'const result = await truapi.entropy.derive({\n  context: "0x70726f647563742d6b6579",\n});\nresult.match(\n  (value) => console.log(value),\n  (error) => console.error(error),\n);',
+                requestType: "host-derive-entropy-request",
+                responseType: "host-derive-entropy-response",
+                errorType: "host-derive-entropy-error",
             },
         ],
     },
@@ -228,23 +330,64 @@ export const services = [
             {
                 name: "read",
                 type: "unary",
+                signature: "read(request: HostLocalStorageReadRequest): Promise<Result<HostLocalStorageReadResponse, HostLocalStorageReadError>>",
+                docUrl: "api/local_storage/trait.LocalStorage.html#method.read",
                 description: "Read a value by key.",
                 requestDescription: "HostLocalStorageReadRequest",
-                defaultRequest: '{\n  "key": "test-key"\n}',
+                exampleSource: 'const result = await truapi.localStorage.read({ key: "test-key" });\nresult.match(\n  (response) => console.log(response.value),\n  (error) => console.error(error),\n);',
+                requestType: "host-local-storage-read-request",
+                responseType: "host-local-storage-read-response",
+                errorType: "host-local-storage-read-error",
             },
             {
                 name: "write",
                 type: "unary",
+                signature: "write(request: HostLocalStorageWriteRequest): Promise<Result<undefined, HostLocalStorageReadError>>",
+                docUrl: "api/local_storage/trait.LocalStorage.html#method.write",
                 description: "Write a value to a key.",
                 requestDescription: "HostLocalStorageWriteRequest",
-                defaultRequest: '{\n  "key": "test-key",\n  "value": "0x48656c6c6f"\n}',
+                exampleSource: 'const result = await truapi.localStorage.write({\n  key: "test-key",\n  value: "0x48656c6c6f",\n});\nresult.match(\n  () => console.log("ok"),\n  (error) => console.error(error),\n);',
+                requestType: "host-local-storage-write-request",
+                errorType: "host-local-storage-read-error",
             },
             {
                 name: "clear",
                 type: "unary",
+                signature: "clear(request: HostLocalStorageClearRequest): Promise<Result<undefined, HostLocalStorageReadError>>",
+                docUrl: "api/local_storage/trait.LocalStorage.html#method.clear",
                 description: "Clear a value by key.",
                 requestDescription: "HostLocalStorageClearRequest",
-                defaultRequest: '{\n  "key": "test-key"\n}',
+                exampleSource: 'const result = await truapi.localStorage.clear({ key: "test-key" });\nresult.match(\n  () => console.log("ok"),\n  (error) => console.error(error),\n);',
+                requestType: "host-local-storage-clear-request",
+                errorType: "host-local-storage-read-error",
+            },
+        ],
+    },
+    {
+        name: "Notifications",
+        methods: [
+            {
+                name: "send_push_notification",
+                type: "unary",
+                signature: "sendPushNotification(request: HostPushNotificationRequest): Promise<Result<HostPushNotificationResponse, HostPushNotificationError>>",
+                docUrl: "api/notifications/trait.Notifications.html#method.send_push_notification",
+                description: "Send a push notification to the user.\n\nReturns a [`NotificationId`](crate::v01::NotificationId) that can be\npassed to [`cancel_push_notification`](Self::cancel_push_notification)\nto retract a scheduled notification. When `scheduled_at` is set the host\npersists the notification across restarts and fires it through the\nplatform-native scheduler. See [RFC 0019].\n\n[RFC 0019]: https://github.com/paritytech/truapi/blob/main/docs/rfcs/0019-scheduled-notifications.md",
+                requestDescription: "HostPushNotificationRequest",
+                exampleSource: 'const result = await truapi.notifications.sendPushNotification({\n  text: "Hello!",\n});\nresult.match(\n  (value) => console.log(value),\n  (error) => console.error(error),\n);',
+                requestType: "host-push-notification-request",
+                responseType: "host-push-notification-response",
+                errorType: "host-push-notification-error",
+            },
+            {
+                name: "cancel_push_notification",
+                type: "unary",
+                signature: "cancelPushNotification(request: HostPushNotificationCancelRequest): Promise<Result<undefined, GenericError>>",
+                docUrl: "api/notifications/trait.Notifications.html#method.cancel_push_notification",
+                description: "Cancels a previously issued push notification.\n\nCancellation is idempotent: returns `Ok(())` whether the notification is\nstill pending, already fired, or was never issued. See [RFC 0019].\n\n[RFC 0019]: https://github.com/paritytech/truapi/blob/main/docs/rfcs/0019-scheduled-notifications.md",
+                requestDescription: "HostPushNotificationCancelRequest",
+                exampleSource: 'const result = await truapi.notifications.cancelPushNotification({\n  id: 1,\n});\nresult.match(\n  () => console.log("ok"),\n  (error) => console.error(error),\n);',
+                requestType: "host-push-notification-cancel-request",
+                errorType: "generic-error",
             },
         ],
     },
@@ -254,29 +397,49 @@ export const services = [
             {
                 name: "balance_subscribe",
                 type: "subscription",
+                signature: "balanceSubscribe(request: HostPaymentBalanceSubscribeRequest): ObservableLike<HostPaymentBalanceSubscribeItem, HostPaymentBalanceSubscribeError>",
+                docUrl: "api/payment/trait.Payment.html#method.balance_subscribe",
                 description: "Subscribe to payment balance updates.",
-                noParams: true,
+                requestDescription: "HostPaymentBalanceSubscribeRequest",
+                exampleSource: 'import { from, take } from "rxjs";\n\nfrom(truapi.payment.balanceSubscribe({ request: {} }))\n  .pipe(take(1))\n  .subscribe({\n    next: (balance) => console.log(balance),\n    error: (error) => console.error(error),\n    complete: () => console.log("completed"),\n  });',
+                requestType: "host-payment-balance-subscribe-request",
+                responseType: "host-payment-balance-subscribe-item",
+                errorType: "host-payment-balance-subscribe-error",
             },
             {
                 name: "top_up",
                 type: "unary",
+                signature: "topUp(request: HostPaymentTopUpRequest): Promise<Result<undefined, HostPaymentTopUpError>>",
+                docUrl: "api/payment/trait.Payment.html#method.top_up",
                 description: "Top up the user's payment balance.",
                 requestDescription: "HostPaymentTopUpRequest",
-                defaultRequest: '{\n  "amount": "1000000000000n",\n  "source": {\n    "tag": "ProductAccount",\n    "value": {\n      "derivationIndex": 0\n    }\n  }\n}',
+                exampleSource: 'const result = await truapi.payment.topUp({\n  amount: 1000n,\n  source: { tag: "ProductAccount", value: { derivationIndex: 0 } },\n});\nresult.match(\n  () => console.log("ok"),\n  (error) => console.error(error),\n);',
+                requestType: "host-payment-top-up-request",
+                errorType: "host-payment-top-up-error",
             },
             {
                 name: "request",
                 type: "unary",
+                signature: "request(request: HostPaymentRequest): Promise<Result<HostPaymentResponse, HostPaymentError>>",
+                docUrl: "api/payment/trait.Payment.html#method.request",
                 description: "Request a payment from the user.",
-                requestDescription: "HostPaymentRequestRequest",
-                defaultRequest: '{\n  "amount": "1000000000000n",\n  "destination": "0x0000000000000000000000000000000000000000000000000000000000000000"\n}',
+                requestDescription: "HostPaymentRequest",
+                exampleSource: '// Fund the balance first so the request is not rejected for lack of funds.\nconst topUp = await truapi.payment.topUp({\n  amount: 1000n,\n  source: { tag: "ProductAccount", value: { derivationIndex: 0 } },\n});\n\nif (topUp.isErr()) {\n  console.error("topUp failed:", topUp.error);\n} else {\n  const result = await truapi.payment.request({\n    amount: 1000n,\n    destination:\n      "0x0000000000000000000000000000000000000000000000000000000000000000",\n  });\n  result.match(\n    (value) => console.log(value),\n    (error) => console.error("request failed:", error),\n  );\n}',
+                requestType: "host-payment-request",
+                responseType: "host-payment-response",
+                errorType: "host-payment-error",
             },
             {
                 name: "status_subscribe",
                 type: "subscription",
+                signature: "statusSubscribe(request: HostPaymentStatusSubscribeRequest): ObservableLike<HostPaymentStatusSubscribeItem, HostPaymentStatusSubscribeError>",
+                docUrl: "api/payment/trait.Payment.html#method.status_subscribe",
                 description: "Subscribe to payment lifecycle updates for a specific payment.",
                 requestDescription: "HostPaymentStatusSubscribeRequest",
-                defaultRequest: '{\n  "paymentId": "payment-id"\n}',
+                exampleSource: 'import { from, take } from "rxjs";\n\n// Fund the balance and start a payment first so there is a status to watch.\nconst topUp = await truapi.payment.topUp({\n  amount: 1000n,\n  source: { tag: "ProductAccount", value: { derivationIndex: 0 } },\n});\n\nif (topUp.isErr()) {\n  console.error("topUp failed:", topUp.error);\n} else {\n  const requested = await truapi.payment.request({\n    amount: 1000n,\n    destination:\n      "0x0000000000000000000000000000000000000000000000000000000000000000",\n  });\n  if (requested.isErr()) {\n    console.error("request failed:", requested.error);\n  } else {\n    from(\n      truapi.payment.statusSubscribe({\n        request: { paymentId: requested.value.id },\n      }),\n    )\n      .pipe(take(1))\n      .subscribe({\n        next: (status) => console.log(status),\n        error: (error) => console.error("statusSubscribe failed:", error),\n        complete: () => console.log("completed"),\n      });\n  }\n}',
+                requestType: "host-payment-status-subscribe-request",
+                responseType: "host-payment-status-subscribe-item",
+                errorType: "host-payment-status-subscribe-error",
             },
         ],
     },
@@ -286,16 +449,26 @@ export const services = [
             {
                 name: "request_device_permission",
                 type: "unary",
+                signature: "requestDevicePermission(request: HostDevicePermissionRequest): Promise<Result<HostDevicePermissionResponse, GenericError>>",
+                docUrl: "api/permissions/trait.Permissions.html#method.request_device_permission",
                 description: "Request a device-capability permission from the user.",
                 requestDescription: "Enum values: Notifications / Camera / Microphone / Bluetooth / NFC / Location / Clipboard / OpenUrl / Biometrics",
-                defaultRequest: '"Camera"',
+                exampleSource: 'const result = await truapi.permissions.requestDevicePermission("Camera");\nresult.match(\n  (value) => console.log(value),\n  (error) => console.error(error),\n);',
+                requestType: "host-device-permission-request",
+                responseType: "host-device-permission-response",
+                errorType: "generic-error",
             },
             {
                 name: "request_remote_permission",
                 type: "unary",
-                description: "Request one or more remote-operation permissions.",
+                signature: "requestRemotePermission(request: RemotePermissionRequest): Promise<Result<RemotePermissionResponse, GenericError>>",
+                docUrl: "api/permissions/trait.Permissions.html#method.request_remote_permission",
+                description: "Request a remote-operation permission.",
                 requestDescription: "RemotePermissionRequest",
-                defaultRequest: '{\n  "permissions": [\n    {\n      "tag": "Remote",\n      "value": {\n        "domains": [\n          "api.example.com"\n        ]\n      }\n    }\n  ]\n}',
+                exampleSource: 'const result = await truapi.permissions.requestRemotePermission({\n  permission: { tag: "Remote", value: { domains: ["api.example.com"] } },\n});\nresult.match(\n  (value) => console.log(value),\n  (error) => console.error(error),\n);',
+                requestType: "remote-permission-request",
+                responseType: "remote-permission-response",
+                errorType: "generic-error",
             },
         ],
     },
@@ -305,16 +478,23 @@ export const services = [
             {
                 name: "lookup_subscribe",
                 type: "subscription",
+                signature: "lookupSubscribe(request: RemotePreimageLookupSubscribeRequest): ObservableLike<RemotePreimageLookupSubscribeItem>",
+                docUrl: "api/preimage/trait.Preimage.html#method.lookup_subscribe",
                 description: "Subscribe to preimage lookups for a given key.",
                 requestDescription: "RemotePreimageLookupSubscribeRequest",
-                defaultRequest: '{\n  "key": "0x0000000000000000000000000000000000000000000000000000000000000000"\n}',
+                exampleSource: 'import { from, take } from "rxjs";\n\n// Submit a preimage first so the lookup resolves to a value.\nconst submitted = await truapi.preimage.submit("0xdeadbeef");\nif (submitted.isErr()) {\n  console.error("submit failed:", submitted.error);\n} else {\n  from(truapi.preimage.lookupSubscribe({ request: { key: submitted.value } }))\n    .pipe(take(1))\n    .subscribe({\n      next: (item) => console.log(item),\n      error: (error) => console.error("lookupSubscribe failed:", error),\n      complete: () => console.log("completed"),\n    });\n}',
+                requestType: "remote-preimage-lookup-subscribe-request",
+                responseType: "remote-preimage-lookup-subscribe-item",
             },
             {
                 name: "submit",
                 type: "unary",
+                signature: "submit(request: HexString): Promise<Result<HexString, PreimageSubmitError>>",
+                docUrl: "api/preimage/trait.Preimage.html#method.submit",
                 description: "Submit a preimage. Returns the preimage key (hash) on success.",
                 requestDescription: "HexString",
-                defaultRequest: '"0xdeadbeef"',
+                exampleSource: 'const result = await truapi.preimage.submit("0xdeadbeef");\nresult.match(\n  (value) => console.log(value),\n  (error) => console.error(error),\n);',
+                errorType: "preimage-submit-error",
             },
         ],
     },
@@ -324,9 +504,14 @@ export const services = [
             {
                 name: "request",
                 type: "unary",
+                signature: "request(request: HostRequestResourceAllocationRequest): Promise<Result<HostRequestResourceAllocationResponse, ResourceAllocationError>>",
+                docUrl: "api/resource_allocation/trait.ResourceAllocation.html#method.request",
                 description: "Request the host to pre-allocate one or more resources.",
                 requestDescription: "HostRequestResourceAllocationRequest",
-                defaultRequest: '{\n  "resources": [\n    {\n      "tag": "StatementStoreAllowance"\n    },\n    {\n      "tag": "AutoSigning"\n    }\n  ]\n}',
+                exampleSource: 'const result = await truapi.resourceAllocation.request({\n  resources: [\n    { tag: "StatementStoreAllowance" },\n    { tag: "AutoSigning" },\n  ],\n});\nresult.match(\n  (value) => console.log(value),\n  (error) => console.error(error),\n);',
+                requestType: "host-request-resource-allocation-request",
+                responseType: "host-request-resource-allocation-response",
+                errorType: "resource-allocation-error",
             },
         ],
     },
@@ -336,44 +521,74 @@ export const services = [
             {
                 name: "create_transaction",
                 type: "unary",
+                signature: "createTransaction(request: ProductAccountTxPayload): Promise<Result<HostCreateTransactionResponse, HostCreateTransactionError>>",
+                docUrl: "api/signing/trait.Signing.html#method.create_transaction",
                 description: "Construct a signed transaction for a product account.",
-                requestDescription: "HostCreateTransactionRequest",
-                defaultRequest: '{\n  "payload": {\n    "tag": "V1",\n    "value": {\n      "callData": "0x0000",\n      "context": {\n        "bestBlockHeight": 0,\n        "metadata": "0x",\n        "tokenDecimals": 10,\n        "tokenSymbol": "DOT"\n      },\n      "extensions": [],\n      "txExtVersion": 0\n    }\n  },\n  "productAccountId": {\n    "derivationIndex": 0,\n    "dotNsIdentifier": "truapi-playground.dot"\n  }\n}',
+                requestDescription: "ProductAccountTxPayload",
+                exampleSource: 'import { PASEO_NEXT_V2_ASSET_HUB } from "@parity/truapi";\n\nconst result = await truapi.signing.createTransaction({\n  signer: {\n    dotNsIdentifier: "truapi-playground.dot",\n    derivationIndex: 0,\n  },\n  genesisHash: PASEO_NEXT_V2_ASSET_HUB.genesis,\n  callData: "0x0000",\n  extensions: [],\n  txExtVersion: 0,\n});\nresult.match(\n  (value) => console.log(value),\n  (error) => console.error(error),\n);',
+                requestType: "product-account-tx-payload",
+                responseType: "host-create-transaction-response",
+                errorType: "host-create-transaction-error",
             },
             {
                 name: "create_transaction_with_legacy_account",
                 type: "unary",
-                description: "Construct a signed transaction for a non-product account.",
-                requestDescription: "HostCreateTransactionWithLegacyAccountRequest",
-                defaultRequest: '{\n  "payload": {\n    "tag": "V1",\n    "value": {\n      "callData": "0x0000",\n      "context": {\n        "bestBlockHeight": 0,\n        "metadata": "0x",\n        "tokenDecimals": 10,\n        "tokenSymbol": "DOT"\n      },\n      "extensions": [],\n      "txExtVersion": 0\n    }\n  }\n}',
+                signature: "createTransactionWithLegacyAccount(request: LegacyAccountTxPayload): Promise<Result<HostCreateTransactionWithLegacyAccountResponse, HostCreateTransactionError>>",
+                docUrl: "api/signing/trait.Signing.html#method.create_transaction_with_legacy_account",
+                description: "Construct a signed transaction for a non-product (legacy) account.",
+                requestDescription: "LegacyAccountTxPayload",
+                exampleSource: 'import { PASEO_NEXT_V2_ASSET_HUB } from "@parity/truapi";\n\nconst result = await truapi.signing.createTransactionWithLegacyAccount({\n  signer: "0x0000000000000000000000000000000000000000000000000000000000000000",\n  genesisHash: PASEO_NEXT_V2_ASSET_HUB.genesis,\n  callData: "0x0000",\n  extensions: [],\n  txExtVersion: 0,\n});\nresult.match(\n  (value) => console.log(value),\n  (error) => console.error(error),\n);',
+                requestType: "legacy-account-tx-payload",
+                responseType: "host-create-transaction-with-legacy-account-response",
+                errorType: "host-create-transaction-error",
             },
             {
                 name: "sign_raw_with_legacy_account",
                 type: "unary",
+                signature: "signRawWithLegacyAccount(request: HostSignRawWithLegacyAccountRequest): Promise<Result<HostSignPayloadResponse, HostSignPayloadError>>",
+                docUrl: "api/signing/trait.Signing.html#method.sign_raw_with_legacy_account",
                 description: "Sign raw bytes with a non-product account.",
                 requestDescription: "HostSignRawWithLegacyAccountRequest",
-                defaultRequest: '{\n  "payload": {\n    "tag": "Bytes",\n    "value": {\n      "bytes": "0x48656c6c6f"\n    }\n  },\n  "signer": "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY"\n}',
+                exampleSource: 'const result = await truapi.signing.signRawWithLegacyAccount({\n  signer: "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY",\n  payload: {\n    tag: "Bytes",\n    value: { bytes: "0x48656c6c6f" },\n  },\n});\nresult.match(\n  (value) => console.log(value),\n  (error) => console.error(error),\n);',
+                requestType: "host-sign-raw-with-legacy-account-request",
+                responseType: "host-sign-payload-response",
+                errorType: "host-sign-payload-error",
             },
             {
                 name: "sign_payload_with_legacy_account",
                 type: "unary",
+                signature: "signPayloadWithLegacyAccount(request: HostSignPayloadWithLegacyAccountRequest): Promise<Result<HostSignPayloadResponse, HostSignPayloadError>>",
+                docUrl: "api/signing/trait.Signing.html#method.sign_payload_with_legacy_account",
                 description: "Sign an extrinsic payload with a non-product account.",
                 requestDescription: "HostSignPayloadWithLegacyAccountRequest",
-                defaultRequest: '{\n  "payload": {\n    "account": {\n      "derivationIndex": 0,\n      "dotNsIdentifier": "truapi-playground.dot"\n    },\n    "blockHash": "0xd6eec26135305a8ad257a20d003357284c8aa03d0bdb2b357ab0a22371e11ef2",\n    "blockNumber": "0x00000000",\n    "era": "0x00",\n    "genesisHash": "0xd6eec26135305a8ad257a20d003357284c8aa03d0bdb2b357ab0a22371e11ef2",\n    "method": "0x0000",\n    "nonce": "0x00000000",\n    "signedExtensions": [],\n    "specVersion": "0x00000000",\n    "tip": "0x00000000000000000000000000000000",\n    "transactionVersion": "0x00000000",\n    "version": 4\n  },\n  "signer": "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY"\n}',
+                exampleSource: 'import { PASEO_NEXT_V2_ASSET_HUB } from "@parity/truapi";\n\nconst result = await truapi.signing.signPayloadWithLegacyAccount({\n  signer: "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY",\n  payload: {\n    blockHash: "0xd6eec26135305a8ad257a20d003357284c8aa03d0bdb2b357ab0a22371e11ef2",\n    blockNumber: "0x00000000",\n    era: "0x00",\n    genesisHash: PASEO_NEXT_V2_ASSET_HUB.genesis,\n    method: "0x0000",\n    nonce: "0x00000000",\n    signedExtensions: [],\n    specVersion: "0x00000000",\n    tip: "0x00000000000000000000000000000000",\n    transactionVersion: "0x00000000",\n    version: 4,\n  },\n});\nresult.match(\n  (value) => console.log(value),\n  (error) => console.error(error),\n);',
+                requestType: "host-sign-payload-with-legacy-account-request",
+                responseType: "host-sign-payload-response",
+                errorType: "host-sign-payload-error",
             },
             {
                 name: "sign_raw",
                 type: "unary",
+                signature: "signRaw(request: HostSignRawRequest): Promise<Result<HostSignPayloadResponse, HostSignPayloadError>>",
+                docUrl: "api/signing/trait.Signing.html#method.sign_raw",
                 description: "Sign raw bytes or a message.",
                 requestDescription: "HostSignRawRequest",
-                defaultRequest: '{\n  "account": {\n    "derivationIndex": 0,\n    "dotNsIdentifier": "truapi-playground.dot"\n  },\n  "payload": {\n    "tag": "Bytes",\n    "value": {\n      "bytes": "0x48656c6c6f2c20776f726c6421"\n    }\n  }\n}',
+                exampleSource: 'const result = await truapi.signing.signRaw({\n  account: { dotNsIdentifier: "truapi-playground.dot", derivationIndex: 0 },\n  payload: {\n    tag: "Bytes",\n    value: {\n      bytes: "0x48656c6c6f2c20776f726c6421",\n    },\n  },\n});\nresult.match(\n  (value) => console.log(value),\n  (error) => console.error(error),\n);',
+                requestType: "host-sign-raw-request",
+                responseType: "host-sign-payload-response",
+                errorType: "host-sign-payload-error",
             },
             {
                 name: "sign_payload",
                 type: "unary",
+                signature: "signPayload(request: HostSignPayloadRequest): Promise<Result<HostSignPayloadResponse, HostSignPayloadError>>",
+                docUrl: "api/signing/trait.Signing.html#method.sign_payload",
                 description: "Sign an extrinsic payload.",
                 requestDescription: "HostSignPayloadRequest",
-                defaultRequest: '{\n  "account": {\n    "derivationIndex": 0,\n    "dotNsIdentifier": "truapi-playground.dot"\n  },\n  "blockHash": "0xd6eec26135305a8ad257a20d003357284c8aa03d0bdb2b357ab0a22371e11ef2",\n  "blockNumber": "0x00000000",\n  "era": "0x00",\n  "genesisHash": "0xd6eec26135305a8ad257a20d003357284c8aa03d0bdb2b357ab0a22371e11ef2",\n  "method": "0x00003448656c6c6f2c20776f726c6421",\n  "nonce": "0x00000000",\n  "signedExtensions": [],\n  "specVersion": "0x00000000",\n  "tip": "0x00000000000000000000000000000000",\n  "transactionVersion": "0x00000000",\n  "version": 4\n}',
+                exampleSource: 'import { PASEO_NEXT_V2_ASSET_HUB } from "@parity/truapi";\n\nconst result = await truapi.signing.signPayload({\n  account: { dotNsIdentifier: "truapi-playground.dot", derivationIndex: 0 },\n  payload: {\n    blockHash: "0xd6eec26135305a8ad257a20d003357284c8aa03d0bdb2b357ab0a22371e11ef2",\n    blockNumber: "0x00000000",\n    era: "0x00",\n    genesisHash: PASEO_NEXT_V2_ASSET_HUB.genesis,\n    method: "0x00003448656c6c6f2c20776f726c6421",\n    nonce: "0x00000000",\n    signedExtensions: [],\n    specVersion: "0x00000000",\n    tip: "0x00000000000000000000000000000000",\n    transactionVersion: "0x00000000",\n    version: 4,\n  },\n});\nresult.match(\n  (value) => console.log(value),\n  (error) => console.error(error),\n);',
+                requestType: "host-sign-payload-request",
+                responseType: "host-sign-payload-response",
+                errorType: "host-sign-payload-error",
             },
         ],
     },
@@ -383,30 +598,48 @@ export const services = [
             {
                 name: "subscribe",
                 type: "subscription",
+                signature: "subscribe(request: RemoteStatementStoreSubscribeRequest): ObservableLike<RemoteStatementStoreSubscribeItem>",
+                docUrl: "api/statement_store/trait.StatementStore.html#method.subscribe",
                 description: "Subscribe to statements matching a topic filter.",
                 requestDescription: "RemoteStatementStoreSubscribeRequest",
-                defaultRequest: '{\n  "tag": "MatchAll",\n  "value": []\n}',
+                exampleSource: 'import { from, take } from "rxjs";\n\n// Create and submit a statement first so the subscription has a match.\nconst proofResult = await truapi.statementStore.createProof({\n  productAccountId: {\n    dotNsIdentifier: "truapi-playground.dot",\n    derivationIndex: 0,\n  },\n  statement: { topics: [] },\n});\n\nif (proofResult.isErr()) {\n  console.error("createProof failed:", proofResult.error);\n} else {\n  await truapi.statementStore.submit({\n    proof: proofResult.value.proof,\n    topics: [],\n  });\n  from(\n    truapi.statementStore.subscribe({\n      request: { tag: "MatchAll", value: [] },\n    }),\n  )\n    .pipe(take(1))\n    .subscribe({\n      next: (statements) => console.log(statements),\n      error: (error) => console.error("subscribe failed:", error),\n      complete: () => console.log("completed"),\n    });\n}',
+                requestType: "remote-statement-store-subscribe-request",
+                responseType: "remote-statement-store-subscribe-item",
             },
             {
                 name: "create_proof",
                 type: "unary",
-                description: "Create a proof for a statement.",
+                signature: "createProof(request: RemoteStatementStoreCreateProofRequest): Promise<Result<RemoteStatementStoreCreateProofResponse, RemoteStatementStoreCreateProofError>>",
+                docUrl: "api/statement_store/trait.StatementStore.html#method.create_proof",
+                description: "Create a proof for a statement.\n\n**Deprecated:** use [`create_proof_authorized`](Self::create_proof_authorized)\ninstead, which uses a pre-allocated allowance account and does not\nrequire a per-call signing prompt.",
                 requestDescription: "RemoteStatementStoreCreateProofRequest",
-                defaultRequest: '{\n  "productAccountId": {\n    "derivationIndex": 0,\n    "dotNsIdentifier": "truapi-playground.dot"\n  },\n  "statement": {\n    "expiry": "9999999999999n",\n    "topics": []\n  }\n}',
+                exampleSource: '// Expiry packs a Unix-seconds timestamp in the high 32 bits; a day out\n// keeps the statement unexpired when it is submitted.\nconst expiry = BigInt(Math.floor(Date.now() / 1000) + 86400) << 32n;\nconst result = await truapi.statementStore.createProof({\n  productAccountId: {\n    dotNsIdentifier: "truapi-playground.dot",\n    derivationIndex: 0,\n  },\n  statement: {\n    expiry,\n    topics: [],\n  },\n});\nresult.match(\n  (value) => console.log(value),\n  (error) => console.error(error),\n);',
+                requestType: "remote-statement-store-create-proof-request",
+                responseType: "remote-statement-store-create-proof-response",
+                errorType: "remote-statement-store-create-proof-error",
             },
             {
                 name: "submit",
                 type: "unary",
+                signature: "submit(request: SignedStatement): Promise<Result<undefined, GenericError>>",
+                docUrl: "api/statement_store/trait.StatementStore.html#method.submit",
                 description: "Submit a signed statement to the network. The request body is the\n[`SignedStatement`](crate::v01::SignedStatement) directly (no wrapping\nstruct), matching upstream `triangle-js-sdks`.",
                 requestDescription: "SignedStatement",
-                defaultRequest: '{\n  "proof": {\n    "tag": "Sr25519",\n    "value": {\n      "signature": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",\n      "signer": "0x0000000000000000000000000000000000000000000000000000000000000000"\n    }\n  },\n  "topics": []\n}',
+                exampleSource: '// Expiry packs a Unix-seconds timestamp in the high 32 bits; a day out\n// keeps the statement unexpired when it is submitted.\nconst expiry = BigInt(Math.floor(Date.now() / 1000) + 86400) << 32n;\nconst proofResult = await truapi.statementStore.createProof({\n  productAccountId: {\n    dotNsIdentifier: "truapi-playground.dot",\n    derivationIndex: 0,\n  },\n  statement: {\n    expiry,\n    topics: [],\n  },\n});\nif (proofResult.isErr()) {\n  console.error("createProof failed:", proofResult.error);\n} else {\n  const result = await truapi.statementStore.submit({\n    proof: proofResult.value.proof,\n    topics: [],\n  });\n  result.match(\n    () => console.log("ok"),\n    (error) => console.error("submit failed:", error),\n  );\n}',
+                requestType: "signed-statement",
+                errorType: "generic-error",
             },
             {
                 name: "create_proof_authorized",
                 type: "unary",
+                signature: "createProofAuthorized(request: Statement): Promise<Result<RemoteStatementStoreCreateProofResponse, RemoteStatementStoreCreateProofError>>",
+                docUrl: "api/statement_store/trait.StatementStore.html#method.create_proof_authorized",
                 description: "Create a proof for a statement using a pre-allocated allowance account,\nbypassing the per-call signing prompt.",
                 requestDescription: "Statement",
-                defaultRequest: '{\n  "expiry": "9999999999999n",\n  "topics": []\n}',
+                exampleSource: "// Expiry packs a Unix-seconds timestamp in the high 32 bits; a day out\n// keeps the statement unexpired when it is submitted.\nconst expiry = BigInt(Math.floor(Date.now() / 1000) + 86400) << 32n;\nconst result = await truapi.statementStore.createProofAuthorized({\n  expiry,\n  topics: [],\n});\nresult.match(\n  (value) => console.log(value),\n  (error) => console.error(error),\n);",
+                requestType: "statement",
+                responseType: "remote-statement-store-create-proof-response",
+                errorType: "remote-statement-store-create-proof-error",
             },
         ],
     },
@@ -416,29 +649,36 @@ export const services = [
             {
                 name: "handshake",
                 type: "unary",
+                signature: "handshake(request: HostHandshakeRequest): Promise<Result<undefined, HostHandshakeError>>",
+                docUrl: "api/system/trait.System.html#method.handshake",
                 description: "Negotiate the wire codec version with the product.",
                 requestDescription: "HostHandshakeRequest",
+                exampleSource: 'const result = await truapi.system.handshake();\nresult.match(\n  () => console.log("ok"),\n  (error) => console.error(error),\n);',
+                requestType: "host-handshake-request",
+                errorType: "host-handshake-error",
             },
             {
                 name: "feature_supported",
                 type: "unary",
+                signature: "featureSupported(request: HostFeatureSupportedRequest): Promise<Result<HostFeatureSupportedResponse, GenericError>>",
+                docUrl: "api/system/trait.System.html#method.feature_supported",
                 description: "Query whether the host supports a specific feature.",
                 requestDescription: "HostFeatureSupportedRequest",
-                defaultRequest: '{\n  "tag": "Chain",\n  "value": {\n    "genesisHash": "0xd6eec26135305a8ad257a20d003357284c8aa03d0bdb2b357ab0a22371e11ef2"\n  }\n}',
-            },
-            {
-                name: "push_notification",
-                type: "unary",
-                description: "Send a push notification to the user.",
-                requestDescription: "HostPushNotificationRequest",
-                defaultRequest: '{\n  "text": "Hello!"\n}',
+                exampleSource: 'import { PASEO_NEXT_V2_ASSET_HUB } from "@parity/truapi";\n\nconst result = await truapi.system.featureSupported({\n  tag: "Chain",\n  value: {\n    genesisHash: PASEO_NEXT_V2_ASSET_HUB.genesis,\n  },\n});\nresult.match(\n  (value) => console.log(value.supported),\n  (error) => console.error(error),\n);',
+                requestType: "host-feature-supported-request",
+                responseType: "host-feature-supported-response",
+                errorType: "generic-error",
             },
             {
                 name: "navigate_to",
                 type: "unary",
+                signature: "navigateTo(request: HostNavigateToRequest): Promise<Result<undefined, HostNavigateToError>>",
+                docUrl: "api/system/trait.System.html#method.navigate_to",
                 description: "Request the host to open a URL.",
                 requestDescription: "HostNavigateToRequest",
-                defaultRequest: '{\n  "url": "https://example.com"\n}',
+                exampleSource: 'const result = await truapi.system.navigateTo({\n  url: "https://example.com",\n});\nresult.match(\n  () => console.log("ok"),\n  (error) => console.error(error),\n);',
+                requestType: "host-navigate-to-request",
+                errorType: "host-navigate-to-error",
             },
         ],
     },
@@ -448,8 +688,11 @@ export const services = [
             {
                 name: "subscribe",
                 type: "subscription",
+                signature: "subscribe(): ObservableLike<HostThemeSubscribeItem>",
+                docUrl: "api/theme/trait.Theme.html#method.subscribe",
                 description: "Subscribe to host theme changes.",
-                noParams: true,
+                exampleSource: 'import { from, take } from "rxjs";\n\nfrom(truapi.theme.subscribe())\n  .pipe(take(3))\n  .subscribe({\n    next: (theme) => console.log(theme),\n    error: (error) => console.error(error),\n    complete: () => console.log("completed"),\n  });',
+                responseType: "host-theme-subscribe-item",
             },
         ],
     },