@sats-connect/core 0.16.0-2dd02aa → 0.16.0-4c59967

package/dist/index.d.cts

@@ -0,0 +1,4173 @@
+import * as v from "valibot";
+
+//#region src/types.d.ts
+declare enum BitcoinNetworkType {
+  Mainnet = "Mainnet",
+  Testnet = "Testnet",
+  Testnet4 = "Testnet4",
+  Signet = "Signet",
+  Regtest = "Regtest",
+}
+declare enum StacksNetworkType {
+  Mainnet = "mainnet",
+  Testnet = "testnet",
+}
+declare enum StarknetNetworkType {
+  Mainnet = "mainnet",
+  Sepolia = "sepolia",
+}
+declare enum SparkNetworkType {
+  Mainnet = "mainnet",
+  Regtest = "regtest",
+}
+interface BitcoinNetwork {
+  type: BitcoinNetworkType;
+  address?: string;
+}
+interface RequestPayload {
+  network: BitcoinNetwork;
+}
+interface RequestOptions<Payload extends RequestPayload, Response> {
+  onFinish: (response: Response) => void;
+  onCancel: () => void;
+  payload: Payload;
+  getProvider?: () => Promise<BitcoinProvider | undefined>;
+}
+declare const RpcIdSchema: v.OptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.NullSchema<undefined>], undefined>, undefined>;
+type RpcId = v.InferOutput<typeof RpcIdSchema>;
+declare const rpcRequestMessageSchema: v.ObjectSchema<{
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+  readonly method: v.StringSchema<undefined>;
+  readonly params: v.OptionalSchema<v.UnionSchema<[v.ArraySchema<v.UnknownSchema, undefined>, v.LooseObjectSchema<{}, undefined>, v.NullSchema<undefined>], undefined>, undefined>;
+  readonly id: v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.NullSchema<undefined>], undefined>;
+}, undefined>;
+type RpcRequestMessage = v.InferOutput<typeof rpcRequestMessageSchema>;
+interface RpcBase {
+  jsonrpc: '2.0';
+  id: RpcId;
+}
+interface RpcRequest<T extends string, U> extends RpcBase {
+  method: T;
+  params: U;
+}
+interface MethodParamsAndResult<TParams, TResult> {
+  params: TParams;
+  result: TResult;
+}
+/**
+ * @enum {number} RpcErrorCode
+ * @description JSON-RPC error codes
+ * @see https://www.jsonrpc.org/specification#error_object
+ */
+declare enum RpcErrorCode {
+  /**
+   * Parse error Invalid JSON
+   **/
+  PARSE_ERROR = -32700,
+  /**
+   * The JSON sent is not a valid Request object.
+   **/
+  INVALID_REQUEST = -32600,
+  /**
+   * The method does not exist/is not available.
+   **/
+  METHOD_NOT_FOUND = -32601,
+  /**
+   * Invalid method parameter(s).
+   */
+  INVALID_PARAMS = -32602,
+  /**
+   * Internal JSON-RPC error.
+   * This is a generic error, used when the server encounters an error in performing the request.
+   **/
+  INTERNAL_ERROR = -32603,
+  /**
+   * user rejected/canceled the request
+   */
+  USER_REJECTION = -32000,
+  /**
+   * method is not supported for the address provided
+   */
+  METHOD_NOT_SUPPORTED = -32001,
+  /**
+   * The client does not have permission to access the requested resource.
+   */
+  ACCESS_DENIED = -32002,
+}
+declare const rpcSuccessResponseMessageSchema: v.ObjectSchema<{
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+  readonly result: v.NonOptionalSchema<v.UnknownSchema, undefined>;
+  readonly id: v.OptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.NullSchema<undefined>], undefined>, undefined>;
+}, undefined>;
+type RpcSuccessResponseMessage = v.InferOutput<typeof rpcSuccessResponseMessageSchema>;
+declare const rpcErrorResponseMessageSchema: v.ObjectSchema<{
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+  readonly error: v.NonOptionalSchema<v.UnknownSchema, undefined>;
+  readonly id: v.OptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.NullSchema<undefined>], undefined>, undefined>;
+}, undefined>;
+type RpcErrorResponseMessage = v.InferOutput<typeof rpcErrorResponseMessageSchema>;
+declare const rpcResponseMessageSchema: v.UnionSchema<[v.ObjectSchema<{
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+  readonly result: v.NonOptionalSchema<v.UnknownSchema, undefined>;
+  readonly id: v.OptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.NullSchema<undefined>], undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+  readonly error: v.NonOptionalSchema<v.UnknownSchema, undefined>;
+  readonly id: v.OptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.NullSchema<undefined>], undefined>, undefined>;
+}, undefined>], undefined>;
+type RpcResponseMessage = v.InferOutput<typeof rpcResponseMessageSchema>;
+interface RpcError {
+  code: number | RpcErrorCode;
+  message: string;
+  data?: any;
+}
+interface RpcErrorResponse<TError extends RpcError = RpcError> extends RpcBase {
+  error: TError;
+}
+interface RpcSuccessResponse<Method$1 extends keyof RpcRequests> extends RpcBase {
+  result: RpcSuccessResponseResult<Method$1>;
+}
+type RpcResponse<Method$1 extends keyof RpcRequests> = RpcSuccessResponse<Method$1> | RpcErrorResponse;
+type RpcResult<Method$1 extends keyof RpcRequests> = {
+  result: RpcSuccessResponse<Method$1>['result'];
+  status: 'success';
+} | {
+  error: RpcErrorResponse['error'];
+  status: 'error';
+};
+//#endregion
+//#region src/addresses/types.d.ts
+declare enum AddressPurpose {
+  Ordinals = "ordinals",
+  Payment = "payment",
+  Stacks = "stacks",
+  Starknet = "starknet",
+  Spark = "spark",
+}
+interface GetAddressPayload extends RequestPayload {
+  purposes: AddressPurpose[];
+  message: string;
+}
+declare enum AddressType {
+  p2pkh = "p2pkh",
+  p2sh = "p2sh",
+  p2wpkh = "p2wpkh",
+  p2wsh = "p2wsh",
+  p2tr = "p2tr",
+  stacks = "stacks",
+  starknet = "starknet",
+  spark = "spark",
+}
+declare const addressSchema: v.ObjectSchema<{
+  readonly address: v.StringSchema<undefined>;
+  readonly publicKey: v.StringSchema<undefined>;
+  readonly purpose: v.EnumSchema<typeof AddressPurpose, undefined>;
+  readonly addressType: v.EnumSchema<typeof AddressType, undefined>;
+  readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone"], undefined>;
+}, undefined>;
+type Address = v.InferOutput<typeof addressSchema>;
+interface GetAddressResponse {
+  addresses: Address[];
+}
+type GetAddressOptions = RequestOptions<GetAddressPayload, GetAddressResponse>;
+//#endregion
+//#region src/addresses/index.d.ts
+/**
+ * @deprecated Use `request()` instead
+ */
+declare const getAddress: (options: GetAddressOptions) => Promise<void>;
+//#endregion
+//#region src/capabilities/types.d.ts
+interface GetCapabilitiesPayload extends RequestPayload {}
+type GetCapabilitiesResponse = Capability[];
+type GetCapabilitiesOptions = RequestOptions<GetCapabilitiesPayload, GetCapabilitiesResponse>;
+//#endregion
+//#region src/capabilities/index.d.ts
+declare const getCapabilities: (options: GetCapabilitiesOptions) => Promise<void>;
+//#endregion
+//#region src/inscriptions/types.d.ts
+interface CreateInscriptionPayload extends RequestPayload {
+  contentType: string;
+  content: string;
+  payloadType: 'PLAIN_TEXT' | 'BASE_64';
+  appFee?: number;
+  appFeeAddress?: string;
+  suggestedMinerFeeRate?: number;
+  token?: string;
+}
+interface CreateRepeatInscriptionsPayload extends CreateInscriptionPayload {
+  repeat: number;
+}
+type CreateInscriptionResponse = {
+  txId: string;
+};
+type CreateRepeatInscriptionsResponse = {
+  txId: string;
+};
+type CreateInscriptionOptions = RequestOptions<CreateInscriptionPayload, CreateInscriptionResponse>;
+type CreateRepeatInscriptionsOptions = RequestOptions<CreateRepeatInscriptionsPayload, CreateRepeatInscriptionsResponse>;
+//#endregion
+//#region src/inscriptions/createInscription.d.ts
+declare const createInscription: (options: CreateInscriptionOptions) => Promise<void>;
+//#endregion
+//#region src/inscriptions/createRepeatInscriptions.d.ts
+declare const createRepeatInscriptions: (options: CreateRepeatInscriptionsOptions) => Promise<void>;
+//#endregion
+//#region src/messages/types.d.ts
+interface SignMessagePayload extends RequestPayload {
+  address: string;
+  message: string;
+  protocol?: MessageSigningProtocols;
+}
+type SignMessageResponse = string;
+type SignMessageOptions = RequestOptions<SignMessagePayload, SignMessageResponse>;
+//#endregion
+//#region src/messages/index.d.ts
+declare const signMessage: (options: SignMessageOptions) => Promise<void>;
+//#endregion
+//#region src/transactions/types.d.ts
+interface Recipient {
+  address: string;
+  amountSats: bigint;
+}
+type SerializedRecipient = Omit<Recipient, 'amountSats'> & {
+  amountSats: string;
+};
+interface SendBtcTransactionPayload extends RequestPayload {
+  recipients: Recipient[];
+  senderAddress: string;
+  message?: string;
+}
+type SerializedSendBtcTransactionPayload = Omit<SendBtcTransactionPayload, 'recipients'> & {
+  recipients: SerializedRecipient[];
+};
+type SendBtcTransactionResponse = string;
+type SendBtcTransactionOptions = RequestOptions<SendBtcTransactionPayload, SendBtcTransactionResponse>;
+interface InputToSign {
+  address: string;
+  signingIndexes: number[];
+  sigHash?: number;
+}
+type PsbtPayload = {
+  psbtBase64: string;
+  inputsToSign?: InputToSign[];
+  broadcast?: boolean;
+};
+type SignMultiplePsbtPayload = {
+  psbtBase64: string;
+  inputsToSign?: InputToSign[];
+};
+interface SignTransactionPayload extends RequestPayload, PsbtPayload {
+  message: string;
+}
+interface SignTransactionResponse {
+  psbtBase64: string;
+  txId?: string;
+}
+type SignTransactionOptions = RequestOptions<SignTransactionPayload, SignTransactionResponse>;
+interface SignMultipleTransactionsPayload extends RequestPayload {
+  message: string;
+  psbts: SignMultiplePsbtPayload[];
+}
+type SignMultipleTransactionsResponse = SignTransactionResponse[];
+type SignMultipleTransactionOptions = RequestOptions<SignMultipleTransactionsPayload, SignMultipleTransactionsResponse>;
+//#endregion
+//#region src/transactions/sendBtcTransaction.d.ts
+declare const sendBtcTransaction: (options: SendBtcTransactionOptions) => Promise<void>;
+//#endregion
+//#region src/transactions/signTransaction.d.ts
+declare const signTransaction: (options: SignTransactionOptions) => Promise<void>;
+//#endregion
+//#region src/transactions/signMultipleTransactions.d.ts
+declare const signMultipleTransactions: (options: SignMultipleTransactionOptions) => Promise<void>;
+//#endregion
+//#region src/provider/types.d.ts
+declare const accountChangeEventName = "accountChange";
+declare const accountChangeSchema: v.ObjectSchema<{
+  readonly type: v.LiteralSchema<"accountChange", undefined>;
+  readonly addresses: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+    readonly address: v.StringSchema<undefined>;
+    readonly publicKey: v.StringSchema<undefined>;
+    readonly purpose: v.EnumSchema<typeof AddressPurpose, undefined>;
+    readonly addressType: v.EnumSchema<typeof AddressType, undefined>;
+    readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone"], undefined>;
+  }, undefined>, undefined>, undefined>;
+}, undefined>;
+type AccountChangeEvent = v.InferOutput<typeof accountChangeSchema>;
+declare const networkChangeEventName = "networkChange";
+declare const networkChangeSchema: v.ObjectSchema<{
+  readonly type: v.LiteralSchema<"networkChange", undefined>;
+  readonly bitcoin: v.ObjectSchema<{
+    readonly name: v.EnumSchema<typeof BitcoinNetworkType, undefined>;
+  }, undefined>;
+  readonly stacks: v.ObjectSchema<{
+    readonly name: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly addresses: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+    readonly address: v.StringSchema<undefined>;
+    readonly publicKey: v.StringSchema<undefined>;
+    readonly purpose: v.EnumSchema<typeof AddressPurpose, undefined>;
+    readonly addressType: v.EnumSchema<typeof AddressType, undefined>;
+    readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone"], undefined>;
+  }, undefined>, undefined>, undefined>;
+}, undefined>;
+type NetworkChangeEvent = v.InferOutput<typeof networkChangeSchema>;
+declare const networkChangeEventNameV2 = "networkChangeV2";
+declare const networkChangeV2Schema: v.ObjectSchema<{
+  readonly type: v.LiteralSchema<"networkChange", undefined>;
+  readonly networks: v.ObjectSchema<{
+    readonly bitcoin: v.ObjectSchema<{
+      readonly mode: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EnumSchema<{
+        readonly mainnet: "mainnet";
+        readonly testnet: "testnet";
+        readonly testnet4: "testnet4";
+        readonly signet: "signet";
+        readonly regtest: "regtest";
+      }, undefined>]>;
+      readonly xverseApiUrl: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UrlAction<string, undefined>]>;
+      readonly electrsApiUrl: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UrlAction<string, undefined>]>;
+      readonly id: v.StringSchema<undefined>;
+      readonly name: v.StringSchema<undefined>;
+      readonly blockExplorerUrl: v.OptionalSchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.LiteralSchema<"", undefined>, v.TransformAction<"", undefined>]>, v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UrlAction<string, undefined>]>], undefined>, undefined>;
+      readonly chain: v.LiteralSchema<"bitcoin", undefined>;
+    }, undefined>;
+    readonly spark: v.ObjectSchema<{
+      readonly mode: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EnumSchema<{
+        readonly mainnet: "mainnet";
+        readonly regtest: "regtest";
+      }, undefined>]>;
+      readonly electrsApiUrl: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UrlAction<string, undefined>]>;
+      readonly id: v.StringSchema<undefined>;
+      readonly name: v.StringSchema<undefined>;
+      readonly blockExplorerUrl: v.OptionalSchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.LiteralSchema<"", undefined>, v.TransformAction<"", undefined>]>, v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UrlAction<string, undefined>]>], undefined>, undefined>;
+      readonly chain: v.LiteralSchema<"spark", undefined>;
+    }, undefined>;
+    readonly stacks: v.ObjectSchema<{
+      readonly mode: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EnumSchema<{
+        readonly mainnet: "mainnet";
+        readonly testnet: "testnet";
+        readonly devnet: "devnet";
+        readonly mocknet: "mocknet";
+      }, undefined>]>;
+      readonly stacksApiUrl: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UrlAction<string, undefined>]>;
+      readonly xverseApiUrl: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UrlAction<string, undefined>]>;
+      readonly id: v.StringSchema<undefined>;
+      readonly name: v.StringSchema<undefined>;
+      readonly blockExplorerUrl: v.OptionalSchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.LiteralSchema<"", undefined>, v.TransformAction<"", undefined>]>, v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UrlAction<string, undefined>]>], undefined>, undefined>;
+      readonly chain: v.LiteralSchema<"stacks", undefined>;
+    }, undefined>;
+    readonly starknet: v.ObjectSchema<{
+      readonly mode: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EnumSchema<{
+        readonly mainnet: "mainnet";
+        readonly sepolia: "sepolia";
+      }, undefined>]>;
+      readonly rpcApiUrl: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UrlAction<string, undefined>]>;
+      readonly xverseApiUrl: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UrlAction<string, undefined>]>;
+      readonly id: v.StringSchema<undefined>;
+      readonly name: v.StringSchema<undefined>;
+      readonly blockExplorerUrl: v.OptionalSchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.LiteralSchema<"", undefined>, v.TransformAction<"", undefined>]>, v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UrlAction<string, undefined>]>], undefined>, undefined>;
+      readonly chain: v.LiteralSchema<"starknet", undefined>;
+    }, undefined>;
+  }, undefined>;
+  readonly addresses: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+    readonly address: v.StringSchema<undefined>;
+    readonly publicKey: v.StringSchema<undefined>;
+    readonly purpose: v.EnumSchema<typeof AddressPurpose, undefined>;
+    readonly addressType: v.EnumSchema<typeof AddressType, undefined>;
+    readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone"], undefined>;
+  }, undefined>, undefined>, undefined>;
+}, undefined>;
+type NetworkChangeEventV2 = v.InferOutput<typeof networkChangeSchema>;
+declare const disconnectEventName = "disconnect";
+declare const disconnectSchema: v.ObjectSchema<{
+  readonly type: v.LiteralSchema<"disconnect", undefined>;
+}, undefined>;
+type DisconnectEvent = v.InferOutput<typeof disconnectSchema>;
+declare const walletEventSchema: v.VariantSchema<"type", [v.ObjectSchema<{
+  readonly type: v.LiteralSchema<"accountChange", undefined>;
+  readonly addresses: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+    readonly address: v.StringSchema<undefined>;
+    readonly publicKey: v.StringSchema<undefined>;
+    readonly purpose: v.EnumSchema<typeof AddressPurpose, undefined>;
+    readonly addressType: v.EnumSchema<typeof AddressType, undefined>;
+    readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone"], undefined>;
+  }, undefined>, undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+  readonly type: v.LiteralSchema<"networkChange", undefined>;
+  readonly bitcoin: v.ObjectSchema<{
+    readonly name: v.EnumSchema<typeof BitcoinNetworkType, undefined>;
+  }, undefined>;
+  readonly stacks: v.ObjectSchema<{
+    readonly name: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly addresses: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+    readonly address: v.StringSchema<undefined>;
+    readonly publicKey: v.StringSchema<undefined>;
+    readonly purpose: v.EnumSchema<typeof AddressPurpose, undefined>;
+    readonly addressType: v.EnumSchema<typeof AddressType, undefined>;
+    readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone"], undefined>;
+  }, undefined>, undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+  readonly type: v.LiteralSchema<"disconnect", undefined>;
+}, undefined>], undefined>;
+type WalletEvent = v.InferOutput<typeof walletEventSchema>;
+type AccountChangeCallback = (e: AccountChangeEvent) => void;
+type DisconnectCallback = (e: DisconnectEvent) => void;
+type NetworkChangeCallback = (e: NetworkChangeEvent) => void;
+type ListenerInfo = {
+  eventName: typeof accountChangeEventName;
+  cb: AccountChangeCallback;
+} | {
+  eventName: typeof disconnectEventName;
+  cb: DisconnectCallback;
+} | {
+  eventName: typeof networkChangeEventName;
+  cb: NetworkChangeCallback;
+};
+type AddListener = (arg: ListenerInfo) => () => void;
+interface BaseBitcoinProvider {
+  request: <Method$1 extends keyof RpcRequests>(method: Method$1, options: RpcRequestParams<Method$1>, providerId?: string) => Promise<RpcResponse<Method$1>>;
+  connect: (request: string) => Promise<GetAddressResponse>;
+  signMessage: (request: string) => Promise<SignMessageResponse>;
+  signTransaction: (request: string) => Promise<SignTransactionResponse>;
+  sendBtcTransaction: (request: string) => Promise<SendBtcTransactionResponse>;
+  createInscription: (request: string) => Promise<CreateInscriptionResponse>;
+  createRepeatInscriptions: (request: string) => Promise<CreateRepeatInscriptionsResponse>;
+  signMultipleTransactions: (request: string) => Promise<SignMultipleTransactionsResponse>;
+  addListener: AddListener;
+}
+type Capability = keyof BaseBitcoinProvider;
+interface BitcoinProvider extends BaseBitcoinProvider {
+  getCapabilities?: (request: string) => Promise<GetCapabilitiesResponse>;
+}
+interface Provider {
+  id: string;
+  name: string;
+  icon: string;
+  webUrl?: string;
+  chromeWebStoreUrl?: string;
+  mozillaAddOnsUrl?: string;
+  googlePlayStoreUrl?: string;
+  iOSAppStoreUrl?: string;
+  methods?: (StacksMethod | BitcoinMethod | RunesMethod | OrdinalsMethod)[];
+}
+interface SupportedWallet extends Provider {
+  isInstalled: boolean;
+}
+declare global {
+  interface XverseProviders {
+    BitcoinProvider?: BitcoinProvider;
+  }
+  interface Window {
+    BitcoinProvider?: BitcoinProvider;
+    XverseProviders?: XverseProviders;
+    btc_providers?: Provider[];
+  }
+}
+//#endregion
+//#region src/provider/index.d.ts
+declare function getProviderOrThrow(getProvider?: () => Promise<BitcoinProvider | undefined>): Promise<BitcoinProvider>;
+declare function getProviders(): Provider[];
+declare function getProviderById(providerId: string): any;
+declare function isProviderInstalled(providerId: string): boolean;
+declare function setDefaultProvider(providerId: string): void;
+declare function getDefaultProvider(): string | null;
+declare function removeDefaultProvider(): void;
+declare function getSupportedWallets(): SupportedWallet[];
+//#endregion
+//#region src/request/rpc/methodSchemas/bitcoin/getInfo/response.d.ts
+declare enum ProviderPlatform {
+  Web = "web",
+  Mobile = "mobile",
+}
+declare const bitcoinGetInfoSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    /**
+     * Version of the wallet.
+     */
+    readonly version: v.StringSchema<undefined>;
+    /**
+     * The platform the wallet is running on (web or mobile).
+     */
+    readonly platform: v.OptionalSchema<v.EnumSchema<typeof ProviderPlatform, undefined>, undefined>;
+    /**
+     * [WBIP](https://wbips.netlify.app/wbips/WBIP002) methods supported by the wallet.
+     */
+    readonly methods: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+    /**
+     * List of WBIP standards supported by the wallet. Not currently used.
+     */
+    readonly supports: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"getInfo", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type BitcoinGetInfoSuccessResponse = v.InferOutput<typeof bitcoinGetInfoSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/bitcoin/getInfoV2/response.d.ts
+declare enum ProviderPlatform$1 {
+  Web = "web",
+  Mobile = "mobile",
+}
+declare const bitcoinGetInfoV2SuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    /**
+     * Version of the wallet.
+     */
+    readonly version: v.StringSchema<undefined>;
+    /**
+     * The platform the wallet is running on (web or mobile).
+     */
+    readonly platform: v.OptionalSchema<v.EnumSchema<typeof ProviderPlatform$1, undefined>, undefined>;
+    /**
+     * [WBIP](https://wbips.netlify.app/wbips/WBIP002) methods supported by the wallet.
+     */
+    readonly methods: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+    /**
+     * List of WBIP standards supported by the wallet. Not currently used.
+     */
+    readonly supports: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"bitcoin_getInfoV2", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type BitcoinGetInfoV2SuccessResponse = v.InferOutput<typeof bitcoinGetInfoV2SuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/bitcoin/signMessage/response.d.ts
+declare enum MessageSigningProtocols$7 {
+  ECDSA = "ECDSA",
+  BIP322 = "BIP322",
+}
+declare const bitcoinSignMessageSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    /**
+     * The signature of the message.
+     */
+    readonly signature: v.StringSchema<undefined>;
+    /**
+     * hash of the message.
+     */
+    readonly messageHash: v.StringSchema<undefined>;
+    /**
+     * The address used for signing.
+     */
+    readonly address: v.StringSchema<undefined>;
+    /**
+     * The protocol used for signing the message.
+     */
+    readonly protocol: v.EnumSchema<typeof MessageSigningProtocols$7, undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"signMessage", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type BitcoinSignMessageSuccessResponse = v.InferOutput<typeof bitcoinSignMessageSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/bitcoin/signMessageV2/response.d.ts
+declare enum MessageSigningProtocols$6 {
+  ECDSA = "ECDSA",
+  BIP322 = "BIP322",
+}
+declare const bitcoinSignMessageV2SuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    /**
+     * The signature of the message.
+     */
+    readonly signature: v.StringSchema<undefined>;
+    /**
+     * hash of the message.
+     */
+    readonly messageHash: v.StringSchema<undefined>;
+    /**
+     * The address used for signing.
+     */
+    readonly address: v.StringSchema<undefined>;
+    /**
+     * The protocol used for signing the message.
+     */
+    readonly protocol: v.EnumSchema<typeof MessageSigningProtocols$6, undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"bitcoin_signMessageV2", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type BitcoinSignMessageV2SuccessResponse = v.InferOutput<typeof bitcoinSignMessageV2SuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/bitcoin/signMultipleMessages/response.d.ts
+declare enum MessageSigningProtocols$5 {
+  ECDSA = "ECDSA",
+  BIP322 = "BIP322",
+}
+declare const bitcoinSignMultipleMessagesSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ArraySchema<v.ObjectSchema<{
+    /**
+     * The signature of the message.
+     */
+    readonly signature: v.StringSchema<undefined>;
+    /**
+     * The original message which was signed.
+     */
+    readonly message: v.StringSchema<undefined>;
+    /**
+     * Hash of the message.
+     */
+    readonly messageHash: v.StringSchema<undefined>;
+    /**
+     * The address used for signing.
+     */
+    readonly address: v.StringSchema<undefined>;
+    /**
+     * The protocol used for signing the message.
+     */
+    readonly protocol: v.EnumSchema<typeof MessageSigningProtocols$5, undefined>;
+  }, undefined>, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"signMultipleMessages", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type BitcoinSignMultipleMessagesSuccessResponse = v.InferOutput<typeof bitcoinSignMultipleMessagesSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/bitcoin/signMultipleMessagesV2/response.d.ts
+declare enum MessageSigningProtocols$4 {
+  ECDSA = "ECDSA",
+  BIP322 = "BIP322",
+}
+declare const bitcoinSignMultipleMessagesV2SuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ArraySchema<v.ObjectSchema<{
+    /**
+     * The signature of the message.
+     */
+    readonly signature: v.StringSchema<undefined>;
+    /**
+     * The original message which was signed.
+     */
+    readonly message: v.StringSchema<undefined>;
+    /**
+     * Hash of the message.
+     */
+    readonly messageHash: v.StringSchema<undefined>;
+    /**
+     * The address used for signing.
+     */
+    readonly address: v.StringSchema<undefined>;
+    /**
+     * The protocol used for signing the message.
+     */
+    readonly protocol: v.EnumSchema<typeof MessageSigningProtocols$4, undefined>;
+  }, undefined>, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"bitcoin_signMultipleMessagesV2", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type BitcoinSignMultipleMessagesV2SuccessResponse = v.InferOutput<typeof bitcoinSignMultipleMessagesV2SuccessResponseSchema>;
+//#endregion
+//#region src/request/methods.d.ts
+declare const bitcoinMethods: {
+  readonly getAccounts: "getAccounts";
+  readonly bitcoin_getAccountsV2: "bitcoin_getAccountsV2";
+  readonly getAddresses: "getAddresses";
+  readonly bitcoin_getAddressesV2: "bitcoin_getAddressesV2";
+  readonly getBalance: "getBalance";
+  readonly bitcoin_getBalanceV2: "bitcoin_getBalanceV2";
+  readonly getInfo: "getInfo";
+  readonly bitcoin_getInfoV2: "bitcoin_getInfoV2";
+  readonly sendTransfer: "sendTransfer";
+  readonly bitcoin_sendTransferV2: "bitcoin_sendTransferV2";
+  readonly signMessage: "signMessage";
+  readonly bitcoin_signMessageV2: "bitcoin_signMessageV2";
+  readonly signMultipleMessages: "signMultipleMessages";
+  readonly bitcoin_signMultipleMessagesV2: "bitcoin_signMultipleMessagesV2";
+  readonly signPsbt: "signPsbt";
+  readonly bitcoin_signPsbtV2: "bitcoin_signPsbtV2";
+};
+type BitcoinMethod = (typeof bitcoinMethods)[keyof typeof bitcoinMethods];
+declare const stacksMethods: {
+  readonly stx_callContract: "stx_callContract";
+  readonly stx_deployContract: "stx_deployContract";
+  readonly stx_getAccounts: "stx_getAccounts";
+  readonly stx_getAddresses: "stx_getAddresses";
+  readonly stacks_getAddressesV2: "stacks_getAddressesV2";
+  readonly stx_signMessage: "stx_signMessage";
+  readonly stx_signStructuredMessage: "stx_signStructuredMessage";
+  readonly stx_signTransaction: "stx_signTransaction";
+  readonly stx_signTransactions: "stx_signTransactions";
+  readonly stx_transferStx: "stx_transferStx";
+};
+type StacksMethod = (typeof stacksMethods)[keyof typeof stacksMethods];
+declare const sparkMethods: {
+  readonly spark_getAddresses: "spark_getAddresses";
+  readonly spark_getAddressesV2: "spark_getAddressesV2";
+  readonly spark_getBalance: "spark_getBalance";
+  readonly spark_transfer: "spark_transfer";
+  readonly spark_transferToken: "spark_transferToken";
+  readonly spark_signMessage: "spark_signMessage";
+  readonly spark_flashnet_getJwt: "spark_flashnet_getJwt";
+  readonly spark_flashnet_signIntent: "spark_flashnet_signIntent";
+  readonly spark_flashnet_signStructuredMessage: "spark_flashnet_signStructuredMessage";
+  readonly spark_flashnet_executeSwap: "spark_flashnet_executeSwap";
+  readonly spark_flashnet_executeRouteSwap: "spark_flashnet_executeRouteSwap";
+  readonly spark_flashnet_clawbackFunds: "spark_flashnet_clawbackFunds";
+  readonly spark_getClawbackEligibleTransfers: "spark_getClawbackEligibleTransfers";
+};
+type SparkMethod = (typeof sparkMethods)[keyof typeof sparkMethods];
+declare const runesMethods: {
+  readonly runes_estimateEtch: "runes_estimateEtch";
+  readonly runes_estimateMint: "runes_estimateMint";
+  readonly runes_estimateRbfOrder: "runes_estimateRbfOrder";
+  readonly runes_etch: "runes_etch";
+  readonly runes_getBalance: "runes_getBalance";
+  readonly runes_getOrder: "runes_getOrder";
+  readonly runes_mint: "runes_mint";
+  readonly runes_rbfOrder: "runes_rbfOrder";
+  readonly runes_transfer: "runes_transfer";
+};
+type RunesMethod = (typeof runesMethods)[keyof typeof runesMethods];
+declare const ordinalsMethods: {
+  readonly ord_getInscriptions: "ord_getInscriptions";
+  readonly ord_sendInscriptions: "ord_sendInscriptions";
+};
+type OrdinalsMethod = (typeof ordinalsMethods)[keyof typeof ordinalsMethods];
+declare const walletMethods: {
+  readonly wallet_addNetwork: "wallet_addNetwork";
+  readonly wallet_addNetworkV2: "wallet_addNetworkV2";
+  readonly wallet_changeNetworkById: "wallet_changeNetworkById";
+  readonly wallet_changeNetwork: "wallet_changeNetwork";
+  readonly wallet_connect: "wallet_connect";
+  readonly wallet_connectV2: "wallet_connectV2";
+  readonly wallet_disconnect: "wallet_disconnect";
+  readonly wallet_getAccount: "wallet_getAccount";
+  readonly wallet_getAccountV2: "wallet_getAccountV2";
+  readonly wallet_getCurrentPermissions: "wallet_getCurrentPermissions";
+  readonly wallet_getNetwork: "wallet_getNetwork";
+  readonly wallet_getNetworks: "wallet_getNetworks";
+  readonly wallet_getWalletType: "wallet_getWalletType";
+  readonly wallet_openBridge: "wallet_openBridge";
+  readonly wallet_openBuy: "wallet_openBuy";
+  readonly wallet_openReceive: "wallet_openReceive";
+  readonly wallet_renouncePermissions: "wallet_renouncePermissions";
+  readonly wallet_requestPermissions: "wallet_requestPermissions";
+};
+type WalletMethod = (typeof walletMethods)[keyof typeof walletMethods];
+type Method = BitcoinMethod | StacksMethod | SparkMethod | RunesMethod | OrdinalsMethod | WalletMethod;
+//#endregion
+//#region src/request/exact.d.ts
+/**
+ * These types allow expressing type constraints akin to exact or sealed types
+ * available in other type systems. Start by defining a union of the keys the
+ * object should have, and then build the final type with `ExactObject`.
+ *
+ * Example:
+ *
+ * ```ts
+ * type Fruit = "apple" | "banana" | "cherry";
+ * type PackagingContainer = ExactObject<Fruit, {
+ *   apple: "bag";
+ *   banana: "box";
+ *   cherry: "bag" | "box"
+ * }>;
+ * ```
+ *
+ * If the keys union and those used in ExactObject don't match, the resulting
+ * type will safely evaluate to `never`.
+ */
+type KeysTemplate<Keys extends string> = { [K in Keys]: unknown };
+type ExactKeys<T, U> = keyof T extends keyof U ? (keyof U extends keyof T ? T : never) : never;
+type ExactObject<Keys extends string, T extends KeysTemplate<Keys>> = ExactKeys<T, KeysTemplate<Keys>>;
+//#endregion
+//#region src/request/rpc/methodSchemas/bitcoin/getAccounts/response.d.ts
+declare const bitcoinGetAccountsSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ArraySchema<v.ObjectSchema<{
+    readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone"], undefined>;
+    readonly address: v.StringSchema<undefined>;
+    readonly publicKey: v.StringSchema<undefined>;
+    readonly purpose: v.EnumSchema<typeof AddressPurpose, undefined>;
+    readonly addressType: v.EnumSchema<typeof AddressType, undefined>;
+  }, undefined>, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"getAccounts", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type BitcoinGetAccountsSuccessResponse = v.InferOutput<typeof bitcoinGetAccountsSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/bitcoin/getAccountsV2/response.d.ts
+declare const bitcoinGetAccountsV2SuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ArraySchema<v.ObjectSchema<{
+    readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone"], undefined>;
+    readonly address: v.StringSchema<undefined>;
+    readonly publicKey: v.StringSchema<undefined>;
+    readonly purpose: v.EnumSchema<typeof AddressPurpose, undefined>;
+    readonly addressType: v.EnumSchema<typeof AddressType, undefined>;
+  }, undefined>, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"bitcoin_getAccountsV2", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type BitcoinGetAccountsV2SuccessResponse = v.InferOutput<typeof bitcoinGetAccountsV2SuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/bitcoin/getAddresses/response.d.ts
+declare const bitcoinGetAddressesSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    /**
+     * The addresses generated for the given purposes.
+     */
+    readonly addresses: v.ArraySchema<v.ObjectSchema<{
+      readonly address: v.StringSchema<undefined>;
+      readonly publicKey: v.StringSchema<undefined>;
+      readonly purpose: v.EnumSchema<typeof AddressPurpose, undefined>;
+      readonly addressType: v.EnumSchema<typeof AddressType, undefined>;
+      readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone"], undefined>;
+    }, undefined>, undefined>;
+    readonly network: v.ObjectSchema<{
+      readonly bitcoin: v.ObjectSchema<{
+        readonly name: v.StringSchema<undefined>;
+      }, undefined>;
+      readonly stacks: v.ObjectSchema<{
+        readonly name: v.StringSchema<undefined>;
+      }, undefined>;
+      readonly spark: v.ObjectSchema<{
+        readonly name: v.StringSchema<undefined>;
+      }, undefined>;
+    }, undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"getAddresses", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type BitcoinGetAddressesSuccessResponse = v.InferOutput<typeof bitcoinGetAddressesSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/bitcoin/getAddressesV2/response.d.ts
+declare const bitcoinGetAddressesV2SuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    /**
+     * The addresses generated for the given purposes.
+     */
+    readonly addresses: v.ArraySchema<v.ObjectSchema<{
+      readonly address: v.StringSchema<undefined>;
+      readonly publicKey: v.StringSchema<undefined>;
+      readonly purpose: v.EnumSchema<typeof AddressPurpose, undefined>;
+      readonly addressType: v.EnumSchema<typeof AddressType, undefined>;
+      readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone"], undefined>;
+    }, undefined>, undefined>;
+    readonly networks: v.ObjectSchema<{
+      readonly active: v.ObjectSchema<{
+        readonly bitcoin: v.ObjectSchema<{
+          readonly id: v.StringSchema<undefined>;
+          readonly type: v.StringSchema<undefined>;
+          readonly name: v.StringSchema<undefined>;
+        }, undefined>;
+        readonly stacks: v.ObjectSchema<{
+          readonly id: v.StringSchema<undefined>;
+          readonly type: v.StringSchema<undefined>;
+          readonly name: v.StringSchema<undefined>;
+        }, undefined>;
+        readonly spark: v.ObjectSchema<{
+          readonly id: v.StringSchema<undefined>;
+          readonly type: v.StringSchema<undefined>;
+          readonly name: v.StringSchema<undefined>;
+        }, undefined>;
+        readonly starknet: v.ObjectSchema<{
+          readonly id: v.StringSchema<undefined>;
+          readonly type: v.StringSchema<undefined>;
+          readonly name: v.StringSchema<undefined>;
+        }, undefined>;
+      }, undefined>;
+      readonly builtin: v.ObjectSchema<{
+        readonly bitcoin: v.ArraySchema<v.AnySchema, undefined>;
+        readonly stacks: v.ArraySchema<v.AnySchema, undefined>;
+        readonly spark: v.ArraySchema<v.AnySchema, undefined>;
+        readonly starknet: v.ArraySchema<v.AnySchema, undefined>;
+      }, undefined>;
+      readonly custom: v.ObjectSchema<{
+        readonly bitcoin: v.ArraySchema<v.AnySchema, undefined>;
+        readonly stacks: v.ArraySchema<v.AnySchema, undefined>;
+        readonly spark: v.ArraySchema<v.AnySchema, undefined>;
+        readonly starknet: v.ArraySchema<v.AnySchema, undefined>;
+      }, undefined>;
+    }, undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"bitcoin_getAddressesV2", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type BitcoinGetAddressesV2SuccessResponse = v.InferOutput<typeof bitcoinGetAddressesV2SuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/bitcoin/getBalance/response.d.ts
+declare const bitcoinGetBalanceSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    /**
+     * The confirmed balance of the wallet in sats. Using a string due to chrome
+     * messages not supporting bigint
+     * (https://issues.chromium.org/issues/40116184).
+     */
+    readonly confirmed: v.StringSchema<undefined>;
+    /**
+     * The unconfirmed balance of the wallet in sats. Using a string due to chrome
+     * messages not supporting bigint
+     * (https://issues.chromium.org/issues/40116184).
+     */
+    readonly unconfirmed: v.StringSchema<undefined>;
+    /**
+     * The total balance (both confirmed and unconfrimed UTXOs) of the wallet in
+     * sats. Using a string due to chrome messages not supporting bigint
+     * (https://issues.chromium.org/issues/40116184).
+     */
+    readonly total: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"getBalance", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type BitcoinGetBalanceSuccessResponse = v.InferOutput<typeof bitcoinGetBalanceSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/bitcoin/getBalanceV2/response.d.ts
+declare const bitcoinGetBalanceV2SuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    /**
+     * The confirmed balance of the wallet in sats. Using a string due to chrome
+     * messages not supporting bigint
+     * (https://issues.chromium.org/issues/40116184).
+     */
+    readonly confirmed: v.StringSchema<undefined>;
+    /**
+     * The unconfirmed balance of the wallet in sats. Using a string due to chrome
+     * messages not supporting bigint
+     * (https://issues.chromium.org/issues/40116184).
+     */
+    readonly unconfirmed: v.StringSchema<undefined>;
+    /**
+     * The total balance (both confirmed and unconfrimed UTXOs) of the wallet in
+     * sats. Using a string due to chrome messages not supporting bigint
+     * (https://issues.chromium.org/issues/40116184).
+     */
+    readonly total: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"bitcoin_getBalanceV2", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type BitcoinGetBalanceV2SuccessResponse = v.InferOutput<typeof bitcoinGetBalanceV2SuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/bitcoin/sendTransfer/response.d.ts
+declare const bitcoinSendTransferSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    /**
+     * The transaction id as a hex-encoded string.
+     */
+    readonly txid: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"sendTransfer", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type BitcoinSendTransferSuccessResponse = v.InferOutput<typeof bitcoinSendTransferSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/bitcoin/sendTransferV2/response.d.ts
+declare const bitcoinSendTransferV2SuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    /**
+     * The transaction id as a hex-encoded string.
+     */
+    readonly txid: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"bitcoin_sendTransferV2", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type BitcoinSendTransferV2SuccessResponse = v.InferOutput<typeof bitcoinSendTransferV2SuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/bitcoin/signPsbt/response.d.ts
+declare const bitcoinSignPsbtSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    /**
+     * The base64 encoded PSBT after signing.
+     */
+    readonly psbt: v.StringSchema<undefined>;
+    /**
+     * The transaction id as a hex-encoded string.
+     * This is only returned if the transaction was broadcast.
+     **/
+    readonly txid: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"signPsbt", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type BitcoinSignPsbtSuccessResponse = v.InferOutput<typeof bitcoinSignPsbtSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/bitcoin/signPsbtV2/response.d.ts
+declare const bitcoinSignPsbtV2SuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    /**
+     * The base64 encoded PSBT after signing.
+     */
+    readonly psbt: v.StringSchema<undefined>;
+    /**
+     * The transaction id as a hex-encoded string.
+     * This is only returned if the transaction was broadcast.
+     **/
+    readonly txid: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"bitcoin_signPsbtV2", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type BitcoinSignPsbtV2SuccessResponse = v.InferOutput<typeof bitcoinSignPsbtV2SuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/stacks/callContract/response.d.ts
+declare const stacksCallContractSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    /**
+     * The ID of the transaction.
+     */
+    readonly txid: v.StringSchema<undefined>;
+    /**
+     * A Stacks transaction as a hex-encoded string.
+     */
+    readonly transaction: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"stx_callContract", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type StacksCallContractSuccessResponse = v.InferOutput<typeof stacksCallContractSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/stacks/deployContract/response.d.ts
+declare const stacksDeployContractSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    /**
+     * The ID of the transaction.
+     */
+    readonly txid: v.StringSchema<undefined>;
+    /**
+     * A Stacks transaction as a hex-encoded string.
+     */
+    readonly transaction: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"stx_deployContract", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type StacksDeployContractSuccessResponse = v.InferOutput<typeof stacksDeployContractSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/stacks/getAccounts/response.d.ts
+declare const stacksGetAccountsSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    /**
+     * The addresses generated for the given purposes.
+     */
+    readonly addresses: v.ArraySchema<v.ObjectSchema<{
+      readonly address: v.StringSchema<undefined>;
+      readonly publicKey: v.StringSchema<undefined>;
+      readonly gaiaHubUrl: v.StringSchema<undefined>;
+      readonly gaiaAppKey: v.StringSchema<undefined>;
+    }, undefined>, undefined>;
+    readonly network: v.ObjectSchema<{
+      readonly type: v.StringSchema<undefined>;
+      readonly address: v.StringSchema<undefined>;
+    }, undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"stx_getAccounts", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type StacksGetAccountsSuccessResponse = v.InferOutput<typeof stacksGetAccountsSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/stacks/getAddresses/response.d.ts
+declare const stacksGetAddressesSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    /**
+     * The addresses generated for the given purposes.
+     */
+    readonly addresses: v.ArraySchema<v.ObjectSchema<{
+      readonly address: v.StringSchema<undefined>;
+      readonly publicKey: v.StringSchema<undefined>;
+      readonly purpose: v.EnumSchema<typeof AddressPurpose, undefined>;
+      readonly addressType: v.EnumSchema<typeof AddressType, undefined>;
+      readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone"], undefined>;
+    }, undefined>, undefined>;
+    readonly network: v.ObjectSchema<{
+      readonly type: v.StringSchema<undefined>;
+      readonly address: v.StringSchema<undefined>;
+    }, undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"stx_getAddresses", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type StacksGetAddressesSuccessResponse = v.InferOutput<typeof stacksGetAddressesSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/stacks/getAddressesV2/response.d.ts
+declare const stacksGetAddressesV2SuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    /**
+     * The addresses generated for the given purposes.
+     */
+    readonly addresses: v.ArraySchema<v.ObjectSchema<{
+      readonly address: v.StringSchema<undefined>;
+      readonly publicKey: v.StringSchema<undefined>;
+      readonly purpose: v.EnumSchema<typeof AddressPurpose, undefined>;
+      readonly addressType: v.EnumSchema<typeof AddressType, undefined>;
+      readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone"], undefined>;
+    }, undefined>, undefined>;
+    readonly network: v.ObjectSchema<{
+      readonly type: v.UnionSchema<[v.LiteralSchema<"Mainnet", undefined>, v.LiteralSchema<"Testnet", undefined>, v.LiteralSchema<"Devnet", undefined>, v.LiteralSchema<"Signet", undefined>], undefined>;
+      readonly chain: v.UnionSchema<[v.LiteralSchema<"bitcoin", undefined>, v.LiteralSchema<"stacks", undefined>], undefined>;
+    }, undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"stacks_getAddressesV2", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type StacksGetAddressesV2SuccessResponse = v.InferOutput<typeof stacksGetAddressesV2SuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/stacks/signMessage/response.d.ts
+declare const stacksSignMessageSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    /**
+     * The signature of the message.
+     */
+    readonly signature: v.StringSchema<undefined>;
+    /**
+     * The public key used to sign the message.
+     */
+    readonly publicKey: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"stx_signMessage", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type StacksSignMessageSuccessResponse = v.InferOutput<typeof stacksSignMessageSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/stacks/signStructuredMessage/response.d.ts
+declare const stacksSignStructuredMessageSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    /**
+     * Signature of the message.
+     */
+    readonly signature: v.StringSchema<undefined>;
+    /**
+     * Public key as hex-encoded string.
+     */
+    readonly publicKey: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"stx_signStructuredMessage", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type StacksSignStructuredMessageSuccessResponse = v.InferOutput<typeof stacksSignStructuredMessageSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/stacks/signTransaction/response.d.ts
+declare const stacksSignTransactionSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    /**
+     * The signed transaction as a hex-encoded string.
+     */
+    readonly transaction: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"stx_signTransaction", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type StacksSignTransactionSuccessResponse = v.InferOutput<typeof stacksSignTransactionSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/stacks/signTransactions/response.d.ts
+declare const stacksSignTransactionsSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    /**
+     * The signed transactions as hex-encoded strings, in the same order as in the
+     * sign request.
+     */
+    readonly transactions: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"stx_signTransactions", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type StacksSignTransactionsSuccessResponse = v.InferOutput<typeof stacksSignTransactionsSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/stacks/transferStx/response.d.ts
+declare const stacksTransferStxSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    /**
+     * The ID of the transaction.
+     */
+    readonly txid: v.StringSchema<undefined>;
+    /**
+     * A Stacks transaction as a hex-encoded string.
+     */
+    readonly transaction: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"stx_transferStx", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type StacksTransferStxSuccessResponse = v.InferOutput<typeof stacksTransferStxSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/spark/getAddresses/response.d.ts
+declare const sparkGetAddressesSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    /**
+     * The addresses generated for the given purposes.
+     */
+    readonly addresses: v.ArraySchema<v.ObjectSchema<{
+      readonly address: v.StringSchema<undefined>;
+      readonly publicKey: v.StringSchema<undefined>;
+      readonly purpose: v.EnumSchema<typeof AddressPurpose, undefined>;
+      readonly addressType: v.EnumSchema<typeof AddressType, undefined>;
+      readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone"], undefined>;
+    }, undefined>, undefined>;
+    readonly network: v.ObjectSchema<{
+      readonly bitcoin: v.ObjectSchema<{
+        readonly name: v.StringSchema<undefined>;
+      }, undefined>;
+      readonly stacks: v.ObjectSchema<{
+        readonly name: v.StringSchema<undefined>;
+      }, undefined>;
+      readonly spark: v.ObjectSchema<{
+        readonly name: v.StringSchema<undefined>;
+      }, undefined>;
+    }, undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"spark_getAddresses", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type SparkGetAddressesSuccessResponse = v.InferOutput<typeof sparkGetAddressesSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/spark/getAddressesV2/response.d.ts
+declare const sparkGetAddressesV2SuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    /**
+     * The addresses generated for the given purposes.
+     */
+    readonly addresses: v.ArraySchema<v.ObjectSchema<{
+      readonly address: v.StringSchema<undefined>;
+      readonly publicKey: v.StringSchema<undefined>;
+      readonly purpose: v.EnumSchema<typeof AddressPurpose, undefined>;
+      readonly addressType: v.EnumSchema<typeof AddressType, undefined>;
+      readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone"], undefined>;
+    }, undefined>, undefined>;
+    readonly network: v.ObjectSchema<{
+      readonly mode: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EnumSchema<{
+        readonly mainnet: "mainnet";
+        readonly regtest: "regtest";
+      }, undefined>]>;
+      readonly electrsApiUrl: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UrlAction<string, undefined>]>;
+      readonly id: v.StringSchema<undefined>;
+      readonly name: v.StringSchema<undefined>;
+      readonly blockExplorerUrl: v.OptionalSchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.LiteralSchema<"", undefined>, v.TransformAction<"", undefined>]>, v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UrlAction<string, undefined>]>], undefined>, undefined>;
+      readonly chain: v.LiteralSchema<"spark", undefined>;
+    }, undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"spark_getAddressesV2", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type SparkGetAddressesV2SuccessResponse = v.InferOutput<typeof sparkGetAddressesV2SuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/spark/getBalance/response.d.ts
+declare const sparkGetBalanceSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    /**
+     * The Spark Bitcoin address balance in sats in string form.
+     */
+    readonly balance: v.StringSchema<undefined>;
+    readonly tokenBalances: v.ArraySchema<v.ObjectSchema<{
+      readonly balance: v.StringSchema<undefined>;
+      readonly tokenMetadata: v.ObjectSchema<{
+        readonly tokenIdentifier: v.StringSchema<undefined>;
+        readonly tokenName: v.StringSchema<undefined>;
+        readonly tokenTicker: v.StringSchema<undefined>;
+        readonly decimals: v.NumberSchema<undefined>;
+        readonly maxSupply: v.StringSchema<undefined>;
+      }, undefined>;
+    }, undefined>, undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"spark_getBalance", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type SparkGetBalanceSuccessResponse = v.InferOutput<typeof sparkGetBalanceSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/spark/transfer/response.d.ts
+declare const sparkTransferSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    /**
+     * The ID of the transaction.
+     */
+    readonly id: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"spark_transfer", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type SparkTransferSuccessResponse = v.InferOutput<typeof sparkTransferSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/spark/transferToken/response.d.ts
+declare const sparkTransferTokenSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    /**
+     * The ID of the transaction.
+     */
+    readonly id: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"spark_transferToken", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type SparkTransferTokenSuccessResponse = v.InferOutput<typeof sparkTransferTokenSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/spark/signMessage/response.d.ts
+declare const sparkSignMessageSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    /**
+     * The signature, encoded in base64, of the message hash.
+     *
+     * Note: When signing, the message is decoded into a byte array,
+     * and the resulting byte array is hashed with SHA256 before signing
+     * with the private key.
+     */
+    readonly signature: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"spark_signMessage", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type SparkSignMessageSuccessResponse = v.InferOutput<typeof sparkSignMessageSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/spark/flashnetGetJwt/response.d.ts
+declare const sparkFlashnetGetJwtSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    /**
+     * The JWT token for authenticated requests to the Flashnet API.
+     */
+    readonly jwt: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"spark_flashnet_getJwt", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type SparkFlashnetGetJwtSuccessResponse = v.InferOutput<typeof sparkFlashnetGetJwtSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/spark/flashnetSignIntent/response.d.ts
+declare const sparkFlashnetSignIntentSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    /**
+     * The signed intent as a hex string.
+     */
+    readonly signature: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"spark_flashnet_signIntent", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type SparkFlashnetSignIntentSuccessResponse = v.InferOutput<typeof sparkFlashnetSignIntentSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/spark/flashnetSignStructuredMessage/response.d.ts
+declare const sparkFlashnetSignStructuredMessageSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    readonly message: v.StringSchema<undefined>;
+    readonly signature: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"spark_flashnet_signStructuredMessage", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type SparkFlashnetSignStructuredMessageSuccessResponse = v.InferOutput<typeof sparkFlashnetSignStructuredMessageSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/spark/flashnetExecuteSwap/response.d.ts
+declare const sparkFlashnetExecuteSwapSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    readonly requestId: v.StringSchema<undefined>;
+    readonly accepted: v.BooleanSchema<undefined>;
+    readonly amountOut: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly feeAmount: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly executionPrice: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly assetOutAddress: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly assetInAddress: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly outboundTransferId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly error: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"spark_flashnet_executeSwap", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type SparkFlashnetExecuteSwapSuccessResponse = v.InferOutput<typeof sparkFlashnetExecuteSwapSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/spark/flashnetExecuteRouteSwap/response.d.ts
+declare const sparkFlashnetExecuteRouteSwapSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    readonly requestId: v.StringSchema<undefined>;
+    readonly accepted: v.BooleanSchema<undefined>;
+    readonly outputAmount: v.StringSchema<undefined>;
+    readonly executionPrice: v.StringSchema<undefined>;
+    readonly finalOutboundTransferId: v.StringSchema<undefined>;
+    readonly error: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"spark_flashnet_executeRouteSwap", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type SparkFlashnetExecuteRouteSwapSuccessResponse = v.InferOutput<typeof sparkFlashnetExecuteRouteSwapSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/spark/flashnetClawbackFunds/response.d.ts
+declare const sparkFlashnetClawbackFundsSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    readonly requestId: v.StringSchema<undefined>;
+    readonly accepted: v.BooleanSchema<undefined>;
+    readonly internalRequestId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly sparkStatusTrackingId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly error: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"spark_flashnet_clawbackFunds", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type SparkFlashnetClawbackFundsSuccessResponse = v.InferOutput<typeof sparkFlashnetClawbackFundsSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/spark/getClawbackEligibleTransfers/response.d.ts
+declare const sparkGetClawbackEligibleTransfersSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    readonly eligibleTransfers: v.ArraySchema<v.ObjectSchema<{
+      readonly txId: v.StringSchema<undefined>;
+      readonly createdAt: v.StringSchema<undefined>;
+      readonly lpIdentityPublicKey: v.StringSchema<undefined>;
+    }, undefined>, undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"spark_getClawbackEligibleTransfers", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type SparkGetClawbackEligibleTransfersSuccessResponse = v.InferOutput<typeof sparkGetClawbackEligibleTransfersSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/runes/estimateEtch/response.d.ts
+declare const runesEstimateEtchSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    readonly totalSize: v.NumberSchema<undefined>;
+    readonly totalCost: v.NumberSchema<undefined>;
+    readonly costBreakdown: v.ObjectSchema<{
+      readonly postage: v.NumberSchema<undefined>;
+      readonly networkFee: v.NumberSchema<undefined>;
+      readonly serviceFee: v.NumberSchema<undefined>;
+      readonly appServiceFee: v.NumberSchema<undefined>;
+    }, undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"runes_estimateEtch", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type RunesEstimateEtchSuccessResponse = v.InferOutput<typeof runesEstimateEtchSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/runes/estimateMint/response.d.ts
+declare const runesEstimateMintSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    readonly totalSize: v.NumberSchema<undefined>;
+    readonly totalCost: v.NumberSchema<undefined>;
+    readonly costBreakdown: v.ObjectSchema<{
+      readonly postage: v.NumberSchema<undefined>;
+      readonly networkFee: v.NumberSchema<undefined>;
+      readonly serviceFee: v.NumberSchema<undefined>;
+      readonly appServiceFee: v.NumberSchema<undefined>;
+    }, undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"runes_estimateMint", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type RunesEstimateMintSuccessResponse = v.InferOutput<typeof runesEstimateMintSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/runes/estimateRbfOrder/response.d.ts
+declare const runesEstimateRbfOrderSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    readonly rbfCost: v.NumberSchema<undefined>;
+    readonly fundingAddress: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"runes_estimateRbfOrder", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type RunesEstimateRbfOrderSuccessResponse = v.InferOutput<typeof runesEstimateRbfOrderSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/runes/etch/response.d.ts
+declare const runesEtchSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    readonly orderId: v.StringSchema<undefined>;
+    readonly fundTransactionId: v.StringSchema<undefined>;
+    readonly fundingAddress: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"runes_etch", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type RunesEtchSuccessResponse = v.InferOutput<typeof runesEtchSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/runes/getBalance/response.d.ts
+declare const runesGetBalanceSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    readonly balances: v.ArraySchema<v.ObjectSchema<{
+      readonly runeName: v.StringSchema<undefined>;
+      readonly amount: v.StringSchema<undefined>;
+      readonly divisibility: v.NumberSchema<undefined>;
+      readonly symbol: v.StringSchema<undefined>;
+      readonly inscriptionId: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+      readonly spendableBalance: v.StringSchema<undefined>;
+    }, undefined>, undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"runes_getBalance", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type RunesGetBalanceSuccessResponse = v.InferOutput<typeof runesGetBalanceSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/runes/getOrder/response.d.ts
+declare const runesGetOrderSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+    readonly orderType: v.UnionSchema<[v.LiteralSchema<"rune_mint", undefined>, v.LiteralSchema<"rune_etch", undefined>], undefined>;
+    readonly state: v.UnionSchema<[v.LiteralSchema<"new", undefined>, v.LiteralSchema<"pending", undefined>, v.LiteralSchema<"executing", undefined>, v.LiteralSchema<"complete", undefined>, v.LiteralSchema<"failed", undefined>, v.LiteralSchema<"refunded", undefined>, v.LiteralSchema<"stale", undefined>], undefined>;
+    readonly fundingAddress: v.StringSchema<undefined>;
+    readonly reason: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly createdAt: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"runes_getOrder", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type RunesGetOrderSuccessResponse = v.InferOutput<typeof runesGetOrderSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/runes/mint/response.d.ts
+declare const runesMintSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    readonly orderId: v.StringSchema<undefined>;
+    readonly fundTransactionId: v.StringSchema<undefined>;
+    readonly fundingAddress: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"runes_mint", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type RunesMintSuccessResponse = v.InferOutput<typeof runesMintSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/runes/rbfOrder/response.d.ts
+declare const runesRbfOrderSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    readonly orderId: v.StringSchema<undefined>;
+    readonly fundRBFTransactionId: v.StringSchema<undefined>;
+    readonly fundingAddress: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"runes_rbfOrder", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type RunesRbfOrderSuccessResponse = v.InferOutput<typeof runesRbfOrderSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/runes/transfer/response.d.ts
+declare const runesTransferSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    readonly txid: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"runes_transfer", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type RunesTransferSuccessResponse = v.InferOutput<typeof runesTransferSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/ordinals/getInscriptions/response.d.ts
+declare const ordinalsGetInscriptionsSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    readonly total: v.NumberSchema<undefined>;
+    readonly limit: v.NumberSchema<undefined>;
+    readonly offset: v.NumberSchema<undefined>;
+    readonly inscriptions: v.ArraySchema<v.ObjectSchema<{
+      readonly inscriptionId: v.StringSchema<undefined>;
+      readonly inscriptionNumber: v.StringSchema<undefined>;
+      readonly address: v.StringSchema<undefined>;
+      readonly collectionName: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      readonly postage: v.StringSchema<undefined>;
+      readonly contentLength: v.StringSchema<undefined>;
+      readonly contentType: v.StringSchema<undefined>;
+      readonly timestamp: v.NumberSchema<undefined>;
+      readonly offset: v.NumberSchema<undefined>;
+      readonly genesisTransaction: v.StringSchema<undefined>;
+      readonly output: v.StringSchema<undefined>;
+    }, undefined>, undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"ord_getInscriptions", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type OrdinalsGetInscriptionsSuccessResponse = v.InferOutput<typeof ordinalsGetInscriptionsSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/ordinals/sendInscriptions/response.d.ts
+declare const ordinalsSendInscriptionsSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    /**
+     * The transaction id as a hex-encoded string.
+     */
+    readonly txid: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"ord_sendInscriptions", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type OrdinalsSendInscriptionsSuccessResponse = v.InferOutput<typeof ordinalsSendInscriptionsSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/addNetwork/response.d.ts
+declare const walletAddNetworkSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"wallet_addNetwork", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletAddNetworkSuccessResponse = v.InferOutput<typeof walletAddNetworkSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/addNetworkV2/response.d.ts
+declare const walletAddNetworkV2SuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"wallet_addNetworkV2", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletAddNetworkV2SuccessResponse = v.InferOutput<typeof walletAddNetworkV2SuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/changeNetworkById/response.d.ts
+declare const walletChangeNetworkByIdSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.NullishSchema<v.NullSchema<undefined>, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"wallet_changeNetworkById", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletChangeNetworkByIdSuccessResponse = v.InferOutput<typeof walletChangeNetworkByIdSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/changeNetwork/response.d.ts
+declare const walletChangeNetworkSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.NullishSchema<v.NullSchema<undefined>, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"wallet_changeNetwork", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletChangeNetworkSuccessResponse = v.InferOutput<typeof walletChangeNetworkSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/connect/response.d.ts
+declare const walletConnectSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+    readonly addresses: v.ArraySchema<v.ObjectSchema<{
+      readonly address: v.StringSchema<undefined>;
+      readonly publicKey: v.StringSchema<undefined>;
+      readonly purpose: v.EnumSchema<typeof AddressPurpose, undefined>;
+      readonly addressType: v.EnumSchema<typeof AddressType, undefined>;
+      readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone"], undefined>;
+    }, undefined>, undefined>;
+    readonly walletType: v.PicklistSchema<["software", "ledger"], undefined>;
+    readonly network: v.ObjectSchema<{
+      readonly bitcoin: v.ObjectSchema<{
+        readonly name: v.PicklistSchema<["Mainnet", "Testnet", "Signet"], undefined>;
+      }, undefined>;
+      readonly stacks: v.ObjectSchema<{
+        readonly name: v.PicklistSchema<["Mainnet", "Testnet"], undefined>;
+      }, undefined>;
+      readonly spark: v.ObjectSchema<{
+        readonly name: v.PicklistSchema<["Mainnet", "Testnet"], undefined>;
+      }, undefined>;
+    }, undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"wallet_connect", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletConnectSuccessResponse = v.InferOutput<typeof walletConnectSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/connectV2/response.d.ts
+declare const walletConnectV2SuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+    readonly addresses: v.ArraySchema<v.ObjectSchema<{
+      readonly address: v.StringSchema<undefined>;
+      readonly publicKey: v.StringSchema<undefined>;
+      readonly purpose: v.EnumSchema<typeof AddressPurpose, undefined>;
+      readonly addressType: v.EnumSchema<typeof AddressType, undefined>;
+      readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone"], undefined>;
+    }, undefined>, undefined>;
+    readonly walletType: v.PicklistSchema<["software", "ledger"], undefined>;
+    readonly networks: v.ObjectSchema<{
+      readonly active: v.ObjectSchema<{
+        readonly bitcoin: v.ObjectSchema<{
+          readonly id: v.StringSchema<undefined>;
+          readonly chain: v.LiteralSchema<"bitcoin", undefined>;
+          readonly type: v.PicklistSchema<["Mainnet", "Testnet", "Signet"], undefined>;
+          readonly name: v.StringSchema<undefined>;
+          readonly rpcUrl: v.StringSchema<undefined>;
+          readonly rpcFallbackUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+          readonly indexerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+          readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>;
+        readonly stacks: v.ObjectSchema<{
+          readonly id: v.StringSchema<undefined>;
+          readonly chain: v.LiteralSchema<"stacks", undefined>;
+          readonly type: v.PicklistSchema<["Mainnet", "Testnet"], undefined>;
+          readonly name: v.StringSchema<undefined>;
+          readonly rpcUrl: v.StringSchema<undefined>;
+          readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>;
+        readonly spark: v.ObjectSchema<{
+          readonly id: v.StringSchema<undefined>;
+          readonly chain: v.LiteralSchema<"spark", undefined>;
+          readonly type: v.PicklistSchema<["Mainnet", "Testnet"], undefined>;
+          readonly name: v.StringSchema<undefined>;
+          readonly rpcUrl: v.StringSchema<undefined>;
+          readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>;
+        readonly starknet: v.ObjectSchema<{
+          readonly id: v.StringSchema<undefined>;
+          readonly chain: v.LiteralSchema<"starknet", undefined>;
+          readonly type: v.PicklistSchema<["Mainnet", "Testnet", "Sepolia"], undefined>;
+          readonly name: v.StringSchema<undefined>;
+          readonly rpcUrl: v.StringSchema<undefined>;
+          readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>;
+      }, undefined>;
+      readonly builtin: v.ObjectSchema<{
+        readonly bitcoin: v.ArraySchema<v.ObjectSchema<{
+          readonly id: v.StringSchema<undefined>;
+          readonly chain: v.LiteralSchema<"bitcoin", undefined>;
+          readonly type: v.PicklistSchema<["Mainnet", "Testnet", "Signet"], undefined>;
+          readonly name: v.StringSchema<undefined>;
+          readonly rpcUrl: v.StringSchema<undefined>;
+          readonly rpcFallbackUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+          readonly indexerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+          readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly stacks: v.ArraySchema<v.ObjectSchema<{
+          readonly id: v.StringSchema<undefined>;
+          readonly chain: v.LiteralSchema<"stacks", undefined>;
+          readonly type: v.PicklistSchema<["Mainnet", "Testnet"], undefined>;
+          readonly name: v.StringSchema<undefined>;
+          readonly rpcUrl: v.StringSchema<undefined>;
+          readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly spark: v.ArraySchema<v.ObjectSchema<{
+          readonly id: v.StringSchema<undefined>;
+          readonly chain: v.LiteralSchema<"spark", undefined>;
+          readonly type: v.PicklistSchema<["Mainnet", "Testnet"], undefined>;
+          readonly name: v.StringSchema<undefined>;
+          readonly rpcUrl: v.StringSchema<undefined>;
+          readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly starknet: v.ArraySchema<v.ObjectSchema<{
+          readonly id: v.StringSchema<undefined>;
+          readonly chain: v.LiteralSchema<"starknet", undefined>;
+          readonly type: v.PicklistSchema<["Mainnet", "Testnet", "Sepolia"], undefined>;
+          readonly name: v.StringSchema<undefined>;
+          readonly rpcUrl: v.StringSchema<undefined>;
+          readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+      }, undefined>;
+      readonly custom: v.ObjectSchema<{
+        readonly bitcoin: v.ArraySchema<v.ObjectSchema<{
+          readonly id: v.StringSchema<undefined>;
+          readonly chain: v.LiteralSchema<"bitcoin", undefined>;
+          readonly type: v.PicklistSchema<["Mainnet", "Testnet", "Signet"], undefined>;
+          readonly name: v.StringSchema<undefined>;
+          readonly rpcUrl: v.StringSchema<undefined>;
+          readonly rpcFallbackUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+          readonly indexerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+          readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly stacks: v.ArraySchema<v.ObjectSchema<{
+          readonly id: v.StringSchema<undefined>;
+          readonly chain: v.LiteralSchema<"stacks", undefined>;
+          readonly type: v.PicklistSchema<["Mainnet", "Testnet"], undefined>;
+          readonly name: v.StringSchema<undefined>;
+          readonly rpcUrl: v.StringSchema<undefined>;
+          readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly spark: v.ArraySchema<v.ObjectSchema<{
+          readonly id: v.StringSchema<undefined>;
+          readonly chain: v.LiteralSchema<"spark", undefined>;
+          readonly type: v.PicklistSchema<["Mainnet", "Testnet"], undefined>;
+          readonly name: v.StringSchema<undefined>;
+          readonly rpcUrl: v.StringSchema<undefined>;
+          readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly starknet: v.ArraySchema<v.ObjectSchema<{
+          readonly id: v.StringSchema<undefined>;
+          readonly chain: v.LiteralSchema<"starknet", undefined>;
+          readonly type: v.PicklistSchema<["Mainnet", "Testnet", "Sepolia"], undefined>;
+          readonly name: v.StringSchema<undefined>;
+          readonly rpcUrl: v.StringSchema<undefined>;
+          readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+      }, undefined>;
+    }, undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"wallet_connectV2", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletConnectV2SuccessResponse = v.InferOutput<typeof walletConnectV2SuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/disconnect/response.d.ts
+declare const walletDisconnectSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.NullishSchema<v.NullSchema<undefined>, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"wallet_disconnect", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletDisconnectSuccessResponse = v.InferOutput<typeof walletDisconnectSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/getAccount/response.d.ts
+declare const walletGetAccountSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+    readonly addresses: v.ArraySchema<v.ObjectSchema<{
+      readonly address: v.StringSchema<undefined>;
+      readonly publicKey: v.StringSchema<undefined>;
+      readonly purpose: v.EnumSchema<typeof AddressPurpose, undefined>;
+      readonly addressType: v.EnumSchema<typeof AddressType, undefined>;
+      readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone"], undefined>;
+    }, undefined>, undefined>;
+    readonly walletType: v.PicklistSchema<["software", "ledger"], undefined>;
+    readonly network: v.ObjectSchema<{
+      readonly bitcoin: v.ObjectSchema<{
+        readonly name: v.PicklistSchema<["Mainnet", "Testnet", "Signet"], undefined>;
+      }, undefined>;
+      readonly stacks: v.ObjectSchema<{
+        readonly name: v.PicklistSchema<["Mainnet", "Testnet"], undefined>;
+      }, undefined>;
+      readonly spark: v.ObjectSchema<{
+        readonly name: v.PicklistSchema<["Mainnet", "Testnet"], undefined>;
+      }, undefined>;
+    }, undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"wallet_getAccount", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletGetAccountSuccessResponse = v.InferOutput<typeof walletGetAccountSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/getAccountV2/response.d.ts
+declare const walletGetAccountV2SuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+    readonly addresses: v.ArraySchema<v.ObjectSchema<{
+      readonly address: v.StringSchema<undefined>;
+      readonly publicKey: v.StringSchema<undefined>;
+      readonly purpose: v.EnumSchema<typeof AddressPurpose, undefined>;
+      readonly addressType: v.EnumSchema<typeof AddressType, undefined>;
+      readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone"], undefined>;
+    }, undefined>, undefined>;
+    readonly walletType: v.PicklistSchema<["software", "ledger"], undefined>;
+    readonly networks: v.ObjectSchema<{
+      readonly active: v.ObjectSchema<{
+        readonly bitcoin: v.ObjectSchema<{
+          readonly id: v.StringSchema<undefined>;
+          readonly chain: v.LiteralSchema<"bitcoin", undefined>;
+          readonly type: v.PicklistSchema<["Mainnet", "Testnet", "Signet"], undefined>;
+          readonly name: v.StringSchema<undefined>;
+          readonly rpcUrl: v.StringSchema<undefined>;
+          readonly rpcFallbackUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+          readonly indexerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+          readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>;
+        readonly stacks: v.ObjectSchema<{
+          readonly id: v.StringSchema<undefined>;
+          readonly chain: v.LiteralSchema<"stacks", undefined>;
+          readonly type: v.PicklistSchema<["Mainnet", "Testnet"], undefined>;
+          readonly name: v.StringSchema<undefined>;
+          readonly rpcUrl: v.StringSchema<undefined>;
+          readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>;
+        readonly spark: v.ObjectSchema<{
+          readonly id: v.StringSchema<undefined>;
+          readonly chain: v.LiteralSchema<"spark", undefined>;
+          readonly type: v.PicklistSchema<["Mainnet", "Testnet"], undefined>;
+          readonly name: v.StringSchema<undefined>;
+          readonly rpcUrl: v.StringSchema<undefined>;
+          readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>;
+        readonly starknet: v.ObjectSchema<{
+          readonly id: v.StringSchema<undefined>;
+          readonly chain: v.LiteralSchema<"starknet", undefined>;
+          readonly type: v.PicklistSchema<["Mainnet", "Testnet", "Sepolia"], undefined>;
+          readonly name: v.StringSchema<undefined>;
+          readonly rpcUrl: v.StringSchema<undefined>;
+          readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>;
+      }, undefined>;
+      readonly builtin: v.ObjectSchema<{
+        readonly bitcoin: v.ArraySchema<v.ObjectSchema<{
+          readonly id: v.StringSchema<undefined>;
+          readonly chain: v.LiteralSchema<"bitcoin", undefined>;
+          readonly type: v.PicklistSchema<["Mainnet", "Testnet", "Signet"], undefined>;
+          readonly name: v.StringSchema<undefined>;
+          readonly rpcUrl: v.StringSchema<undefined>;
+          readonly rpcFallbackUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+          readonly indexerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+          readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly stacks: v.ArraySchema<v.ObjectSchema<{
+          readonly id: v.StringSchema<undefined>;
+          readonly chain: v.LiteralSchema<"stacks", undefined>;
+          readonly type: v.PicklistSchema<["Mainnet", "Testnet"], undefined>;
+          readonly name: v.StringSchema<undefined>;
+          readonly rpcUrl: v.StringSchema<undefined>;
+          readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly spark: v.ArraySchema<v.ObjectSchema<{
+          readonly id: v.StringSchema<undefined>;
+          readonly chain: v.LiteralSchema<"spark", undefined>;
+          readonly type: v.PicklistSchema<["Mainnet", "Testnet"], undefined>;
+          readonly name: v.StringSchema<undefined>;
+          readonly rpcUrl: v.StringSchema<undefined>;
+          readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly starknet: v.ArraySchema<v.ObjectSchema<{
+          readonly id: v.StringSchema<undefined>;
+          readonly chain: v.LiteralSchema<"starknet", undefined>;
+          readonly type: v.PicklistSchema<["Mainnet", "Testnet", "Sepolia"], undefined>;
+          readonly name: v.StringSchema<undefined>;
+          readonly rpcUrl: v.StringSchema<undefined>;
+          readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+      }, undefined>;
+      readonly custom: v.ObjectSchema<{
+        readonly bitcoin: v.ArraySchema<v.ObjectSchema<{
+          readonly id: v.StringSchema<undefined>;
+          readonly chain: v.LiteralSchema<"bitcoin", undefined>;
+          readonly type: v.PicklistSchema<["Mainnet", "Testnet", "Signet"], undefined>;
+          readonly name: v.StringSchema<undefined>;
+          readonly rpcUrl: v.StringSchema<undefined>;
+          readonly rpcFallbackUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+          readonly indexerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+          readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly stacks: v.ArraySchema<v.ObjectSchema<{
+          readonly id: v.StringSchema<undefined>;
+          readonly chain: v.LiteralSchema<"stacks", undefined>;
+          readonly type: v.PicklistSchema<["Mainnet", "Testnet"], undefined>;
+          readonly name: v.StringSchema<undefined>;
+          readonly rpcUrl: v.StringSchema<undefined>;
+          readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly spark: v.ArraySchema<v.ObjectSchema<{
+          readonly id: v.StringSchema<undefined>;
+          readonly chain: v.LiteralSchema<"spark", undefined>;
+          readonly type: v.PicklistSchema<["Mainnet", "Testnet"], undefined>;
+          readonly name: v.StringSchema<undefined>;
+          readonly rpcUrl: v.StringSchema<undefined>;
+          readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly starknet: v.ArraySchema<v.ObjectSchema<{
+          readonly id: v.StringSchema<undefined>;
+          readonly chain: v.LiteralSchema<"starknet", undefined>;
+          readonly type: v.PicklistSchema<["Mainnet", "Testnet", "Sepolia"], undefined>;
+          readonly name: v.StringSchema<undefined>;
+          readonly rpcUrl: v.StringSchema<undefined>;
+          readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+      }, undefined>;
+    }, undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"wallet_getAccountV2", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletGetAccountV2SuccessResponse = v.InferOutput<typeof walletGetAccountV2SuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/getCurrentPermissions/response.d.ts
+declare const walletGetCurrentPermissionsSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"account", undefined>;
+    readonly resourceId: v.StringSchema<undefined>;
+    readonly clientId: v.StringSchema<undefined>;
+    readonly actions: v.ObjectSchema<{
+      readonly read: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    }, undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"wallet", undefined>;
+    readonly resourceId: v.StringSchema<undefined>;
+    readonly clientId: v.StringSchema<undefined>;
+    readonly actions: v.ObjectSchema<{
+      readonly readNetwork: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    }, undefined>;
+  }, undefined>], undefined>, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"wallet_getCurrentPermissions", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletGetCurrentPermissionsSuccessResponse = v.InferOutput<typeof walletGetCurrentPermissionsSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/getNetwork/response.d.ts
+declare const walletGetNetworkSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    readonly bitcoin: v.ObjectSchema<{
+      readonly name: v.PicklistSchema<["Mainnet", "Testnet", "Signet"], undefined>;
+    }, undefined>;
+    readonly stacks: v.ObjectSchema<{
+      readonly name: v.PicklistSchema<["Mainnet", "Testnet"], undefined>;
+    }, undefined>;
+    readonly spark: v.ObjectSchema<{
+      readonly name: v.PicklistSchema<["Mainnet", "Testnet"], undefined>;
+    }, undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"wallet_getNetwork", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletGetNetworkSuccessResponse = v.InferOutput<typeof walletGetNetworkSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/getNetworks/response.d.ts
+declare const walletGetNetworksSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    readonly active: v.ObjectSchema<{
+      readonly bitcoin: v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly chain: v.LiteralSchema<"bitcoin", undefined>;
+        readonly type: v.PicklistSchema<["Mainnet", "Testnet", "Signet"], undefined>;
+        readonly name: v.StringSchema<undefined>;
+        readonly rpcUrl: v.StringSchema<undefined>;
+        readonly rpcFallbackUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly indexerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      }, undefined>;
+      readonly stacks: v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly chain: v.LiteralSchema<"stacks", undefined>;
+        readonly type: v.PicklistSchema<["Mainnet", "Testnet"], undefined>;
+        readonly name: v.StringSchema<undefined>;
+        readonly rpcUrl: v.StringSchema<undefined>;
+        readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      }, undefined>;
+      readonly spark: v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly chain: v.LiteralSchema<"spark", undefined>;
+        readonly type: v.PicklistSchema<["Mainnet", "Testnet"], undefined>;
+        readonly name: v.StringSchema<undefined>;
+        readonly rpcUrl: v.StringSchema<undefined>;
+        readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      }, undefined>;
+      readonly starknet: v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly chain: v.LiteralSchema<"starknet", undefined>;
+        readonly type: v.PicklistSchema<["Mainnet", "Testnet", "Sepolia"], undefined>;
+        readonly name: v.StringSchema<undefined>;
+        readonly rpcUrl: v.StringSchema<undefined>;
+        readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      }, undefined>;
+    }, undefined>;
+    readonly builtin: v.ObjectSchema<{
+      readonly bitcoin: v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly chain: v.LiteralSchema<"bitcoin", undefined>;
+        readonly type: v.PicklistSchema<["Mainnet", "Testnet", "Signet"], undefined>;
+        readonly name: v.StringSchema<undefined>;
+        readonly rpcUrl: v.StringSchema<undefined>;
+        readonly rpcFallbackUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly indexerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      }, undefined>, undefined>;
+      readonly stacks: v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly chain: v.LiteralSchema<"stacks", undefined>;
+        readonly type: v.PicklistSchema<["Mainnet", "Testnet"], undefined>;
+        readonly name: v.StringSchema<undefined>;
+        readonly rpcUrl: v.StringSchema<undefined>;
+        readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      }, undefined>, undefined>;
+      readonly spark: v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly chain: v.LiteralSchema<"spark", undefined>;
+        readonly type: v.PicklistSchema<["Mainnet", "Testnet"], undefined>;
+        readonly name: v.StringSchema<undefined>;
+        readonly rpcUrl: v.StringSchema<undefined>;
+        readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      }, undefined>, undefined>;
+      readonly starknet: v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly chain: v.LiteralSchema<"starknet", undefined>;
+        readonly type: v.PicklistSchema<["Mainnet", "Testnet", "Sepolia"], undefined>;
+        readonly name: v.StringSchema<undefined>;
+        readonly rpcUrl: v.StringSchema<undefined>;
+        readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      }, undefined>, undefined>;
+    }, undefined>;
+    readonly custom: v.ObjectSchema<{
+      readonly bitcoin: v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly chain: v.LiteralSchema<"bitcoin", undefined>;
+        readonly type: v.PicklistSchema<["Mainnet", "Testnet", "Signet"], undefined>;
+        readonly name: v.StringSchema<undefined>;
+        readonly rpcUrl: v.StringSchema<undefined>;
+        readonly rpcFallbackUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly indexerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      }, undefined>, undefined>;
+      readonly stacks: v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly chain: v.LiteralSchema<"stacks", undefined>;
+        readonly type: v.PicklistSchema<["Mainnet", "Testnet"], undefined>;
+        readonly name: v.StringSchema<undefined>;
+        readonly rpcUrl: v.StringSchema<undefined>;
+        readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      }, undefined>, undefined>;
+      readonly spark: v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly chain: v.LiteralSchema<"spark", undefined>;
+        readonly type: v.PicklistSchema<["Mainnet", "Testnet"], undefined>;
+        readonly name: v.StringSchema<undefined>;
+        readonly rpcUrl: v.StringSchema<undefined>;
+        readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      }, undefined>, undefined>;
+      readonly starknet: v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly chain: v.LiteralSchema<"starknet", undefined>;
+        readonly type: v.PicklistSchema<["Mainnet", "Testnet", "Sepolia"], undefined>;
+        readonly name: v.StringSchema<undefined>;
+        readonly rpcUrl: v.StringSchema<undefined>;
+        readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      }, undefined>, undefined>;
+    }, undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"wallet_getNetworks", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletGetNetworksSuccessResponse = v.InferOutput<typeof walletGetNetworksSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/getWalletType/response.d.ts
+declare const walletGetWalletTypeSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.PicklistSchema<["software", "ledger"], undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"wallet_getWalletType", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletGetWalletTypeSuccessResponse = v.InferOutput<typeof walletGetWalletTypeSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/openBridge/response.d.ts
+declare const walletOpenBridgeSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.NullishSchema<v.NullSchema<undefined>, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"wallet_openBridge", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletOpenBridgeSuccessResponse = v.InferOutput<typeof walletOpenBridgeSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/openBuy/response.d.ts
+declare const walletOpenBuySuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.NullishSchema<v.NullSchema<undefined>, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"wallet_openBuy", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletOpenBuySuccessResponse = v.InferOutput<typeof walletOpenBuySuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/openReceive/response.d.ts
+declare const walletOpenReceiveSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.ObjectSchema<{
+    readonly address: v.StringSchema<undefined>;
+    readonly publicKey: v.StringSchema<undefined>;
+    readonly purpose: v.EnumSchema<typeof AddressPurpose, undefined>;
+    readonly addressType: v.EnumSchema<typeof AddressType, undefined>;
+    readonly walletType: v.PicklistSchema<readonly ["software", "ledger", "keystone"], undefined>;
+  }, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"wallet_openReceive", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletOpenReceiveSuccessResponse = v.InferOutput<typeof walletOpenReceiveSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/renouncePermissions/response.d.ts
+declare const walletRenouncePermissionsSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.NullishSchema<v.NullSchema<undefined>, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"wallet_renouncePermissions", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletRenouncePermissionsSuccessResponse = v.InferOutput<typeof walletRenouncePermissionsSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/requestPermissions/response.d.ts
+declare const walletRequestPermissionsSuccessResponseSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly result: v.LiteralSchema<true, undefined>;
+  readonly '~sats-connect-method': v.LiteralSchema<"wallet_requestPermissions", undefined>;
+  readonly extensions: v.OptionalSchema<v.ObjectSchema<{
+    readonly warnings: v.ArraySchema<v.VariantSchema<"code", [v.ObjectSchema<{
+      readonly code: v.LiteralSchema<"DEPRECATION_NOTICE", undefined>;
+      readonly message: v.StringSchema<undefined>;
+      readonly sunsetDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletRequestPermissionsSuccessResponse = v.InferOutput<typeof walletRequestPermissionsSuccessResponseSchema>;
+//#endregion
+//#region src/request/rpc/responses.d.ts
+type RpcSuccessResponses = ExactObject<Method, {
+  [bitcoinMethods.getAccounts]: BitcoinGetAccountsSuccessResponse;
+  [bitcoinMethods.bitcoin_getAccountsV2]: BitcoinGetAccountsV2SuccessResponse;
+  [bitcoinMethods.getAddresses]: BitcoinGetAddressesSuccessResponse;
+  [bitcoinMethods.bitcoin_getAddressesV2]: BitcoinGetAddressesV2SuccessResponse;
+  [bitcoinMethods.getBalance]: BitcoinGetBalanceSuccessResponse;
+  [bitcoinMethods.bitcoin_getBalanceV2]: BitcoinGetBalanceV2SuccessResponse;
+  [bitcoinMethods.getInfo]: BitcoinGetInfoSuccessResponse;
+  [bitcoinMethods.bitcoin_getInfoV2]: BitcoinGetInfoV2SuccessResponse;
+  [bitcoinMethods.sendTransfer]: BitcoinSendTransferSuccessResponse;
+  [bitcoinMethods.bitcoin_sendTransferV2]: BitcoinSendTransferV2SuccessResponse;
+  [bitcoinMethods.signMessage]: BitcoinSignMessageSuccessResponse;
+  [bitcoinMethods.bitcoin_signMessageV2]: BitcoinSignMessageV2SuccessResponse;
+  [bitcoinMethods.signMultipleMessages]: BitcoinSignMultipleMessagesSuccessResponse;
+  [bitcoinMethods.bitcoin_signMultipleMessagesV2]: BitcoinSignMultipleMessagesV2SuccessResponse;
+  [bitcoinMethods.signPsbt]: BitcoinSignPsbtSuccessResponse;
+  [bitcoinMethods.bitcoin_signPsbtV2]: BitcoinSignPsbtV2SuccessResponse;
+  [stacksMethods.stx_callContract]: StacksCallContractSuccessResponse;
+  [stacksMethods.stx_deployContract]: StacksDeployContractSuccessResponse;
+  [stacksMethods.stx_getAccounts]: StacksGetAccountsSuccessResponse;
+  [stacksMethods.stx_getAddresses]: StacksGetAddressesSuccessResponse;
+  [stacksMethods.stacks_getAddressesV2]: StacksGetAddressesV2SuccessResponse;
+  [stacksMethods.stx_signMessage]: StacksSignMessageSuccessResponse;
+  [stacksMethods.stx_signStructuredMessage]: StacksSignStructuredMessageSuccessResponse;
+  [stacksMethods.stx_signTransaction]: StacksSignTransactionSuccessResponse;
+  [stacksMethods.stx_signTransactions]: StacksSignTransactionsSuccessResponse;
+  [stacksMethods.stx_transferStx]: StacksTransferStxSuccessResponse;
+  [sparkMethods.spark_getAddresses]: SparkGetAddressesSuccessResponse;
+  [sparkMethods.spark_getAddressesV2]: SparkGetAddressesV2SuccessResponse;
+  [sparkMethods.spark_getBalance]: SparkGetBalanceSuccessResponse;
+  [sparkMethods.spark_transfer]: SparkTransferSuccessResponse;
+  [sparkMethods.spark_transferToken]: SparkTransferTokenSuccessResponse;
+  [sparkMethods.spark_signMessage]: SparkSignMessageSuccessResponse;
+  [sparkMethods.spark_flashnet_getJwt]: SparkFlashnetGetJwtSuccessResponse;
+  [sparkMethods.spark_flashnet_signIntent]: SparkFlashnetSignIntentSuccessResponse;
+  [sparkMethods.spark_flashnet_signStructuredMessage]: SparkFlashnetSignStructuredMessageSuccessResponse;
+  [sparkMethods.spark_flashnet_executeSwap]: SparkFlashnetExecuteSwapSuccessResponse;
+  [sparkMethods.spark_flashnet_executeRouteSwap]: SparkFlashnetExecuteRouteSwapSuccessResponse;
+  [sparkMethods.spark_flashnet_clawbackFunds]: SparkFlashnetClawbackFundsSuccessResponse;
+  [sparkMethods.spark_getClawbackEligibleTransfers]: SparkGetClawbackEligibleTransfersSuccessResponse;
+  [runesMethods.runes_estimateEtch]: RunesEstimateEtchSuccessResponse;
+  [runesMethods.runes_estimateMint]: RunesEstimateMintSuccessResponse;
+  [runesMethods.runes_estimateRbfOrder]: RunesEstimateRbfOrderSuccessResponse;
+  [runesMethods.runes_etch]: RunesEtchSuccessResponse;
+  [runesMethods.runes_getBalance]: RunesGetBalanceSuccessResponse;
+  [runesMethods.runes_getOrder]: RunesGetOrderSuccessResponse;
+  [runesMethods.runes_mint]: RunesMintSuccessResponse;
+  [runesMethods.runes_rbfOrder]: RunesRbfOrderSuccessResponse;
+  [runesMethods.runes_transfer]: RunesTransferSuccessResponse;
+  [ordinalsMethods.ord_getInscriptions]: OrdinalsGetInscriptionsSuccessResponse;
+  [ordinalsMethods.ord_sendInscriptions]: OrdinalsSendInscriptionsSuccessResponse;
+  [walletMethods.wallet_addNetwork]: WalletAddNetworkSuccessResponse;
+  [walletMethods.wallet_addNetworkV2]: WalletAddNetworkV2SuccessResponse;
+  [walletMethods.wallet_changeNetworkById]: WalletChangeNetworkByIdSuccessResponse;
+  [walletMethods.wallet_changeNetwork]: WalletChangeNetworkSuccessResponse;
+  [walletMethods.wallet_connect]: WalletConnectSuccessResponse;
+  [walletMethods.wallet_connectV2]: WalletConnectV2SuccessResponse;
+  [walletMethods.wallet_disconnect]: WalletDisconnectSuccessResponse;
+  [walletMethods.wallet_getAccount]: WalletGetAccountSuccessResponse;
+  [walletMethods.wallet_getAccountV2]: WalletGetAccountV2SuccessResponse;
+  [walletMethods.wallet_getCurrentPermissions]: WalletGetCurrentPermissionsSuccessResponse;
+  [walletMethods.wallet_getNetwork]: WalletGetNetworkSuccessResponse;
+  [walletMethods.wallet_getNetworks]: WalletGetNetworksSuccessResponse;
+  [walletMethods.wallet_getWalletType]: WalletGetWalletTypeSuccessResponse;
+  [walletMethods.wallet_openBridge]: WalletOpenBridgeSuccessResponse;
+  [walletMethods.wallet_openBuy]: WalletOpenBuySuccessResponse;
+  [walletMethods.wallet_openReceive]: WalletOpenReceiveSuccessResponse;
+  [walletMethods.wallet_renouncePermissions]: WalletRenouncePermissionsSuccessResponse;
+  [walletMethods.wallet_requestPermissions]: WalletRequestPermissionsSuccessResponse;
+}>;
+type RpcSuccessResponseResult<M extends Method> = RpcSuccessResponses[M]['result'];
+//#endregion
+//#region src/request/rpc/methodSchemas/bitcoin/signMessage/request.d.ts
+declare enum MessageSigningProtocols {
+  ECDSA = "ECDSA",
+  BIP322 = "BIP322",
+}
+declare const bitcoinSignMessageRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"signMessage", undefined>;
+  readonly params: v.ObjectSchema<{
+    /**
+     * The address used for signing.
+     **/
+    readonly address: v.StringSchema<undefined>;
+    /**
+     * The message to sign.
+     **/
+    readonly message: v.StringSchema<undefined>;
+    /**
+     * The protocol to use for signing the message.
+     *
+     * If not specified, defaults to ECDSA if signing with a P2WPKH or P2SH address,
+     * and to BIP322 if signing with a taproot address.
+     */
+    readonly protocol: v.OptionalSchema<v.EnumSchema<typeof MessageSigningProtocols, undefined>, undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type BitcoinSignMessageRequest = v.InferOutput<typeof bitcoinSignMessageRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/bitcoin/signMessageV2/request.d.ts
+declare enum MessageSigningProtocols$3 {
+  ECDSA = "ECDSA",
+  BIP322 = "BIP322",
+}
+declare const bitcoinSignMessageV2RequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"bitcoin_signMessageV2", undefined>;
+  readonly params: v.ObjectSchema<{
+    /**
+     * The address used for signing.
+     **/
+    readonly address: v.StringSchema<undefined>;
+    /**
+     * The message to sign.
+     **/
+    readonly message: v.StringSchema<undefined>;
+    /**
+     * The protocol to use for signing the message.
+     *
+     * If not specified, defaults to ECDSA if signing with a P2WPKH or P2SH address,
+     * and to BIP322 if signing with a taproot address.
+     */
+    readonly protocol: v.OptionalSchema<v.EnumSchema<typeof MessageSigningProtocols$3, undefined>, undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type BitcoinSignMessageV2Request = v.InferOutput<typeof bitcoinSignMessageV2RequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/bitcoin/signMultipleMessages/request.d.ts
+declare enum MessageSigningProtocols$2 {
+  ECDSA = "ECDSA",
+  BIP322 = "BIP322",
+}
+declare const bitcoinSignMultipleMessagesRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"signMultipleMessages", undefined>;
+  readonly params: v.ArraySchema<v.ObjectSchema<{
+    /**
+     * The address used for signing.
+     **/
+    readonly address: v.StringSchema<undefined>;
+    /**
+     * The message to sign.
+     **/
+    readonly message: v.StringSchema<undefined>;
+    /**
+     * The protocol to use to sign the message.
+     *
+     * If not specified, defaults to ECDSA if signing with a P2WPKH or P2SH address,
+     * and to BIP322 if signing with a taproot address.
+     */
+    readonly protocol: v.OptionalSchema<v.EnumSchema<typeof MessageSigningProtocols$2, undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type BitcoinSignMultipleMessagesRequest = v.InferOutput<typeof bitcoinSignMultipleMessagesRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/bitcoin/signMultipleMessagesV2/request.d.ts
+declare enum MessageSigningProtocols$1 {
+  ECDSA = "ECDSA",
+  BIP322 = "BIP322",
+}
+declare const bitcoinSignMultipleMessagesV2RequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"bitcoin_signMultipleMessagesV2", undefined>;
+  readonly params: v.ArraySchema<v.ObjectSchema<{
+    /**
+     * The address used for signing.
+     **/
+    readonly address: v.StringSchema<undefined>;
+    /**
+     * The message to sign.
+     **/
+    readonly message: v.StringSchema<undefined>;
+    /**
+     * The protocol to use to sign the message.
+     *
+     * If not specified, defaults to ECDSA if signing with a P2WPKH or P2SH address,
+     * and to BIP322 if signing with a taproot address.
+     */
+    readonly protocol: v.OptionalSchema<v.EnumSchema<typeof MessageSigningProtocols$1, undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type BitcoinSignMultipleMessagesV2Request = v.InferOutput<typeof bitcoinSignMultipleMessagesV2RequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/bitcoin/getAccounts/request.d.ts
+declare const bitcoinGetAccountsRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"getAccounts", undefined>;
+  readonly params: v.ObjectSchema<{
+    /**
+     * The purposes for which to generate addresses. See
+     * {@linkcode AddressPurpose} for available purposes.
+     */
+    readonly purposes: v.ArraySchema<v.EnumSchema<typeof AddressPurpose, undefined>, undefined>;
+    /**
+     * A message to be displayed to the user in the request prompt.
+     */
+    readonly message: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type BitcoinGetAccountsRequest = v.InferOutput<typeof bitcoinGetAccountsRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/bitcoin/getAccountsV2/request.d.ts
+declare const bitcoinGetAccountsV2RequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"bitcoin_getAccountsV2", undefined>;
+  readonly params: v.ObjectSchema<{
+    /**
+     * The purposes for which to generate addresses. See
+     * {@linkcode AddressPurpose} for available purposes.
+     */
+    readonly purposes: v.ArraySchema<v.EnumSchema<typeof AddressPurpose, undefined>, undefined>;
+    /**
+     * A message to be displayed to the user in the request prompt.
+     */
+    readonly message: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type BitcoinGetAccountsV2Request = v.InferOutput<typeof bitcoinGetAccountsV2RequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/bitcoin/getAddresses/request.d.ts
+declare const bitcoinGetAddressesRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"getAddresses", undefined>;
+  readonly params: v.ObjectSchema<{
+    /**
+     * The purposes for which to generate addresses. See
+     * {@linkcode AddressPurpose} for available purposes.
+     */
+    readonly purposes: v.ArraySchema<v.EnumSchema<typeof AddressPurpose, undefined>, undefined>;
+    /**
+     * A message to be displayed to the user in the request prompt.
+     */
+    readonly message: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type BitcoinGetAddressesRequest = v.InferOutput<typeof bitcoinGetAddressesRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/bitcoin/getAddressesV2/request.d.ts
+declare const bitcoinGetAddressesV2RequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"bitcoin_getAddressesV2", undefined>;
+  readonly params: v.ObjectSchema<{
+    /**
+     * The purposes for which to generate addresses. See
+     * {@linkcode AddressPurpose} for available purposes.
+     */
+    readonly purposes: v.ArraySchema<v.EnumSchema<typeof AddressPurpose, undefined>, undefined>;
+    /**
+     * A message to be displayed to the user in the request prompt.
+     */
+    readonly message: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type BitcoinGetAddressesV2Request = v.InferOutput<typeof bitcoinGetAddressesV2RequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/bitcoin/getBalance/request.d.ts
+declare const bitcoinGetBalanceRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"getBalance", undefined>;
+  readonly params: v.NullishSchema<v.NullSchema<undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type BitcoinGetBalanceRequest = v.InferOutput<typeof bitcoinGetBalanceRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/bitcoin/getBalanceV2/request.d.ts
+declare const bitcoinGetBalanceV2RequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"bitcoin_getBalanceV2", undefined>;
+  readonly params: v.NullishSchema<v.NullSchema<undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type BitcoinGetBalanceV2Request = v.InferOutput<typeof bitcoinGetBalanceV2RequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/bitcoin/getInfo/request.d.ts
+declare const bitcoinGetInfoRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"getInfo", undefined>;
+  readonly params: v.NullishSchema<v.NullSchema<undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type BitcoinGetInfoRequest = v.InferOutput<typeof bitcoinGetInfoRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/bitcoin/getInfoV2/request.d.ts
+declare const bitcoinGetInfoV2RequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"bitcoin_getInfoV2", undefined>;
+  readonly params: v.NullishSchema<v.NullSchema<undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type BitcoinGetInfoV2Request = v.InferOutput<typeof bitcoinGetInfoV2RequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/bitcoin/sendTransfer/request.d.ts
+declare const bitcoinSendTransferRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"sendTransfer", undefined>;
+  readonly params: v.ObjectSchema<{
+    /**
+     * Array of recipients to send to.
+     * The amount to send to each recipient is in satoshis.
+     */
+    readonly recipients: v.ArraySchema<v.ObjectSchema<{
+      readonly address: v.StringSchema<undefined>;
+      readonly amount: v.NumberSchema<undefined>;
+    }, undefined>, undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type BitcoinSendTransferRequest = v.InferOutput<typeof bitcoinSendTransferRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/bitcoin/sendTransferV2/request.d.ts
+declare const bitcoinSendTransferV2RequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"bitcoin_sendTransferV2", undefined>;
+  readonly params: v.ObjectSchema<{
+    /**
+     * Array of recipients to send to.
+     * The amount to send to each recipient is in satoshis.
+     */
+    readonly recipients: v.ArraySchema<v.ObjectSchema<{
+      readonly address: v.StringSchema<undefined>;
+      readonly amount: v.NumberSchema<undefined>;
+    }, undefined>, undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type BitcoinSendTransferV2Request = v.InferOutput<typeof bitcoinSendTransferV2RequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/bitcoin/signPsbt/request.d.ts
+declare const bitcoinSignPsbtRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"signPsbt", undefined>;
+  readonly params: v.ObjectSchema<{
+    /**
+     * The base64 encoded PSBT to sign.
+     */
+    readonly psbt: v.StringSchema<undefined>;
+    /**
+     * The inputs to sign.
+     * The key is the address and the value is an array of indexes of the inputs to sign.
+     */
+    readonly signInputs: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.ArraySchema<v.NumberSchema<undefined>, undefined>, undefined>, undefined>;
+    /**
+     * Whether to broadcast the transaction after signing.
+     **/
+    readonly broadcast: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type BitcoinSignPsbtRequest = v.InferOutput<typeof bitcoinSignPsbtRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/bitcoin/signPsbtV2/request.d.ts
+declare const bitcoinSignPsbtV2RequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"bitcoin_signPsbtV2", undefined>;
+  readonly params: v.ObjectSchema<{
+    /**
+     * The base64 encoded PSBT to sign.
+     */
+    readonly psbt: v.StringSchema<undefined>;
+    /**
+     * The inputs to sign.
+     * The key is the address and the value is an array of indexes of the inputs to sign.
+     */
+    readonly signInputs: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.ArraySchema<v.NumberSchema<undefined>, undefined>, undefined>, undefined>;
+    /**
+     * Whether to broadcast the transaction after signing.
+     **/
+    readonly broadcast: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type BitcoinSignPsbtV2Request = v.InferOutput<typeof bitcoinSignPsbtV2RequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/stacks/callContract/request.d.ts
+declare const stacksCallContractRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"stx_callContract", undefined>;
+  readonly params: v.ObjectSchema<{
+    /**
+     * The contract principal.
+     *
+     * E.g. `"SPKE...GD5C.my-contract"`
+     */
+    readonly contract: v.StringSchema<undefined>;
+    /**
+     * The name of the function to call.
+     *
+     * Note: spec changes ongoing,
+     * https://github.com/stacksgov/sips/pull/166#pullrequestreview-1914236999
+     */
+    readonly functionName: v.StringSchema<undefined>;
+    /**
+     * @deprecated in favor of `functionArgs` for @stacks/connect compatibility
+     */
+    readonly arguments: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+    /**
+     * The function's arguments. The arguments are expected to be hex-encoded
+     * strings of Clarity values.
+     *
+     * To convert Clarity values to their hex representation, the `cvToHex`
+     * helper from the `@stacks/transactions` package may be helpful.
+     *
+     * ```js
+     * import { cvToHex } from '@stacks/transactions';
+     *
+     * const functionArgs = [someClarityValue1, someClarityValue2];
+     * const hexArgs = functionArgs.map(cvToHex);
+     * ```
+     */
+    readonly functionArgs: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+    /**
+     * The post conditions to apply to the contract call.
+     */
+    readonly postConditions: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+    /**
+     * The mode to apply to the post conditions.
+     */
+    readonly postConditionMode: v.OptionalSchema<v.UnionSchema<[v.LiteralSchema<"allow", undefined>, v.LiteralSchema<"deny", undefined>], undefined>, undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type StacksCallContractRequest = v.InferOutput<typeof stacksCallContractRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/stacks/deployContract/request.d.ts
+declare const stacksDeployContractRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"stx_deployContract", undefined>;
+  readonly params: v.ObjectSchema<{
+    /**
+     * Name of the contract.
+     */
+    readonly name: v.StringSchema<undefined>;
+    /**
+     * The source code of the Clarity contract.
+     */
+    readonly clarityCode: v.StringSchema<undefined>;
+    /**
+     * The version of the Clarity contract.
+     */
+    readonly clarityVersion: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    /**
+     * The post conditions to apply to the contract call.
+     */
+    readonly postConditions: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+    /**
+     * The mode to apply to the post conditions.
+     */
+    readonly postConditionMode: v.OptionalSchema<v.UnionSchema<[v.LiteralSchema<"allow", undefined>, v.LiteralSchema<"deny", undefined>], undefined>, undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type StacksDeployContractRequest = v.InferOutput<typeof stacksDeployContractRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/stacks/getAccounts/request.d.ts
+declare const stacksGetAccountsRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"stx_getAccounts", undefined>;
+  readonly params: v.NullishSchema<v.NullSchema<undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type StacksGetAccountsRequest = v.InferOutput<typeof stacksGetAccountsRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/stacks/getAddresses/request.d.ts
+declare const stacksGetAddressesRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"stx_getAddresses", undefined>;
+  readonly params: v.NullishSchema<v.ObjectSchema<{
+    /**
+     * A message to be displayed to the user in the request prompt.
+     */
+    readonly message: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type StacksGetAddressesRequest = v.InferOutput<typeof stacksGetAddressesRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/stacks/getAddressesV2/request.d.ts
+declare const stacksGetAddressesV2RequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"stacks_getAddressesV2", undefined>;
+  readonly params: v.NullishSchema<v.ObjectSchema<{
+    /**
+     * A message to be displayed to the user in the request prompt.
+     */
+    readonly message: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type StacksGetAddressesV2Request = v.InferOutput<typeof stacksGetAddressesV2RequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/stacks/signMessage/request.d.ts
+declare const stacksSignMessageRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"stx_signMessage", undefined>;
+  readonly params: v.ObjectSchema<{
+    /**
+     * The message to sign.
+     */
+    readonly message: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type StacksSignMessageRequest = v.InferOutput<typeof stacksSignMessageRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/stacks/signStructuredMessage/request.d.ts
+declare const stacksSignStructuredMessageRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"stx_signStructuredMessage", undefined>;
+  readonly params: v.ObjectSchema<{
+    /**
+     * The domain to be signed.
+     */
+    readonly domain: v.StringSchema<undefined>;
+    /**
+     * Message payload to be signed.
+     */
+    readonly message: v.StringSchema<undefined>;
+    /**
+     * The public key to sign the message with.
+     */
+    readonly publicKey: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type StacksSignStructuredMessageRequest = v.InferOutput<typeof stacksSignStructuredMessageRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/stacks/signTransaction/request.d.ts
+declare const stacksSignTransactionRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"stx_signTransaction", undefined>;
+  readonly params: v.ObjectSchema<{
+    /**
+     * The transaction to sign as a hex-encoded string.
+     */
+    readonly transaction: v.StringSchema<undefined>;
+    /**
+     * The public key to sign the transaction with. The wallet may use any key
+     * when not provided.
+     */
+    readonly pubkey: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    /**
+     * Whether to broadcast the transaction after signing. Defaults to `true`.
+     */
+    readonly broadcast: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type StacksSignTransactionRequest = v.InferOutput<typeof stacksSignTransactionRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/stacks/signTransactions/request.d.ts
+declare const stacksSignTransactionsRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"stx_signTransactions", undefined>;
+  readonly params: v.ObjectSchema<{
+    /**
+     * The transactions to sign as hex-encoded strings.
+     */
+    readonly transactions: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Invalid hex-encoded Stacks transaction.">]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
+    /**
+     * Whether the signed transactions should be broadcast after signing. Defaults
+     * to `true`.
+     */
+    readonly broadcast: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type StacksSignTransactionsRequest = v.InferOutput<typeof stacksSignTransactionsRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/stacks/transferStx/request.d.ts
+declare const stacksTransferStxRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"stx_transferStx", undefined>;
+  readonly params: v.ObjectSchema<{
+    /**
+     * Amount of STX tokens to transfer in microstacks as a string. Anything
+     * parseable by `BigInt` is acceptable.
+     *
+     * Example,
+     *
+     * ```js
+     * const amount1 = 1234;
+     * const amount2 = 1234n;
+     * const amount3 = '1234';
+     * ```
+     */
+    readonly amount: v.UnionSchema<[v.NumberSchema<undefined>, v.StringSchema<undefined>], undefined>;
+    /**
+     * The recipient's principal.
+     */
+    readonly recipient: v.StringSchema<undefined>;
+    /**
+     * A string representing the memo.
+     */
+    readonly memo: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    /**
+     * Version of parameter format.
+     */
+    readonly version: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    /**
+     * The mode of the post conditions.
+     */
+    readonly postConditionMode: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    /**
+     * A hex-encoded string representing the post conditions.
+     *
+     * A post condition may be converted to it's hex representation using the `serializePostCondition` helper from the `@stacks/transactions` package,
+     *
+     * ```js
+     * import { serializePostCondition } from '@stacks/transactions';
+     *
+     * const postCondition = somePostCondition;
+     * const hexPostCondition = serializePostCondition(postCondition).toString('hex');
+     * ```
+     */
+    readonly postConditions: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+    /**
+     * The public key to sign the transaction with. The wallet may use any key
+     * when not provided.
+     */
+    readonly pubkey: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type StacksTransferStxRequest = v.InferOutput<typeof stacksTransferStxRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/spark/getAddresses/request.d.ts
+declare const sparkGetAddressesRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"spark_getAddresses", undefined>;
+  readonly params: v.NullishSchema<v.ObjectSchema<{
+    /**
+     * A message to be displayed to the user in the request prompt.
+     */
+    readonly message: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type SparkGetAddressesRequest = v.InferOutput<typeof sparkGetAddressesRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/spark/getAddressesV2/request.d.ts
+declare const sparkGetAddressesV2RequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"spark_getAddressesV2", undefined>;
+  readonly params: v.NullishSchema<v.ObjectSchema<{
+    /**
+     * A message to be displayed to the user in the request prompt.
+     */
+    readonly message: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type SparkGetAddressesV2Request = v.InferOutput<typeof sparkGetAddressesV2RequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/spark/getBalance/request.d.ts
+declare const sparkGetBalanceRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"spark_getBalance", undefined>;
+  readonly params: v.NullishSchema<v.NullSchema<undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type SparkGetBalanceRequest = v.InferOutput<typeof sparkGetBalanceRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/spark/transfer/request.d.ts
+declare const sparkTransferRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"spark_transfer", undefined>;
+  readonly params: v.ObjectSchema<{
+    /**
+     * Amount of SATS to transfer as a string or number.
+     */
+    readonly amountSats: v.UnionSchema<[v.NumberSchema<undefined>, v.StringSchema<undefined>], undefined>;
+    /**
+     * The recipient's spark address.
+     */
+    readonly receiverSparkAddress: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type SparkTransferRequest = v.InferOutput<typeof sparkTransferRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/spark/transferToken/request.d.ts
+declare const sparkTransferTokenRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"spark_transferToken", undefined>;
+  readonly params: v.ObjectSchema<{
+    /**
+     * Amount of units of the token to transfer as a string or number.
+     */
+    readonly tokenAmount: v.UnionSchema<[v.NumberSchema<undefined>, v.StringSchema<undefined>], undefined>;
+    /**
+     * The Bech32m token identifier.
+     */
+    readonly tokenIdentifier: v.StringSchema<undefined>;
+    /**
+     * The recipient's spark address.
+     */
+    readonly receiverSparkAddress: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type SparkTransferTokenRequest = v.InferOutput<typeof sparkTransferTokenRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/spark/signMessage/request.d.ts
+declare const sparkSignMessageRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"spark_signMessage", undefined>;
+  readonly params: v.ObjectSchema<{
+    /**
+     * The message to sign. The message should only consist of valid UTF-8 characters.
+     */
+    readonly message: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type SparkSignMessageRequest = v.InferOutput<typeof sparkSignMessageRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/spark/flashnetGetJwt/request.d.ts
+declare const sparkFlashnetGetJwtRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"spark_flashnet_getJwt", undefined>;
+  readonly params: v.NullSchema<undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type SparkFlashnetGetJwtRequest = v.InferOutput<typeof sparkFlashnetGetJwtRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/spark/flashnetSignIntent/request.d.ts
+declare const sparkFlashnetSignIntentRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"spark_flashnet_signIntent", undefined>;
+  readonly params: v.UnionSchema<[v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"executeSwap", undefined>;
+    readonly data: v.ObjectSchema<{
+      readonly userPublicKey: v.StringSchema<undefined>;
+      readonly poolId: v.StringSchema<undefined>;
+      readonly transferId: v.StringSchema<undefined>;
+      readonly assetInAddress: v.StringSchema<undefined>;
+      readonly assetOutAddress: v.StringSchema<undefined>;
+      readonly amountIn: v.StringSchema<undefined>;
+      readonly maxSlippageBps: v.UnionSchema<[v.NumberSchema<undefined>, v.StringSchema<undefined>], undefined>;
+      readonly minAmountOut: v.StringSchema<undefined>;
+      readonly totalIntegratorFeeRateBps: v.OptionalSchema<v.UnionSchema<[v.NumberSchema<undefined>, v.StringSchema<undefined>], undefined>, undefined>;
+      readonly nonce: v.StringSchema<undefined>;
+    }, undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"executeRouteSwap", undefined>;
+    readonly data: v.ObjectSchema<{
+      readonly userPublicKey: v.StringSchema<undefined>;
+      readonly initialSparkTransferId: v.StringSchema<undefined>;
+      readonly hops: v.ArraySchema<v.ObjectSchema<{
+        readonly poolId: v.StringSchema<undefined>;
+        readonly inputAssetAddress: v.StringSchema<undefined>;
+        readonly outputAssetAddress: v.StringSchema<undefined>;
+        readonly hopIntegratorFeeRateBps: v.OptionalSchema<v.UnionSchema<[v.NumberSchema<undefined>, v.StringSchema<undefined>], undefined>, undefined>;
+      }, undefined>, undefined>;
+      readonly inputAmount: v.StringSchema<undefined>;
+      readonly maxRouteSlippageBps: v.UnionSchema<[v.NumberSchema<undefined>, v.StringSchema<undefined>], undefined>;
+      readonly minAmountOut: v.StringSchema<undefined>;
+      readonly defaultIntegratorFeeRateBps: v.OptionalSchema<v.UnionSchema<[v.NumberSchema<undefined>, v.StringSchema<undefined>], undefined>, undefined>;
+      readonly nonce: v.StringSchema<undefined>;
+    }, undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"addLiquidity", undefined>;
+    readonly data: v.ObjectSchema<{
+      readonly userPublicKey: v.StringSchema<undefined>;
+      readonly poolId: v.StringSchema<undefined>;
+      readonly assetAAmount: v.StringSchema<undefined>;
+      readonly assetBAmount: v.StringSchema<undefined>;
+      readonly assetAMinAmountIn: v.StringSchema<undefined>;
+      readonly assetBMinAmountIn: v.StringSchema<undefined>;
+      readonly assetATransferId: v.StringSchema<undefined>;
+      readonly assetBTransferId: v.StringSchema<undefined>;
+      readonly nonce: v.StringSchema<undefined>;
+    }, undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"clawback", undefined>;
+    readonly data: v.ObjectSchema<{
+      readonly senderPublicKey: v.StringSchema<undefined>;
+      readonly sparkTransferId: v.StringSchema<undefined>;
+      readonly lpIdentityPublicKey: v.StringSchema<undefined>;
+      readonly nonce: v.StringSchema<undefined>;
+    }, undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"confirmInitialDeposit", undefined>;
+    readonly data: v.ObjectSchema<{
+      readonly poolId: v.StringSchema<undefined>;
+      readonly assetASparkTransferId: v.StringSchema<undefined>;
+      readonly poolOwnerPublicKey: v.StringSchema<undefined>;
+      readonly nonce: v.StringSchema<undefined>;
+    }, undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"createConstantProductPool", undefined>;
+    readonly data: v.ObjectSchema<{
+      readonly poolOwnerPublicKey: v.StringSchema<undefined>;
+      readonly assetAAddress: v.StringSchema<undefined>;
+      readonly assetBAddress: v.StringSchema<undefined>;
+      readonly lpFeeRateBps: v.UnionSchema<[v.NumberSchema<undefined>, v.StringSchema<undefined>], undefined>;
+      readonly totalHostFeeRateBps: v.UnionSchema<[v.NumberSchema<undefined>, v.StringSchema<undefined>], undefined>;
+      readonly nonce: v.StringSchema<undefined>;
+    }, undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"createSingleSidedPool", undefined>;
+    readonly data: v.ObjectSchema<{
+      readonly assetAAddress: v.StringSchema<undefined>;
+      readonly assetBAddress: v.StringSchema<undefined>;
+      readonly assetAInitialReserve: v.StringSchema<undefined>;
+      readonly virtualReserveA: v.UnionSchema<[v.NumberSchema<undefined>, v.StringSchema<undefined>], undefined>;
+      readonly virtualReserveB: v.UnionSchema<[v.NumberSchema<undefined>, v.StringSchema<undefined>], undefined>;
+      readonly threshold: v.UnionSchema<[v.NumberSchema<undefined>, v.StringSchema<undefined>], undefined>;
+      readonly lpFeeRateBps: v.UnionSchema<[v.NumberSchema<undefined>, v.StringSchema<undefined>], undefined>;
+      readonly totalHostFeeRateBps: v.UnionSchema<[v.NumberSchema<undefined>, v.StringSchema<undefined>], undefined>;
+      readonly poolOwnerPublicKey: v.StringSchema<undefined>;
+      readonly nonce: v.StringSchema<undefined>;
+    }, undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"removeLiquidity", undefined>;
+    readonly data: v.ObjectSchema<{
+      readonly userPublicKey: v.StringSchema<undefined>;
+      readonly poolId: v.StringSchema<undefined>;
+      readonly lpTokensToRemove: v.StringSchema<undefined>;
+      readonly nonce: v.StringSchema<undefined>;
+    }, undefined>;
+  }, undefined>], undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type SparkFlashnetSignIntentRequest = v.InferOutput<typeof sparkFlashnetSignIntentRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/spark/flashnetSignStructuredMessage/request.d.ts
+declare const sparkFlashnetSignStructuredMessageRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"spark_flashnet_signStructuredMessage", undefined>;
+  readonly params: v.ObjectSchema<{
+    readonly message: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type SparkFlashnetSignStructuredMessageRequest = v.InferOutput<typeof sparkFlashnetSignStructuredMessageRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/spark/flashnetExecuteSwap/request.d.ts
+declare const sparkFlashnetExecuteSwapRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"spark_flashnet_executeSwap", undefined>;
+  readonly params: v.ObjectSchema<{
+    readonly poolId: v.StringSchema<undefined>;
+    readonly assetInAddress: v.StringSchema<undefined>;
+    readonly assetOutAddress: v.StringSchema<undefined>;
+    readonly amountIn: v.StringSchema<undefined>;
+    readonly maxSlippageBps: v.NumberSchema<undefined>;
+    readonly minAmountOut: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly integratorFeeRateBps: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    readonly integratorPublicKey: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type SparkFlashnetExecuteSwapRequest = v.InferOutput<typeof sparkFlashnetExecuteSwapRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/spark/flashnetExecuteRouteSwap/request.d.ts
+declare const sparkFlashnetExecuteRouteSwapRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"spark_flashnet_executeRouteSwap", undefined>;
+  readonly params: v.ObjectSchema<{
+    readonly hops: v.ArraySchema<v.ObjectSchema<{
+      readonly poolId: v.StringSchema<undefined>;
+      readonly assetInAddress: v.StringSchema<undefined>;
+      readonly assetOutAddress: v.StringSchema<undefined>;
+      readonly hopIntegratorFeeRateBps: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+    readonly initialAssetAddress: v.StringSchema<undefined>;
+    readonly inputAmount: v.StringSchema<undefined>;
+    readonly maxRouteSlippageBps: v.StringSchema<undefined>;
+    readonly minAmountOut: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly integratorFeeRateBps: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    readonly integratorPublicKey: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type SparkFlashnetExecuteRouteSwapRequest = v.InferOutput<typeof sparkFlashnetExecuteRouteSwapRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/spark/flashnetClawbackFunds/request.d.ts
+declare const sparkFlashnetClawbackFundsRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"spark_flashnet_clawbackFunds", undefined>;
+  readonly params: v.ObjectSchema<{
+    readonly sparkTransferId: v.StringSchema<undefined>;
+    readonly lpIdentityPublicKey: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type SparkFlashnetClawbackFundsRequest = v.InferOutput<typeof sparkFlashnetClawbackFundsRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/spark/getClawbackEligibleTransfers/request.d.ts
+declare const sparkGetClawbackEligibleTransfersRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"spark_getClawbackEligibleTransfers", undefined>;
+  readonly params: v.NullishSchema<v.NullSchema<undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type SparkGetClawbackEligibleTransfersRequest = v.InferOutput<typeof sparkGetClawbackEligibleTransfersRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/runes/estimateEtch/request.d.ts
+declare const runesEstimateEtchRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"runes_estimateEtch", undefined>;
+  readonly params: v.ObjectSchema<{
+    readonly runeName: v.StringSchema<undefined>;
+    readonly divisibility: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    readonly symbol: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly premine: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly isMintable: v.BooleanSchema<undefined>;
+    readonly terms: v.OptionalSchema<v.ObjectSchema<{
+      readonly amount: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      readonly cap: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      readonly heightStart: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      readonly heightEnd: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      readonly offsetStart: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      readonly offsetEnd: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+    readonly inscriptionDetails: v.OptionalSchema<v.ObjectSchema<{
+      readonly contentType: v.StringSchema<undefined>;
+      readonly contentBase64: v.StringSchema<undefined>;
+    }, undefined>, undefined>;
+    readonly delegateInscriptionId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly destinationAddress: v.StringSchema<undefined>;
+    readonly feeRate: v.NumberSchema<undefined>;
+    readonly appServiceFee: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    readonly appServiceFeeAddress: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly network: v.OptionalSchema<v.EnumSchema<typeof BitcoinNetworkType, undefined>, undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type RunesEstimateEtchRequest = v.InferOutput<typeof runesEstimateEtchRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/runes/estimateMint/request.d.ts
+declare const runesEstimateMintRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"runes_estimateMint", undefined>;
+  readonly params: v.ObjectSchema<{
+    readonly runeName: v.StringSchema<undefined>;
+    readonly repeats: v.NumberSchema<undefined>;
+    readonly destinationAddress: v.StringSchema<undefined>;
+    readonly feeRate: v.NumberSchema<undefined>;
+    readonly appServiceFee: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    readonly appServiceFeeAddress: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly network: v.OptionalSchema<v.EnumSchema<typeof BitcoinNetworkType, undefined>, undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type RunesEstimateMintRequest = v.InferOutput<typeof runesEstimateMintRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/runes/estimateRbfOrder/request.d.ts
+declare const runesEstimateRbfOrderRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"runes_estimateRbfOrder", undefined>;
+  readonly params: v.ObjectSchema<{
+    readonly orderId: v.StringSchema<undefined>;
+    readonly newFeeRate: v.NumberSchema<undefined>;
+    readonly network: v.OptionalSchema<v.EnumSchema<typeof BitcoinNetworkType, undefined>, undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type RunesEstimateRbfOrderRequest = v.InferOutput<typeof runesEstimateRbfOrderRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/runes/etch/request.d.ts
+declare const runesEtchRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"runes_etch", undefined>;
+  readonly params: v.ObjectSchema<{
+    readonly runeName: v.StringSchema<undefined>;
+    readonly divisibility: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    readonly symbol: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly premine: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly isMintable: v.BooleanSchema<undefined>;
+    readonly terms: v.OptionalSchema<v.ObjectSchema<{
+      readonly amount: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      readonly cap: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      readonly heightStart: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      readonly heightEnd: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      readonly offsetStart: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      readonly offsetEnd: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+    readonly inscriptionDetails: v.OptionalSchema<v.ObjectSchema<{
+      readonly contentType: v.StringSchema<undefined>;
+      readonly contentBase64: v.StringSchema<undefined>;
+    }, undefined>, undefined>;
+    readonly delegateInscriptionId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly destinationAddress: v.StringSchema<undefined>;
+    readonly refundAddress: v.StringSchema<undefined>;
+    readonly feeRate: v.NumberSchema<undefined>;
+    readonly appServiceFee: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    readonly appServiceFeeAddress: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly network: v.OptionalSchema<v.EnumSchema<typeof BitcoinNetworkType, undefined>, undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type RunesEtchRequest = v.InferOutput<typeof runesEtchRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/runes/getBalance/request.d.ts
+declare const runesGetBalanceRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"runes_getBalance", undefined>;
+  readonly params: v.NullishSchema<v.NullSchema<undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type RunesGetBalanceRequest = v.InferOutput<typeof runesGetBalanceRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/runes/getOrder/request.d.ts
+declare const runesGetOrderRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"runes_getOrder", undefined>;
+  readonly params: v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+    readonly network: v.OptionalSchema<v.EnumSchema<typeof BitcoinNetworkType, undefined>, undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type RunesGetOrderRequest = v.InferOutput<typeof runesGetOrderRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/runes/mint/request.d.ts
+declare const runesMintRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"runes_mint", undefined>;
+  readonly params: v.ObjectSchema<{
+    readonly appServiceFee: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    readonly appServiceFeeAddress: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly destinationAddress: v.StringSchema<undefined>;
+    readonly feeRate: v.NumberSchema<undefined>;
+    readonly refundAddress: v.StringSchema<undefined>;
+    readonly repeats: v.NumberSchema<undefined>;
+    readonly runeName: v.StringSchema<undefined>;
+    readonly network: v.OptionalSchema<v.EnumSchema<typeof BitcoinNetworkType, undefined>, undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type RunesMintRequest = v.InferOutput<typeof runesMintRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/runes/rbfOrder/request.d.ts
+declare const runesRbfOrderRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"runes_rbfOrder", undefined>;
+  readonly params: v.ObjectSchema<{
+    readonly orderId: v.StringSchema<undefined>;
+    readonly newFeeRate: v.NumberSchema<undefined>;
+    readonly network: v.OptionalSchema<v.EnumSchema<typeof BitcoinNetworkType, undefined>, undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type RunesRbfOrderRequest = v.InferOutput<typeof runesRbfOrderRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/runes/transfer/request.d.ts
+declare const runesTransferRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"runes_transfer", undefined>;
+  readonly params: v.ObjectSchema<{
+    readonly recipients: v.ArraySchema<v.ObjectSchema<{
+      readonly runeName: v.StringSchema<undefined>;
+      readonly amount: v.StringSchema<undefined>;
+      readonly address: v.StringSchema<undefined>;
+    }, undefined>, undefined>;
+    readonly network: v.OptionalSchema<v.EnumSchema<typeof BitcoinNetworkType, undefined>, undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type RunesTransferRequest = v.InferOutput<typeof runesTransferRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/ordinals/getInscriptions/request.d.ts
+declare const ordinalsGetInscriptionsRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"ord_getInscriptions", undefined>;
+  readonly params: v.ObjectSchema<{
+    readonly offset: v.NumberSchema<undefined>;
+    readonly limit: v.NumberSchema<undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type OrdinalsGetInscriptionsRequest = v.InferOutput<typeof ordinalsGetInscriptionsRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/ordinals/sendInscriptions/request.d.ts
+declare const ordinalsSendInscriptionsRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"ord_sendInscriptions", undefined>;
+  readonly params: v.ObjectSchema<{
+    readonly transfers: v.ArraySchema<v.ObjectSchema<{
+      readonly address: v.StringSchema<undefined>;
+      readonly inscriptionId: v.StringSchema<undefined>;
+    }, undefined>, undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type OrdinalsSendInscriptionsRequest = v.InferOutput<typeof ordinalsSendInscriptionsRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/addNetwork/request.d.ts
+declare const walletAddNetworkRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"wallet_addNetwork", undefined>;
+  readonly params: v.VariantSchema<"chain", [v.ObjectSchema<{
+    readonly chain: v.LiteralSchema<"bitcoin", undefined>;
+    readonly type: v.PicklistSchema<["Mainnet", "Testnet", "Signet"], undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly rpcUrl: v.StringSchema<undefined>;
+    readonly rpcFallbackUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly indexerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly switch: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly chain: v.LiteralSchema<"stacks", undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly type: v.PicklistSchema<["Mainnet", "Testnet"], undefined>;
+    readonly rpcUrl: v.StringSchema<undefined>;
+    readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly switch: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly chain: v.LiteralSchema<"starknet", undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly type: v.PicklistSchema<["Mainnet", "Testnet", "Sepolia"], undefined>;
+    readonly rpcUrl: v.StringSchema<undefined>;
+    readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly switch: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+  }, undefined>], undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletAddNetworkRequest = v.InferOutput<typeof walletAddNetworkRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/addNetworkV2/request.d.ts
+declare const walletAddNetworkV2RequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"wallet_addNetworkV2", undefined>;
+  readonly params: v.ObjectSchema<{
+    readonly network: v.VariantSchema<"chain", [v.ObjectSchema<{
+      readonly chain: v.LiteralSchema<"bitcoin", undefined>;
+      readonly type: v.PicklistSchema<["Mainnet", "Testnet", "Signet"], undefined>;
+      readonly name: v.StringSchema<undefined>;
+      readonly rpcUrl: v.StringSchema<undefined>;
+      readonly rpcFallbackUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      readonly indexerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly chain: v.LiteralSchema<"spark", undefined>;
+      readonly type: v.PicklistSchema<["Mainnet", "Testnet"], undefined>;
+      readonly name: v.StringSchema<undefined>;
+      readonly rpcUrl: v.StringSchema<undefined>;
+      readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly chain: v.LiteralSchema<"stacks", undefined>;
+      readonly type: v.PicklistSchema<["Mainnet", "Testnet"], undefined>;
+      readonly name: v.StringSchema<undefined>;
+      readonly rpcUrl: v.StringSchema<undefined>;
+      readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly chain: v.LiteralSchema<"starknet", undefined>;
+      readonly type: v.PicklistSchema<["Mainnet", "Testnet", "Sepolia"], undefined>;
+      readonly name: v.StringSchema<undefined>;
+      readonly rpcUrl: v.StringSchema<undefined>;
+      readonly blockExplorerUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>], undefined>;
+    readonly isActive: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletAddNetworkV2Request = v.InferOutput<typeof walletAddNetworkV2RequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/changeNetworkById/request.d.ts
+declare const walletChangeNetworkByIdRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"wallet_changeNetworkById", undefined>;
+  readonly params: v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletChangeNetworkByIdRequest = v.InferOutput<typeof walletChangeNetworkByIdRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/changeNetwork/request.d.ts
+declare const walletChangeNetworkRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"wallet_changeNetwork", undefined>;
+  readonly params: v.ObjectSchema<{
+    readonly name: v.PicklistSchema<["Mainnet", "Testnet", "Signet"], undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletChangeNetworkRequest = v.InferOutput<typeof walletChangeNetworkRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/connect/request.d.ts
+declare const walletConnectRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"wallet_connect", undefined>;
+  readonly params: v.NullishSchema<v.ObjectSchema<{
+    readonly permissions: v.OptionalSchema<v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
+      readonly type: v.LiteralSchema<"account", undefined>;
+      readonly resourceId: v.StringSchema<undefined>;
+      readonly actions: v.ObjectSchema<{
+        readonly read: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+      }, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly type: v.LiteralSchema<"wallet", undefined>;
+      readonly resourceId: v.StringSchema<undefined>;
+      readonly actions: v.ObjectSchema<{
+        readonly readNetwork: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+      }, undefined>;
+    }, undefined>], undefined>, undefined>, undefined>;
+    readonly addresses: v.OptionalSchema<v.ArraySchema<v.EnumSchema<typeof AddressPurpose, undefined>, undefined>, undefined>;
+    readonly message: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 80, "The message must not exceed 80 characters.">]>, undefined>;
+    readonly network: v.OptionalSchema<v.PicklistSchema<["Mainnet", "Testnet", "Signet"], undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletConnectRequest = v.InferOutput<typeof walletConnectRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/connectV2/request.d.ts
+declare const walletConnectV2RequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"wallet_connectV2", undefined>;
+  readonly params: v.NullishSchema<v.ObjectSchema<{
+    readonly permissions: v.OptionalSchema<v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
+      readonly type: v.LiteralSchema<"account", undefined>;
+      readonly resourceId: v.StringSchema<undefined>;
+      readonly actions: v.ObjectSchema<{
+        readonly read: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+      }, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly type: v.LiteralSchema<"wallet", undefined>;
+      readonly resourceId: v.StringSchema<undefined>;
+      readonly actions: v.ObjectSchema<{
+        readonly readNetwork: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+      }, undefined>;
+    }, undefined>], undefined>, undefined>, undefined>;
+    readonly addresses: v.OptionalSchema<v.ArraySchema<v.EnumSchema<typeof AddressPurpose, undefined>, undefined>, undefined>;
+    readonly message: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 80, "The message must not exceed 80 characters.">]>, undefined>;
+    readonly networkId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletConnectV2Request = v.InferOutput<typeof walletConnectV2RequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/disconnect/request.d.ts
+declare const walletDisconnectRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"wallet_disconnect", undefined>;
+  readonly params: v.NullishSchema<v.NullSchema<undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletDisconnectRequest = v.InferOutput<typeof walletDisconnectRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/getAccount/request.d.ts
+declare const walletGetAccountRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"wallet_getAccount", undefined>;
+  readonly params: v.NullishSchema<v.NullSchema<undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletGetAccountRequest = v.InferOutput<typeof walletGetAccountRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/getAccountV2/request.d.ts
+declare const walletGetAccountV2RequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"wallet_getAccountV2", undefined>;
+  readonly params: v.NullishSchema<v.NullSchema<undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletGetAccountV2Request = v.InferOutput<typeof walletGetAccountV2RequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/getCurrentPermissions/request.d.ts
+declare const walletGetCurrentPermissionsRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"wallet_getCurrentPermissions", undefined>;
+  readonly params: v.NullishSchema<v.NullSchema<undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletGetCurrentPermissionsRequest = v.InferOutput<typeof walletGetCurrentPermissionsRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/getNetwork/request.d.ts
+declare const walletGetNetworkRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"wallet_getNetwork", undefined>;
+  readonly params: v.NullishSchema<v.NullSchema<undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletGetNetworkRequest = v.InferOutput<typeof walletGetNetworkRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/getNetworks/request.d.ts
+declare const walletGetNetworksRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"wallet_getNetworks", undefined>;
+  readonly params: v.NullishSchema<v.NullSchema<undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletGetNetworksRequest = v.InferOutput<typeof walletGetNetworksRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/getWalletType/request.d.ts
+declare const walletGetWalletTypeRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"wallet_getWalletType", undefined>;
+  readonly params: v.NullishSchema<v.NullSchema<undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletGetWalletTypeRequest = v.InferOutput<typeof walletGetWalletTypeRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/openBridge/request.d.ts
+declare const walletOpenBridgeRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"wallet_openBridge", undefined>;
+  readonly params: v.ObjectSchema<{
+    readonly fromAsset: v.StringSchema<undefined>;
+    readonly toAsset: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletOpenBridgeRequest = v.InferOutput<typeof walletOpenBridgeRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/openBuy/request.d.ts
+declare const walletOpenBuyRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"wallet_openBuy", undefined>;
+  readonly params: v.ObjectSchema<{
+    readonly asset: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletOpenBuyRequest = v.InferOutput<typeof walletOpenBuyRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/openReceive/request.d.ts
+declare const walletOpenReceiveRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"wallet_openReceive", undefined>;
+  readonly params: v.ObjectSchema<{
+    readonly address: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletOpenReceiveRequest = v.InferOutput<typeof walletOpenReceiveRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/renouncePermissions/request.d.ts
+declare const walletRenouncePermissionsRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"wallet_renouncePermissions", undefined>;
+  readonly params: v.NullishSchema<v.NullSchema<undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletRenouncePermissionsRequest = v.InferOutput<typeof walletRenouncePermissionsRequestSchema>;
+//#endregion
+//#region src/request/rpc/methodSchemas/wallet/requestPermissions/request.d.ts
+declare const walletRequestPermissionsRequestSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly method: v.LiteralSchema<"wallet_requestPermissions", undefined>;
+  readonly params: v.NullishSchema<v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"account", undefined>;
+    readonly resourceId: v.StringSchema<undefined>;
+    readonly actions: v.ObjectSchema<{
+      readonly read: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    }, undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"wallet", undefined>;
+    readonly resourceId: v.StringSchema<undefined>;
+    readonly actions: v.ObjectSchema<{
+      readonly readNetwork: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    }, undefined>;
+  }, undefined>], undefined>, undefined>, undefined>;
+  readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type WalletRequestPermissionsRequest = v.InferOutput<typeof walletRequestPermissionsRequestSchema>;
+//#endregion
+//#region src/request/rpc/requests.d.ts
+type RpcRequests = ExactObject<Method, {
+  [bitcoinMethods.getAccounts]: BitcoinGetAccountsRequest;
+  [bitcoinMethods.bitcoin_getAccountsV2]: BitcoinGetAccountsV2Request;
+  [bitcoinMethods.getAddresses]: BitcoinGetAddressesRequest;
+  [bitcoinMethods.bitcoin_getAddressesV2]: BitcoinGetAddressesV2Request;
+  [bitcoinMethods.getBalance]: BitcoinGetBalanceRequest;
+  [bitcoinMethods.bitcoin_getBalanceV2]: BitcoinGetBalanceV2Request;
+  [bitcoinMethods.getInfo]: BitcoinGetInfoRequest;
+  [bitcoinMethods.bitcoin_getInfoV2]: BitcoinGetInfoV2Request;
+  [bitcoinMethods.sendTransfer]: BitcoinSendTransferRequest;
+  [bitcoinMethods.bitcoin_sendTransferV2]: BitcoinSendTransferV2Request;
+  [bitcoinMethods.signMessage]: BitcoinSignMessageRequest;
+  [bitcoinMethods.bitcoin_signMessageV2]: BitcoinSignMessageV2Request;
+  [bitcoinMethods.signMultipleMessages]: BitcoinSignMultipleMessagesRequest;
+  [bitcoinMethods.bitcoin_signMultipleMessagesV2]: BitcoinSignMultipleMessagesV2Request;
+  [bitcoinMethods.signPsbt]: BitcoinSignPsbtRequest;
+  [bitcoinMethods.bitcoin_signPsbtV2]: BitcoinSignPsbtV2Request;
+  [stacksMethods.stx_callContract]: StacksCallContractRequest;
+  [stacksMethods.stx_deployContract]: StacksDeployContractRequest;
+  [stacksMethods.stx_getAccounts]: StacksGetAccountsRequest;
+  [stacksMethods.stx_getAddresses]: StacksGetAddressesRequest;
+  [stacksMethods.stacks_getAddressesV2]: StacksGetAddressesV2Request;
+  [stacksMethods.stx_signMessage]: StacksSignMessageRequest;
+  [stacksMethods.stx_signStructuredMessage]: StacksSignStructuredMessageRequest;
+  [stacksMethods.stx_signTransaction]: StacksSignTransactionRequest;
+  [stacksMethods.stx_signTransactions]: StacksSignTransactionsRequest;
+  [stacksMethods.stx_transferStx]: StacksTransferStxRequest;
+  [sparkMethods.spark_getAddresses]: SparkGetAddressesRequest;
+  [sparkMethods.spark_getAddressesV2]: SparkGetAddressesV2Request;
+  [sparkMethods.spark_getBalance]: SparkGetBalanceRequest;
+  [sparkMethods.spark_transfer]: SparkTransferRequest;
+  [sparkMethods.spark_transferToken]: SparkTransferTokenRequest;
+  [sparkMethods.spark_signMessage]: SparkSignMessageRequest;
+  [sparkMethods.spark_flashnet_getJwt]: SparkFlashnetGetJwtRequest;
+  [sparkMethods.spark_flashnet_signIntent]: SparkFlashnetSignIntentRequest;
+  [sparkMethods.spark_flashnet_signStructuredMessage]: SparkFlashnetSignStructuredMessageRequest;
+  [sparkMethods.spark_flashnet_executeSwap]: SparkFlashnetExecuteSwapRequest;
+  [sparkMethods.spark_flashnet_executeRouteSwap]: SparkFlashnetExecuteRouteSwapRequest;
+  [sparkMethods.spark_flashnet_clawbackFunds]: SparkFlashnetClawbackFundsRequest;
+  [sparkMethods.spark_getClawbackEligibleTransfers]: SparkGetClawbackEligibleTransfersRequest;
+  [runesMethods.runes_estimateEtch]: RunesEstimateEtchRequest;
+  [runesMethods.runes_estimateMint]: RunesEstimateMintRequest;
+  [runesMethods.runes_estimateRbfOrder]: RunesEstimateRbfOrderRequest;
+  [runesMethods.runes_etch]: RunesEtchRequest;
+  [runesMethods.runes_getBalance]: RunesGetBalanceRequest;
+  [runesMethods.runes_getOrder]: RunesGetOrderRequest;
+  [runesMethods.runes_mint]: RunesMintRequest;
+  [runesMethods.runes_rbfOrder]: RunesRbfOrderRequest;
+  [runesMethods.runes_transfer]: RunesTransferRequest;
+  [ordinalsMethods.ord_getInscriptions]: OrdinalsGetInscriptionsRequest;
+  [ordinalsMethods.ord_sendInscriptions]: OrdinalsSendInscriptionsRequest;
+  [walletMethods.wallet_addNetwork]: WalletAddNetworkRequest;
+  [walletMethods.wallet_addNetworkV2]: WalletAddNetworkV2Request;
+  [walletMethods.wallet_changeNetworkById]: WalletChangeNetworkByIdRequest;
+  [walletMethods.wallet_changeNetwork]: WalletChangeNetworkRequest;
+  [walletMethods.wallet_connect]: WalletConnectRequest;
+  [walletMethods.wallet_connectV2]: WalletConnectV2Request;
+  [walletMethods.wallet_disconnect]: WalletDisconnectRequest;
+  [walletMethods.wallet_getAccount]: WalletGetAccountRequest;
+  [walletMethods.wallet_getAccountV2]: WalletGetAccountV2Request;
+  [walletMethods.wallet_getCurrentPermissions]: WalletGetCurrentPermissionsRequest;
+  [walletMethods.wallet_getNetwork]: WalletGetNetworkRequest;
+  [walletMethods.wallet_getNetworks]: WalletGetNetworksRequest;
+  [walletMethods.wallet_getWalletType]: WalletGetWalletTypeRequest;
+  [walletMethods.wallet_openBridge]: WalletOpenBridgeRequest;
+  [walletMethods.wallet_openBuy]: WalletOpenBuyRequest;
+  [walletMethods.wallet_openReceive]: WalletOpenReceiveRequest;
+  [walletMethods.wallet_renouncePermissions]: WalletRenouncePermissionsRequest;
+  [walletMethods.wallet_requestPermissions]: WalletRequestPermissionsRequest;
+}>;
+type RpcRequestParams<M extends Method> = RpcRequests[M]['params'];
+//#endregion
+//#region src/request/types/index.d.ts
+type GetInfoResult = RpcSuccessResponseResult<typeof bitcoinMethods.getInfo>;
+//#endregion
+//#region src/request/index.d.ts
+declare const request: <Method$1 extends keyof RpcRequests>(method: Method$1, params: RpcRequestParams<Method$1>,
+/**
+ * The providerId is the object path to the provider in the window object.
+ * E.g., a provider available at `window.Foo.BarProvider` would have a
+ * providerId of `Foo.BarProvider`.
+ */
+providerId?: string) => Promise<RpcResult<Method$1>>;
+/**
+ * Adds an event listener.
+ *
+ * Currently expects 2 arguments, although is also capable of handling legacy
+ * calls with 3 arguments consisting of:
+ *
+ * - event name (string)
+ * - callback (function)
+ * - provider ID (optional string)
+ */
+declare const addListener: (...rawArgs: unknown[]) => ReturnType<AddListener>;
+//#endregion
+//#region src/adapters/satsConnectAdapter.d.ts
+declare abstract class SatsConnectAdapter {
+  abstract readonly id: string;
+  private mintRunes;
+  private etchRunes;
+  private estimateMint;
+  private estimateEtch;
+  private getOrder;
+  private estimateRbfOrder;
+  private rbfOrder;
+  request<Method$1 extends keyof RpcRequests>(method: Method$1, params: RpcRequestParams<Method$1>): Promise<RpcResult<Method$1>>;
+  abstract addListener: AddListener;
+  protected abstract requestInternal<Method$1 extends keyof RpcRequests>(method: Method$1, params: RpcRequestParams<Method$1>): Promise<RpcResult<Method$1>>;
+}
+//#endregion
+//#region src/adapters/BaseAdapter.d.ts
+declare class BaseAdapter extends SatsConnectAdapter {
+  id: string;
+  constructor(providerId: string);
+  requestInternal: <Method$1 extends keyof RpcRequests>(method: Method$1, params: RpcRequestParams<Method$1>) => Promise<RpcResult<Method$1>>;
+  addListener: AddListener;
+}
+//#endregion
+//#region src/adapters/index.d.ts
+declare const DefaultAdaptersInfo: Record<string, Provider>;
+declare const defaultAdapters: Record<string, new () => SatsConnectAdapter>;
+//#endregion
+export { AccountChangeCallback, AccountChangeEvent, AddListener, Address, AddressPurpose, AddressType, BaseAdapter, BitcoinNetwork, BitcoinNetworkType, BitcoinProvider, type BitcoinMethod as BitcoinRequestMethod, Capability, CreateInscriptionOptions, CreateInscriptionPayload, CreateInscriptionResponse, CreateRepeatInscriptionsOptions, CreateRepeatInscriptionsPayload, CreateRepeatInscriptionsResponse, DefaultAdaptersInfo, DisconnectCallback, DisconnectEvent, GetAddressOptions, GetAddressPayload, GetAddressResponse, GetCapabilitiesOptions, GetCapabilitiesPayload, GetCapabilitiesResponse, GetInfoResult, InputToSign, ListenerInfo, MessageSigningProtocols, MethodParamsAndResult, NetworkChangeCallback, NetworkChangeEvent, NetworkChangeEventV2, type OrdinalsMethod as OrdinalsRequestMethod, type RpcRequestParams as Params, Provider, ProviderPlatform, PsbtPayload, Recipient, RequestOptions, RequestPayload, type RpcRequests as Requests, type RpcSuccessResponseResult as Return, RpcBase, RpcError, RpcErrorCode, RpcErrorResponse, RpcErrorResponseMessage, RpcId, RpcIdSchema, RpcRequest, RpcRequestMessage, RpcResponse, RpcResponseMessage, RpcResult, RpcSuccessResponse, RpcSuccessResponseMessage, type RunesMethod as RunesRequestMethod, SatsConnectAdapter, SendBtcTransactionOptions, SendBtcTransactionPayload, SendBtcTransactionResponse, SerializedRecipient, SerializedSendBtcTransactionPayload, SignMessageOptions, SignMessagePayload, SignMessageResponse, SignMultiplePsbtPayload, SignMultipleTransactionOptions, SignMultipleTransactionsPayload, SignMultipleTransactionsResponse, SignTransactionOptions, SignTransactionPayload, SignTransactionResponse, SparkNetworkType, type SparkMethod as SparkRequestMethod, StacksNetworkType, type StacksMethod as StacksRequestMethod, StarknetNetworkType, SupportedWallet, WalletEvent, type WalletMethod as WalletRequestMethod, accountChangeEventName, accountChangeSchema, addListener, addressSchema, createInscription, createRepeatInscriptions, defaultAdapters, disconnectEventName, disconnectSchema, getAddress, getCapabilities, getDefaultProvider, getProviderById, getProviderOrThrow, getProviders, getSupportedWallets, isProviderInstalled, networkChangeEventName, networkChangeEventNameV2, networkChangeSchema, networkChangeV2Schema, removeDefaultProvider, request, rpcErrorResponseMessageSchema, rpcRequestMessageSchema, rpcResponseMessageSchema, rpcSuccessResponseMessageSchema, sendBtcTransaction, setDefaultProvider, signMessage, signMultipleTransactions, signTransaction, walletEventSchema };