@sats-connect/core 0.4.0-7721c7c → 0.4.0-7a3cb13

package/dist/index.d.mts

@@ -42,15 +42,15 @@ type SignMessageOptions = RequestOptions<SignMessagePayload, SignMessageResponse
 
 declare const signMessage: (options: SignMessageOptions) => Promise<void>;
 
-interface Recipient$2 {
+interface Recipient {
     address: string;
     amountSats: bigint;
 }
-type SerializedRecipient = Omit<Recipient$2, 'amountSats'> & {
+type SerializedRecipient = Omit<Recipient, 'amountSats'> & {
     amountSats: string;
 };
 interface SendBtcTransactionPayload extends RequestPayload {
-    recipients: Recipient$2[];
+    recipients: Recipient[];
     senderAddress: string;
     message?: string;
 }
@@ -193,7 +193,7 @@ 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>, never>;
-    readonly id: v.OptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.NullSchema<undefined>], undefined>, never>;
+    readonly id: v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.NullSchema<undefined>], undefined>;
 }, undefined>;
 type RpcRequestMessage = v.InferOutput<typeof rpcRequestMessageSchema>;
 interface RpcBase {
@@ -313,9 +313,9 @@ declare const addressSchema: v.ObjectSchema<{
     readonly purpose: v.EnumSchema<typeof AddressPurpose, undefined>;
     readonly addressType: v.EnumSchema<typeof AddressType, undefined>;
 }, undefined>;
-type Address$1 = v.InferOutput<typeof addressSchema>;
+type Address = v.InferOutput<typeof addressSchema>;
 interface GetAddressResponse {
-    addresses: Address$1[];
+    addresses: Address[];
 }
 type GetAddressOptions = RequestOptions<GetAddressPayload, GetAddressResponse>;
 
@@ -455,61 +455,94 @@ declare const signMessageRequestMessageSchema: v.ObjectSchema<{
 }, undefined>;
 type SignMessageRequestMessage = v.InferOutput<typeof signMessageRequestMessageSchema>;
 type SignMessage = MethodParamsAndResult<v.InferOutput<typeof signMessageParamsSchema>, v.InferOutput<typeof signMessageResultSchema>>;
-type Recipient$1 = {
-    /**
-     * The recipient's address.
-     **/
-    address: string;
-    /**
-     * The amount to send to the recipient in satoshis.
-     */
-    amount: number;
-};
-type SendTransferParams = {
+declare const sendTransferMethodName = "sendTransfer";
+declare const sendTransferParamsSchema: v.ObjectSchema<{
     /**
      * Array of recipients to send to.
      * The amount to send to each recipient is in satoshis.
      */
-    recipients: Array<Recipient$1>;
-};
-type SendTransferResult = {
+    readonly recipients: v.ArraySchema<v.ObjectSchema<{
+        readonly address: v.StringSchema<undefined>;
+        readonly amount: v.NumberSchema<undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+type SendTransferParams = v.InferOutput<typeof sendTransferParamsSchema>;
+declare const sendTransferResultSchema: v.ObjectSchema<{
     /**
      * The transaction id as a hex-encoded string.
      */
-    txid: string;
-};
+    readonly txid: v.StringSchema<undefined>;
+}, undefined>;
+type SendTransferResult = v.InferOutput<typeof sendTransferResultSchema>;
+declare const sendTransferRequestMessageSchema: v.ObjectSchema<{
+    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 id: v.StringSchema<undefined>;
+    readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type SendTransferRequestMessage = v.InferOutput<typeof sendTransferRequestMessageSchema>;
 type SendTransfer = MethodParamsAndResult<SendTransferParams, SendTransferResult>;
-type SignPsbtParams = {
+declare const signPsbtMethodName = "signPsbt";
+declare const signPsbtParamsSchema: v.ObjectSchema<{
     /**
      * The base64 encoded PSBT to sign.
      */
-    psbt: string;
+    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.
      */
-    signInputs: Record<string, number[]>;
-    /**
-     * the sigHash type to use for signing.
-     * will default to the sighash type of the input if not provided.
-     **/
-    allowedSignHash?: number;
+    readonly signInputs: v.RecordSchema<v.StringSchema<undefined>, v.ArraySchema<v.NumberSchema<undefined>, undefined>, undefined>;
+    readonly allowedSignHash: v.OptionalSchema<v.NumberSchema<undefined>, never>;
     /**
      * Whether to broadcast the transaction after signing.
      **/
-    broadcast?: boolean;
-};
-type SignPsbtResult = {
+    readonly broadcast: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+}, undefined>;
+type SignPsbtParams = v.InferOutput<typeof signPsbtParamsSchema>;
+declare const signPsbtResultSchema: v.ObjectSchema<{
     /**
      * The base64 encoded PSBT after signing.
      */
-    psbt: string;
+    readonly psbt: v.StringSchema<undefined>;
     /**
      * The transaction id as a hex-encoded string.
      * This is only returned if the transaction was broadcast.
      **/
-    txid?: string;
-};
+    readonly txid: v.OptionalSchema<v.StringSchema<undefined>, never>;
+}, undefined>;
+type SignPsbtResult = v.InferOutput<typeof signPsbtResultSchema>;
+declare const signPsbtRequestMessageSchema: v.ObjectSchema<{
+    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.RecordSchema<v.StringSchema<undefined>, v.ArraySchema<v.NumberSchema<undefined>, undefined>, undefined>;
+        readonly allowedSignHash: v.OptionalSchema<v.NumberSchema<undefined>, never>;
+        /**
+         * Whether to broadcast the transaction after signing.
+         **/
+        readonly broadcast: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+    }, undefined>;
+    readonly id: v.StringSchema<undefined>;
+    readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type SignPsbtRequestMessage = v.InferOutput<typeof signPsbtRequestMessageSchema>;
 type SignPsbt = MethodParamsAndResult<SignPsbtParams, SignPsbtResult>;
 declare const getAccountsMethodName = "getAccounts";
 declare const getAccountsParamsSchema: v.ObjectSchema<{
@@ -554,6 +587,7 @@ type GetAccountsRequestMessage = v.InferOutput<typeof getAccountsRequestMessageS
 type GetAccounts = MethodParamsAndResult<v.InferOutput<typeof getAccountsParamsSchema>, v.InferOutput<typeof getAccountsResultSchema>>;
 declare const getBalanceMethodName = "getBalance";
 declare const getBalanceParamsSchema: v.NullishSchema<v.NullSchema<undefined>, never>;
+type GetBalanceParams = v.InferOutput<typeof getBalanceParamsSchema>;
 declare const getBalanceResultSchema: v.ObjectSchema<{
     /**
      * The confirmed balance of the wallet in sats. Using a string due to chrome
@@ -574,19 +608,22 @@ declare const getBalanceResultSchema: v.ObjectSchema<{
      */
     readonly total: v.StringSchema<undefined>;
 }, undefined>;
+type GetBalanceResult = v.InferOutput<typeof getBalanceResultSchema>;
 declare const getBalanceRequestMessageSchema: v.ObjectSchema<{
     readonly method: v.LiteralSchema<"getBalance", undefined>;
     readonly id: v.StringSchema<undefined>;
     readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
     readonly params: v.OptionalSchema<v.UnionSchema<[v.ArraySchema<v.UnknownSchema, undefined>, v.LooseObjectSchema<{}, undefined>, v.NullSchema<undefined>], undefined>, never>;
 }, undefined>;
-type GetBalance = MethodParamsAndResult<v.InferOutput<typeof getBalanceParamsSchema>, v.InferOutput<typeof getBalanceResultSchema>>;
+type GetBalanceRequestMessage = v.InferOutput<typeof getBalanceRequestMessageSchema>;
+type GetBalance = MethodParamsAndResult<GetBalanceParams, GetBalanceResult>;
 
 declare const getInscriptionsMethodName = "ord_getInscriptions";
 declare const getInscriptionsParamsSchema: v.ObjectSchema<{
     readonly offset: v.NumberSchema<undefined>;
     readonly limit: v.NumberSchema<undefined>;
 }, undefined>;
+type GetInscriptionsParams = v.InferOutput<typeof getInscriptionsParamsSchema>;
 declare const getInscriptionsResultSchema: v.ObjectSchema<{
     readonly total: v.NumberSchema<undefined>;
     readonly limit: v.NumberSchema<undefined>;
@@ -605,7 +642,8 @@ declare const getInscriptionsResultSchema: v.ObjectSchema<{
         readonly output: v.StringSchema<undefined>;
     }, undefined>, undefined>;
 }, undefined>;
-declare const getInscriptionsSchema: v.ObjectSchema<{
+type GetInscriptionsResult = v.InferOutput<typeof getInscriptionsResultSchema>;
+declare const getInscriptionsRequestMessageSchema: v.ObjectSchema<{
     readonly method: v.LiteralSchema<"ord_getInscriptions", undefined>;
     readonly params: v.ObjectSchema<{
         readonly offset: v.NumberSchema<undefined>;
@@ -614,7 +652,8 @@ declare const getInscriptionsSchema: v.ObjectSchema<{
     readonly id: v.StringSchema<undefined>;
     readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
 }, undefined>;
-type GetInscriptions = MethodParamsAndResult<v.InferOutput<typeof getInscriptionsParamsSchema>, v.InferOutput<typeof getInscriptionsResultSchema>>;
+type GetInscriptionsRequestMessage = v.InferOutput<typeof getInscriptionsRequestMessageSchema>;
+type GetInscriptions = MethodParamsAndResult<GetInscriptionsParams, GetInscriptionsResult>;
 declare const sendInscriptionsMethodName = "ord_sendInscriptions";
 declare const sendInscriptionsParamsSchema: v.ObjectSchema<{
     readonly transfers: v.ArraySchema<v.ObjectSchema<{
@@ -622,10 +661,12 @@ declare const sendInscriptionsParamsSchema: v.ObjectSchema<{
         readonly inscriptionId: v.StringSchema<undefined>;
     }, undefined>, undefined>;
 }, undefined>;
+type SendInscriptionsParams = v.InferOutput<typeof sendInscriptionsParamsSchema>;
 declare const sendInscriptionsResultSchema: v.ObjectSchema<{
     readonly txid: v.StringSchema<undefined>;
 }, undefined>;
-declare const sendInscriptionsSchema: v.ObjectSchema<{
+type SendInscriptionsResult = v.InferOutput<typeof sendInscriptionsResultSchema>;
+declare const sendInscriptionsRequestMessageSchema: v.ObjectSchema<{
     readonly method: v.LiteralSchema<"ord_sendInscriptions", undefined>;
     readonly params: v.ObjectSchema<{
         readonly transfers: v.ArraySchema<v.ObjectSchema<{
@@ -636,7 +677,8 @@ declare const sendInscriptionsSchema: v.ObjectSchema<{
     readonly id: v.StringSchema<undefined>;
     readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
 }, undefined>;
-type SendInscriptions = MethodParamsAndResult<v.InferOutput<typeof sendInscriptionsParamsSchema>, v.InferOutput<typeof sendInscriptionsResultSchema>>;
+type SendInscriptionsRequestMessage = v.InferOutput<typeof sendInscriptionsRequestMessageSchema>;
+type SendInscriptions = MethodParamsAndResult<SendInscriptionsParams, SendInscriptionsResult>;
 
 type CreateMintOrderRequest = {
     runeName: string;
@@ -704,55 +746,95 @@ type RBFOrderResponse = {
     fundingAddress: string;
 };
 
-interface EstimateRunesMintParams extends EstimateMintOrderRequest {
-    network?: BitcoinNetworkType;
-}
-type EstimateRunesMintResult = EstimateOrderResponse;
-type EstimateRunesMint = MethodParamsAndResult<EstimateRunesMintParams, EstimateRunesMintResult>;
-interface MintRunesParams extends CreateMintOrderRequest {
-    network?: BitcoinNetworkType;
-}
-type MintRunesResult = {
-    orderId: string;
-    fundTransactionId: string;
-    fundingAddress: string;
-};
-type MintRunes = MethodParamsAndResult<MintRunesParams, MintRunesResult>;
-interface EstimateRunesEtchParams extends EstimateEtchOrderRequest {
-    network?: BitcoinNetworkType;
-}
-type EstimateRunesEtchResult = EstimateOrderResponse;
-type EstimateRunesEtch = MethodParamsAndResult<EstimateRunesEtchParams, EstimateRunesEtchResult>;
-interface EtchRunesParams extends CreateEtchOrderRequest {
+interface RunesEstimateEtchParams extends EstimateEtchOrderRequest {
     network?: BitcoinNetworkType;
 }
-type EtchRunesResult = {
-    orderId: string;
-    fundTransactionId: string;
-    fundingAddress: string;
-};
-type EtchRunes = MethodParamsAndResult<EtchRunesParams, EtchRunesResult>;
-interface GetOrderParams extends GetOrderRequest {
-    network?: BitcoinNetworkType;
-}
-type GetOrder = MethodParamsAndResult<GetOrderParams, GetOrderResponse>;
-interface EstimateRbfOrderParams extends RBFOrderRequest {
+type RunesEstimateEtchResult = EstimateOrderResponse;
+type RunesEstimateEtch = MethodParamsAndResult<RunesEstimateEtchParams, RunesEstimateEtchResult>;
+
+interface runesEstimateMintParams extends EstimateMintOrderRequest {
     network?: BitcoinNetworkType;
 }
-type EstimateRbfOrder = MethodParamsAndResult<EstimateRbfOrderParams, RBFOrderResponse>;
-interface RbfOrderParams extends RBFOrderRequest {
+type runesEstimateMintResult = EstimateOrderResponse;
+type RunesEstimateMint = MethodParamsAndResult<runesEstimateMintParams, runesEstimateMintResult>;
+
+interface RunesEstimateRbfOrderParams extends RBFOrderRequest {
     network?: BitcoinNetworkType;
 }
-interface RbfOrderResult {
-    orderId: string;
-    fundRBFTransactionId: string;
-    fundingAddress: string;
-}
-type RbfOrder = MethodParamsAndResult<RbfOrderParams, RbfOrderResult>;
-declare const getRunesBalanceMethodName = "runes_getBalance";
-declare const getRunesBalanceParamsSchema: v.NullishSchema<v.NullSchema<undefined>, never>;
-type GetRunesBalanceParams = v.InferOutput<typeof getRunesBalanceParamsSchema>;
-declare const getRunesBalanceResultSchema: v.ObjectSchema<{
+type RunesEstimateRbfOrder = MethodParamsAndResult<RunesEstimateRbfOrderParams, RBFOrderResponse>;
+
+declare const runesEtchMethodName = "runes_etch";
+declare const runesEtchParamsSchema: v.ObjectSchema<{
+    readonly runeName: v.StringSchema<undefined>;
+    readonly divisibility: v.OptionalSchema<v.NumberSchema<undefined>, never>;
+    readonly symbol: v.OptionalSchema<v.StringSchema<undefined>, never>;
+    readonly premine: v.OptionalSchema<v.StringSchema<undefined>, never>;
+    readonly isMintable: v.BooleanSchema<undefined>;
+    readonly delegateInscriptionId: v.OptionalSchema<v.StringSchema<undefined>, never>;
+    readonly destinationAddress: v.StringSchema<undefined>;
+    readonly refundAddress: v.StringSchema<undefined>;
+    readonly feeRate: v.NumberSchema<undefined>;
+    readonly appServiceFee: v.OptionalSchema<v.NumberSchema<undefined>, never>;
+    readonly appServiceFeeAddress: v.OptionalSchema<v.StringSchema<undefined>, never>;
+    readonly terms: v.OptionalSchema<v.ObjectSchema<{
+        readonly amount: v.StringSchema<undefined>;
+        readonly cap: v.StringSchema<undefined>;
+        readonly heightStart: v.OptionalSchema<v.StringSchema<undefined>, never>;
+        readonly heightEnd: v.OptionalSchema<v.StringSchema<undefined>, never>;
+        readonly offsetStart: v.OptionalSchema<v.StringSchema<undefined>, never>;
+        readonly offsetEnd: v.OptionalSchema<v.StringSchema<undefined>, never>;
+    }, undefined>, never>;
+    readonly inscriptionDetails: v.OptionalSchema<v.ObjectSchema<{
+        readonly contentType: v.StringSchema<undefined>;
+        readonly contentBase64: v.StringSchema<undefined>;
+    }, undefined>, never>;
+    readonly network: v.OptionalSchema<v.EnumSchema<typeof BitcoinNetworkType, undefined>, never>;
+}, undefined>;
+type RunesEtchParams = v.InferOutput<typeof runesEtchParamsSchema>;
+declare const runesEtchResultSchema: v.ObjectSchema<{
+    readonly orderId: v.StringSchema<undefined>;
+    readonly fundTransactionId: v.StringSchema<undefined>;
+    readonly fundingAddress: v.StringSchema<undefined>;
+}, undefined>;
+type RunesEtchResult = v.InferOutput<typeof runesEtchResultSchema>;
+declare const runesEtchRequestMessageSchema: v.ObjectSchema<{
+    readonly method: v.LiteralSchema<"runes_etch", undefined>;
+    readonly params: v.ObjectSchema<{
+        readonly runeName: v.StringSchema<undefined>;
+        readonly divisibility: v.OptionalSchema<v.NumberSchema<undefined>, never>;
+        readonly symbol: v.OptionalSchema<v.StringSchema<undefined>, never>;
+        readonly premine: v.OptionalSchema<v.StringSchema<undefined>, never>;
+        readonly isMintable: v.BooleanSchema<undefined>;
+        readonly delegateInscriptionId: v.OptionalSchema<v.StringSchema<undefined>, never>;
+        readonly destinationAddress: v.StringSchema<undefined>;
+        readonly refundAddress: v.StringSchema<undefined>;
+        readonly feeRate: v.NumberSchema<undefined>;
+        readonly appServiceFee: v.OptionalSchema<v.NumberSchema<undefined>, never>;
+        readonly appServiceFeeAddress: v.OptionalSchema<v.StringSchema<undefined>, never>;
+        readonly terms: v.OptionalSchema<v.ObjectSchema<{
+            readonly amount: v.StringSchema<undefined>;
+            readonly cap: v.StringSchema<undefined>;
+            readonly heightStart: v.OptionalSchema<v.StringSchema<undefined>, never>;
+            readonly heightEnd: v.OptionalSchema<v.StringSchema<undefined>, never>;
+            readonly offsetStart: v.OptionalSchema<v.StringSchema<undefined>, never>;
+            readonly offsetEnd: v.OptionalSchema<v.StringSchema<undefined>, never>;
+        }, undefined>, never>;
+        readonly inscriptionDetails: v.OptionalSchema<v.ObjectSchema<{
+            readonly contentType: v.StringSchema<undefined>;
+            readonly contentBase64: v.StringSchema<undefined>;
+        }, undefined>, never>;
+        readonly network: v.OptionalSchema<v.EnumSchema<typeof BitcoinNetworkType, undefined>, never>;
+    }, undefined>;
+    readonly id: v.StringSchema<undefined>;
+    readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type RunesEtchRequestMessage = v.InferOutput<typeof runesEtchRequestMessageSchema>;
+type RunesEtch = MethodParamsAndResult<v.InferOutput<typeof runesEtchParamsSchema>, v.InferOutput<typeof runesEtchResultSchema>>;
+
+declare const runesGetBalanceMethodName = "runes_getBalance";
+declare const runesGetBalanceParamsSchema: v.NullishSchema<v.NullSchema<undefined>, never>;
+type RunesGetBalanceParams = v.InferOutput<typeof runesGetBalanceParamsSchema>;
+declare const runesGetBalanceResultSchema: v.ObjectSchema<{
     readonly balances: v.ArraySchema<v.ObjectSchema<{
         readonly runeName: v.StringSchema<undefined>;
         readonly amount: v.StringSchema<undefined>;
@@ -761,25 +843,81 @@ declare const getRunesBalanceResultSchema: v.ObjectSchema<{
         readonly inscriptionId: v.NullishSchema<v.StringSchema<undefined>, never>;
     }, undefined>, undefined>;
 }, undefined>;
-type GetRunesBalanceResult = v.InferOutput<typeof getRunesBalanceResultSchema>;
-declare const getRunesBalanceRequestMessageSchema: v.ObjectSchema<{
+type RunesGetBalanceResult = v.InferOutput<typeof runesGetBalanceResultSchema>;
+declare const runesGetBalanceRequestMessageSchema: v.ObjectSchema<{
     readonly method: v.LiteralSchema<"runes_getBalance", undefined>;
     readonly params: v.NullishSchema<v.NullSchema<undefined>, never>;
     readonly id: v.StringSchema<undefined>;
     readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
 }, undefined>;
-type GetRunesBalanceRequestMessage = v.InferOutput<typeof getRunesBalanceRequestMessageSchema>;
-type GetRunesBalance = MethodParamsAndResult<v.InferOutput<typeof getRunesBalanceParamsSchema>, v.InferOutput<typeof getRunesBalanceResultSchema>>;
-declare const transferRunesMethodName = "runes_transfer";
-declare const transferRunesParamsSchema: v.ObjectSchema<{
+type runesGetBalanceRequestMessage = v.InferOutput<typeof runesGetBalanceRequestMessageSchema>;
+type RunesGetBalance = MethodParamsAndResult<RunesGetBalanceParams, RunesGetBalanceResult>;
+
+interface RunesGetOrderParams extends GetOrderRequest {
+    network?: BitcoinNetworkType;
+}
+type RunesGetOrder = MethodParamsAndResult<RunesGetOrderParams, GetOrderResponse>;
+
+declare const runesMintMethodName = "runes_mint";
+declare const runesMintParamsSchema: v.ObjectSchema<{
+    readonly appServiceFee: v.OptionalSchema<v.NumberSchema<undefined>, never>;
+    readonly appServiceFeeAddress: v.OptionalSchema<v.StringSchema<undefined>, never>;
+    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>, never>;
+}, undefined>;
+type RunesMintParams = v.InferOutput<typeof runesMintParamsSchema>;
+declare const runesMintResultSchema: v.ObjectSchema<{
+    readonly orderId: v.StringSchema<undefined>;
+    readonly fundTransactionId: v.StringSchema<undefined>;
+    readonly fundingAddress: v.StringSchema<undefined>;
+}, undefined>;
+type RunesMintResult = v.InferOutput<typeof runesMintResultSchema>;
+declare const runesMintRequestMessageSchema: v.ObjectSchema<{
+    readonly method: v.LiteralSchema<"runes_mint", undefined>;
+    readonly params: v.ObjectSchema<{
+        readonly appServiceFee: v.OptionalSchema<v.NumberSchema<undefined>, never>;
+        readonly appServiceFeeAddress: v.OptionalSchema<v.StringSchema<undefined>, never>;
+        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>, never>;
+    }, undefined>;
+    readonly id: v.StringSchema<undefined>;
+    readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type RunesMintRequestMessage = v.InferOutput<typeof runesMintRequestMessageSchema>;
+type RunesMint = MethodParamsAndResult<v.InferOutput<typeof runesMintParamsSchema>, v.InferOutput<typeof runesMintResultSchema>>;
+
+interface RunesRbfOrderParams extends RBFOrderRequest {
+    network?: BitcoinNetworkType;
+}
+interface RunesRbfOrderResult {
+    orderId: string;
+    fundRBFTransactionId: string;
+    fundingAddress: string;
+}
+type RunesRbfOrder = MethodParamsAndResult<RunesRbfOrderParams, RunesRbfOrderResult>;
+
+declare const runesTransferMethodName = "runes_transfer";
+declare const runesTransferParamsSchema: 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>;
 }, undefined>;
-type TransferRunesParams = v.InferOutput<typeof transferRunesParamsSchema>;
-declare const transferRunesRequestSchema: v.ObjectSchema<{
+type TransferRunesParams = v.InferOutput<typeof runesTransferParamsSchema>;
+declare const runesTransferResultSchema: v.ObjectSchema<{
+    readonly txid: v.StringSchema<undefined>;
+}, undefined>;
+type RunesTransferResult = v.InferOutput<typeof runesTransferResultSchema>;
+declare const runesTransferRequestMessageSchema: v.ObjectSchema<{
     readonly method: v.LiteralSchema<"runes_transfer", undefined>;
     readonly params: v.ObjectSchema<{
         readonly recipients: v.ArraySchema<v.ObjectSchema<{
@@ -791,134 +929,24 @@ declare const transferRunesRequestSchema: v.ObjectSchema<{
     readonly id: v.StringSchema<undefined>;
     readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
 }, undefined>;
-type TransferRunesRequest = v.InferOutput<typeof transferRunesRequestSchema>;
-declare const TransferRunesResultSchema: v.ObjectSchema<{
-    readonly txid: v.StringSchema<undefined>;
-}, undefined>;
-type TransferRunesResult = v.InferOutput<typeof TransferRunesResultSchema>;
-type TransferRunes = MethodParamsAndResult<TransferRunesParams, TransferRunesResult>;
+type RunesTransferRequestMessage = v.InferOutput<typeof runesTransferRequestMessageSchema>;
+type RunesTransfer = MethodParamsAndResult<TransferRunesParams, RunesTransferResult>;
 
-interface Pubkey {
-    /**
-     * When sending a transfer STX request to a wallet, users can generally
-     * choose from which accout they want to send the STX tokens from. In
-     * cases where applications want the transfer to be made from a specific
-     * account, they can provide the `pubkey` of the address they'd like the
-     * transfer to be made from. It is up to wallet providers to handle this
-     * field as they see fit.
-     */
-    pubkey: string;
-}
-interface Address {
-    /**
-     * A Crockford base-32 encoded Stacks address.
-     */
-    address: string;
-}
-interface PostConditions {
-    /**
-     * 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');
-     * ```
-     */
-    postConditions: Array<string>;
-}
-interface PostConditionMode {
-    /**
-     * The mode of the post conditions.
-     */
-    postConditionMode: number;
-}
-interface ParameterFormatVersion {
-    /**
-     * Version of parameter format.
-     */
-    version: string;
-}
-interface Recipient {
-    /**
-     * The recipeint's Crockford base-32 encoded Stacks address.
-     */
-    recipient: string;
-}
-interface Amount {
-    /**
-     * 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';
-     * ```
-     */
-    amount: number | string;
-}
-interface Memo {
-    /**
-     * A string representing the memo.
-     */
-    memo: string;
-}
-interface TxId {
-    /**
-     * The ID of the transaction.
-     */
-    txid: string;
-}
-interface Transaction {
-    /**
-     * A Stacks transaction as a hex-encoded string.
-     */
-    transaction: string;
-}
-interface Message {
-    /**
-     * Message payload to be signed.
-     */
-    message: string;
-}
-interface Signature {
-    /**
-     * Signature of the message.
-     */
-    signature: string;
-}
-interface PublicKey {
+declare const stxCallContractMethodName = "stx_callContract";
+declare const stxCallContractParamsSchema: v.ObjectSchema<{
     /**
-     * Public key as hex-encoded string.
-     */
-    publicKey: string;
-}
-interface Domain {
-    /**
-     * The domain to be signed.
-     */
-    domain: string;
-}
-interface CallContractParams {
-    /**
-     * The contract's Crockford base-32 encoded Stacks address and name.
+     * The contract principal.
      *
      * E.g. `"SPKE...GD5C.my-contract"`
      */
-    contract: string;
+    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
      */
-    functionName: string;
+    readonly functionName: v.StringSchema<undefined>;
     /**
      * The function's arguments. The arguments are expected to be hex-encoded
      * strings of Clarity values.
@@ -933,42 +961,131 @@ interface CallContractParams {
      * const hexArgs = functionArgs.map(cvToString);
      * ```
      */
-    arguments?: Array<string>;
-}
-type CallContractResult = TxId & Transaction;
-type StxCallContract = MethodParamsAndResult<CallContractParams, CallContractResult>;
-type TransferStxParams = Amount & Recipient & Partial<Memo> & Partial<ParameterFormatVersion> & Partial<PostConditionMode> & Partial<PostConditions> & Partial<Pubkey>;
-type TransferStxResult = TxId & Transaction;
-type StxTransferStx = MethodParamsAndResult<TransferStxParams, TransferStxResult>;
-type SignStxMessageParams = Message & Partial<Pubkey> & Partial<ParameterFormatVersion>;
-type SignStxMessageResult = Signature & PublicKey;
-type StxSignStxMessage = MethodParamsAndResult<SignStxMessageParams, SignStxMessageResult>;
-type SignStructuredMessageParams = Domain & Message & Partial<ParameterFormatVersion> & Partial<Pubkey>;
-type SignStructuredMessageResult = Signature & PublicKey;
-type StxSignStructuredMessage = MethodParamsAndResult<SignStructuredMessageParams, SignStructuredMessageResult>;
-interface DeployContractParams {
+    readonly arguments: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, never>;
+}, undefined>;
+type StxCallContractParams = v.InferOutput<typeof stxCallContractParamsSchema>;
+declare const stxCallContractResultSchema: 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>;
+type StxCallContractResult = v.InferOutput<typeof stxCallContractResultSchema>;
+declare const stxCallContractRequestMessageSchema: v.ObjectSchema<{
+    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>;
+        /**
+         * 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 `cvToString`
+         * helper from the `@stacks/transactions` package may be helpful.
+         *
+         * ```js
+         * import { cvToString } from '@stacks/transactions';
+         *
+         * const functionArgs = [someClarityValue1, someClarityValue2];
+         * const hexArgs = functionArgs.map(cvToString);
+         * ```
+         */
+        readonly arguments: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, never>;
+    }, undefined>;
+    readonly id: v.StringSchema<undefined>;
+    readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type StxCallContractRequestMessage = v.InferOutput<typeof stxCallContractRequestMessageSchema>;
+type StxCallContract = MethodParamsAndResult<StxCallContractParams, StxCallContractResult>;
+
+declare const stxDeployContractMethodName = "stx_deployContract";
+declare const stxDeployContractParamsSchema: v.ObjectSchema<{
     /**
      * Name of the contract.
      */
-    name: string;
+    readonly name: v.StringSchema<undefined>;
     /**
-     * The code of the Clarity contract.
+     * The source code of the Clarity contract.
      */
-    clarityCode: string;
+    readonly clarityCode: v.StringSchema<undefined>;
     /**
      * The version of the Clarity contract.
      */
-    clarityVersion?: string;
-}
-type DeployContractResult = TxId & Transaction;
-type StxDeployContract = MethodParamsAndResult<DeployContractParams, DeployContractResult>;
-type StxGetAccountsResult = {
-    addresses: Array<Address & PublicKey & {
-        gaiaHubUrl: string;
-        gaiaAppKey: string;
-    }>;
-};
-type StxGetAccounts = MethodParamsAndResult<{}, StxGetAccountsResult>;
+    readonly clarityVersion: v.OptionalSchema<v.StringSchema<undefined>, never>;
+}, undefined>;
+type StxDeployContractParams = v.InferOutput<typeof stxDeployContractParamsSchema>;
+declare const stxDeployContractResultSchema: 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>;
+type StxDeployContractResult = v.InferOutput<typeof stxDeployContractResultSchema>;
+declare const stxDeployContractRequestMessageSchema: v.ObjectSchema<{
+    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.StringSchema<undefined>, never>;
+    }, undefined>;
+    readonly id: v.StringSchema<undefined>;
+    readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type StxDeployContractRequestMessage = v.InferOutput<typeof stxDeployContractRequestMessageSchema>;
+type StxDeployContract = MethodParamsAndResult<StxDeployContractParams, StxDeployContractResult>;
+
+declare const stxGetAccountsMethodName = "stx_getAccounts";
+declare const stxGetAccountsParamsSchema: v.NullishSchema<v.NullSchema<undefined>, never>;
+type StxGetAccountsParams = v.InferOutput<typeof stxGetAccountsParamsSchema>;
+declare const stxGetAccountsResultSchema: 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>;
+}, undefined>;
+type StxGetAccountsResult = v.InferOutput<typeof stxGetAccountsResultSchema>;
+declare const stxGetAccountsRequestMessageSchema: v.ObjectSchema<{
+    readonly method: v.LiteralSchema<"stx_getAccounts", undefined>;
+    readonly params: v.NullishSchema<v.NullSchema<undefined>, never>;
+    readonly id: v.StringSchema<undefined>;
+    readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type StxGetAccountsRequestMessage = v.InferOutput<typeof stxGetAccountsRequestMessageSchema>;
+type StxGetAccounts = MethodParamsAndResult<StxGetAccountsParams, StxGetAccountsResult>;
+
 declare const stxGetAddressesMethodName = "stx_getAddresses";
 declare const stxGetAddressesParamsSchema: v.NullishSchema<v.ObjectSchema<{
     /**
@@ -1002,6 +1119,113 @@ declare const stxGetAddressesRequestMessageSchema: v.ObjectSchema<{
 }, undefined>;
 type StxGetAddressesRequestMessage = v.InferOutput<typeof stxGetAddressesRequestMessageSchema>;
 type StxGetAddresses = MethodParamsAndResult<v.InferOutput<typeof stxGetAddressesParamsSchema>, v.InferOutput<typeof stxGetAddressesResultSchema>>;
+
+declare const stxSignMessageMethodName = "stx_signMessage";
+declare const stxSignMessageParamsSchema: v.ObjectSchema<{
+    /**
+     * The message to sign.
+     */
+    readonly message: v.StringSchema<undefined>;
+    /**
+     * The public key to sign the message with.
+     */
+    readonly publicKey: v.StringSchema<undefined>;
+    /**
+     * The format version of the parameter.
+     */
+    readonly parameterFormatVersion: v.OptionalSchema<v.NumberSchema<undefined>, never>;
+}, undefined>;
+type StxSignMessageParams = v.InferOutput<typeof stxSignMessageParamsSchema>;
+declare const stxSignMessageResultSchema: 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>;
+type StxSignMessageResult = v.InferOutput<typeof stxSignMessageResultSchema>;
+declare const stxSignMessageRequestMessageSchema: v.ObjectSchema<{
+    readonly method: v.LiteralSchema<"stx_signMessage", undefined>;
+    readonly params: v.ObjectSchema<{
+        /**
+         * The message to sign.
+         */
+        readonly message: v.StringSchema<undefined>;
+        /**
+         * The public key to sign the message with.
+         */
+        readonly publicKey: v.StringSchema<undefined>;
+        /**
+         * The format version of the parameter.
+         */
+        readonly parameterFormatVersion: v.OptionalSchema<v.NumberSchema<undefined>, never>;
+    }, undefined>;
+    readonly id: v.StringSchema<undefined>;
+    readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type StxSignMessageRequestMessage = v.InferOutput<typeof stxSignMessageRequestMessageSchema>;
+type StxSignMessage = MethodParamsAndResult<StxSignMessageParams, StxSignMessageResult>;
+
+declare const stxSignStructuredMessageMethodName = "stx_signStructuredMessage";
+declare const stxSignStructuredMessageParamsSchema: v.ObjectSchema<{
+    /**
+     * The domain to be signed.
+     */
+    readonly domain: v.StringSchema<undefined>;
+    /**
+     * Message payload to be signed.
+     */
+    readonly message: v.StringSchema<undefined>;
+    /**
+     * The format version of the parameter.
+     */
+    readonly parameterFormatVersion: v.OptionalSchema<v.NumberSchema<undefined>, never>;
+    /**
+     * The public key to sign the message with.
+     */
+    readonly publicKey: v.OptionalSchema<v.StringSchema<undefined>, never>;
+}, undefined>;
+type StxSignStructuredMessageParams = v.InferOutput<typeof stxSignStructuredMessageParamsSchema>;
+declare const stxSignStructuredMessageResultSchema: v.ObjectSchema<{
+    /**
+     * Signature of the message.
+     */
+    readonly signature: v.StringSchema<undefined>;
+    /**
+     * Public key as hex-encoded string.
+     */
+    readonly publicKey: v.StringSchema<undefined>;
+}, undefined>;
+type StxSignStructuredMessageResult = v.InferOutput<typeof stxSignStructuredMessageResultSchema>;
+declare const stxSignStructuredMessageRequestMessageSchema: v.ObjectSchema<{
+    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 format version of the parameter.
+         */
+        readonly parameterFormatVersion: v.OptionalSchema<v.NumberSchema<undefined>, never>;
+        /**
+         * The public key to sign the message with.
+         */
+        readonly publicKey: v.OptionalSchema<v.StringSchema<undefined>, never>;
+    }, undefined>;
+    readonly id: v.StringSchema<undefined>;
+    readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type StxSignStructuredMessageRequestMessage = v.InferOutput<typeof stxSignStructuredMessageRequestMessageSchema>;
+type StxSignStructuredMessage = MethodParamsAndResult<StxSignStructuredMessageParams, StxSignStructuredMessageResult>;
+
 declare const stxSignTransactionMethodName = "stx_signTransaction";
 declare const stxSignTransactionParamsSchema: v.ObjectSchema<{
     /**
@@ -1049,399 +1273,271 @@ declare const stxSignTransactionRequestMessageSchema: v.ObjectSchema<{
 type StxSignTransactionRequestMessage = v.InferOutput<typeof stxSignTransactionRequestMessageSchema>;
 type StxSignTransaction = MethodParamsAndResult<StxSignTransactionParams, StxSignTransactionResult>;
 
+declare const stxTransferStxMethodName = "stx_transferStx";
+declare const stxTransferStxParamsSchema: 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 recipeint's principal.
+     */
+    readonly recipient: v.StringSchema<undefined>;
+    /**
+     * A string representing the memo.
+     */
+    readonly memo: v.OptionalSchema<v.StringSchema<undefined>, never>;
+    /**
+     * Version of parameter format.
+     */
+    readonly version: v.OptionalSchema<v.StringSchema<undefined>, never>;
+    /**
+     * The mode of the post conditions.
+     */
+    readonly postConditionMode: v.OptionalSchema<v.NumberSchema<undefined>, never>;
+    /**
+     * 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>, never>;
+    /**
+     * The public key to sign the transaction with. The wallet may use any key
+     * when not provided.
+     */
+    readonly pubkey: v.OptionalSchema<v.StringSchema<undefined>, never>;
+}, undefined>;
+type StxTransferStxParams = v.InferOutput<typeof stxTransferStxParamsSchema>;
+declare const stxTransferStxResultSchema: 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>;
+type StxTransferStxResult = v.InferOutput<typeof stxTransferStxResultSchema>;
+declare const stxTransferStxRequestMessageSchema: v.ObjectSchema<{
+    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 recipeint's principal.
+         */
+        readonly recipient: v.StringSchema<undefined>;
+        /**
+         * A string representing the memo.
+         */
+        readonly memo: v.OptionalSchema<v.StringSchema<undefined>, never>;
+        /**
+         * Version of parameter format.
+         */
+        readonly version: v.OptionalSchema<v.StringSchema<undefined>, never>;
+        /**
+         * The mode of the post conditions.
+         */
+        readonly postConditionMode: v.OptionalSchema<v.NumberSchema<undefined>, never>;
+        /**
+         * 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>, never>;
+        /**
+         * The public key to sign the transaction with. The wallet may use any key
+         * when not provided.
+         */
+        readonly pubkey: v.OptionalSchema<v.StringSchema<undefined>, never>;
+    }, undefined>;
+    readonly id: v.StringSchema<undefined>;
+    readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+type StxTransferStxRequestMessage = v.InferOutput<typeof stxTransferStxRequestMessageSchema>;
+type StxTransferStx = MethodParamsAndResult<StxTransferStxParams, StxTransferStxResult>;
+
 /**
- * Permissions with the clientId field omitted. Used for permission requests,
- * since the wallet performs authentication based on the client's tab origin and
- * should not rely on the client authenticating themselves.
+ * Permissions with the clientId field omitted and optional actions. Used for
+ * permission requests, since the wallet performs authentication based on the
+ * client's tab origin and should not rely on the client authenticating
+ * themselves.
  */
-declare const permissionWithoutClientId: v.VariantSchema<"type", [Omit<v.ObjectSchema<{
+declare const permissionTemplate: v.VariantSchema<"type", [v.ObjectSchema<{
     readonly type: v.LiteralSchema<"account", undefined>;
     readonly resourceId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string, undefined>, v.BrandAction<string, "AccountResourceId">]>;
-    readonly clientId: v.StringSchema<undefined>;
     readonly actions: v.ObjectSchema<{
-        readonly read: v.BooleanSchema<undefined>;
-        readonly autoSign: v.BooleanSchema<undefined>;
-        readonly rename: v.BooleanSchema<undefined>;
+        readonly read: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+        readonly autoSign: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+        readonly rename: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
     }, undefined>;
-}, undefined>, "_types" | "_run" | "entries"> & {
-    readonly entries: Omit<{
-        readonly type: v.LiteralSchema<"account", undefined>;
-        readonly resourceId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string, undefined>, v.BrandAction<string, "AccountResourceId">]>;
-        readonly clientId: v.StringSchema<undefined>;
-        readonly actions: v.ObjectSchema<{
-            readonly read: v.BooleanSchema<undefined>;
-            readonly autoSign: v.BooleanSchema<undefined>;
-            readonly rename: v.BooleanSchema<undefined>;
-        }, undefined>;
-    }, "clientId">;
-    readonly _run: (dataset: v.Dataset<unknown, never>, config: v.Config<v.BaseIssue<unknown>>) => v.Dataset<{
-        type: "account";
-        resourceId: string & v.Brand<"AccountResourceId">;
-        actions: {
-            read: boolean;
-            autoSign: boolean;
-            rename: boolean;
-        };
-    }, v.StringIssue | v.LiteralIssue | v.ObjectIssue | v.BooleanIssue | v.CheckIssue<string>>;
-    readonly _types?: {
-        readonly input: {
-            type: "account";
-            resourceId: string;
-            actions: {
-                read: boolean;
-                autoSign: boolean;
-                rename: boolean;
-            };
-        };
-        readonly output: {
-            type: "account";
-            resourceId: string & v.Brand<"AccountResourceId">;
-            actions: {
-                read: boolean;
-                autoSign: boolean;
-                rename: boolean;
-            };
-        };
-        readonly issue: v.StringIssue | v.LiteralIssue | v.ObjectIssue | v.BooleanIssue | v.CheckIssue<string>;
-    } | undefined;
-}, Omit<v.ObjectSchema<{
+}, undefined>, v.ObjectSchema<{
     readonly type: v.LiteralSchema<"wallet", undefined>;
     readonly resourceId: v.LiteralSchema<"wallet", undefined>;
-    readonly clientId: v.StringSchema<undefined>;
     readonly actions: v.ObjectSchema<{
-        readonly addPrivateKey: v.BooleanSchema<undefined>;
-        readonly openPopup: v.BooleanSchema<undefined>;
-        readonly openFullPage: v.BooleanSchema<undefined>;
-        readonly readAllAccounts: v.BooleanSchema<undefined>;
+        readonly addPrivateKey: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+        readonly openPopup: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+        readonly openFullPage: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+        readonly readAllAccounts: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
     }, undefined>;
-}, undefined>, "_types" | "_run" | "entries"> & {
-    readonly entries: Omit<{
-        readonly type: v.LiteralSchema<"wallet", undefined>;
-        readonly resourceId: v.LiteralSchema<"wallet", undefined>;
-        readonly clientId: v.StringSchema<undefined>;
-        readonly actions: v.ObjectSchema<{
-            readonly addPrivateKey: v.BooleanSchema<undefined>;
-            readonly openPopup: v.BooleanSchema<undefined>;
-            readonly openFullPage: v.BooleanSchema<undefined>;
-            readonly readAllAccounts: v.BooleanSchema<undefined>;
-        }, undefined>;
-    }, "clientId">;
-    readonly _run: (dataset: v.Dataset<unknown, never>, config: v.Config<v.BaseIssue<unknown>>) => v.Dataset<{
-        type: "wallet";
-        resourceId: "wallet";
-        actions: {
-            addPrivateKey: boolean;
-            openPopup: boolean;
-            openFullPage: boolean;
-            readAllAccounts: boolean;
-        };
-    }, v.LiteralIssue | v.ObjectIssue | v.BooleanIssue>;
-    readonly _types?: {
-        readonly input: {
-            type: "wallet";
-            resourceId: "wallet";
-            actions: {
-                addPrivateKey: boolean;
-                openPopup: boolean;
-                openFullPage: boolean;
-                readAllAccounts: boolean;
-            };
-        };
-        readonly output: {
-            type: "wallet";
-            resourceId: "wallet";
-            actions: {
-                addPrivateKey: boolean;
-                openPopup: boolean;
-                openFullPage: boolean;
-                readAllAccounts: boolean;
-            };
-        };
-        readonly issue: v.LiteralIssue | v.ObjectIssue | v.BooleanIssue;
-    } | undefined;
-}], undefined>;
-type PermissionsWithoutClientId = v.InferOutput<typeof permissionWithoutClientId>;
+}, undefined>], undefined>;
+type PermissionWithoutClientId = v.InferOutput<typeof permissionTemplate>;
 declare const requestPermissionsMethodName = "wallet_requestPermissions";
-declare const requestPermissionsParamsSchema: v.NullishSchema<v.ArraySchema<v.VariantSchema<"type", [Omit<v.ObjectSchema<{
+declare const requestPermissionsParamsSchema: v.NullishSchema<v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
     readonly type: v.LiteralSchema<"account", undefined>;
     readonly resourceId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string, undefined>, v.BrandAction<string, "AccountResourceId">]>;
-    readonly clientId: v.StringSchema<undefined>;
     readonly actions: v.ObjectSchema<{
-        readonly read: v.BooleanSchema<undefined>;
-        readonly autoSign: v.BooleanSchema<undefined>;
-        readonly rename: v.BooleanSchema<undefined>;
+        readonly read: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+        readonly autoSign: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+        readonly rename: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
     }, undefined>;
-}, undefined>, "_types" | "_run" | "entries"> & {
-    readonly entries: Omit<{
-        readonly type: v.LiteralSchema<"account", undefined>;
-        readonly resourceId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string, undefined>, v.BrandAction<string, "AccountResourceId">]>;
-        readonly clientId: v.StringSchema<undefined>;
-        readonly actions: v.ObjectSchema<{
-            readonly read: v.BooleanSchema<undefined>;
-            readonly autoSign: v.BooleanSchema<undefined>;
-            readonly rename: v.BooleanSchema<undefined>;
-        }, undefined>;
-    }, "clientId">;
-    readonly _run: (dataset: v.Dataset<unknown, never>, config: v.Config<v.BaseIssue<unknown>>) => v.Dataset<{
-        type: "account";
-        resourceId: string & v.Brand<"AccountResourceId">;
-        actions: {
-            read: boolean;
-            autoSign: boolean;
-            rename: boolean;
-        };
-    }, v.StringIssue | v.LiteralIssue | v.ObjectIssue | v.BooleanIssue | v.CheckIssue<string>>;
-    readonly _types?: {
-        readonly input: {
-            type: "account";
-            resourceId: string;
-            actions: {
-                read: boolean;
-                autoSign: boolean;
-                rename: boolean;
-            };
-        };
-        readonly output: {
-            type: "account";
-            resourceId: string & v.Brand<"AccountResourceId">;
-            actions: {
-                read: boolean;
-                autoSign: boolean;
-                rename: boolean;
-            };
-        };
-        readonly issue: v.StringIssue | v.LiteralIssue | v.ObjectIssue | v.BooleanIssue | v.CheckIssue<string>;
-    } | undefined;
-}, Omit<v.ObjectSchema<{
+}, undefined>, v.ObjectSchema<{
     readonly type: v.LiteralSchema<"wallet", undefined>;
     readonly resourceId: v.LiteralSchema<"wallet", undefined>;
-    readonly clientId: v.StringSchema<undefined>;
     readonly actions: v.ObjectSchema<{
-        readonly addPrivateKey: v.BooleanSchema<undefined>;
-        readonly openPopup: v.BooleanSchema<undefined>;
-        readonly openFullPage: v.BooleanSchema<undefined>;
-        readonly readAllAccounts: v.BooleanSchema<undefined>;
+        readonly addPrivateKey: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+        readonly openPopup: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+        readonly openFullPage: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+        readonly readAllAccounts: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
     }, undefined>;
-}, undefined>, "_types" | "_run" | "entries"> & {
-    readonly entries: Omit<{
-        readonly type: v.LiteralSchema<"wallet", undefined>;
-        readonly resourceId: v.LiteralSchema<"wallet", undefined>;
-        readonly clientId: v.StringSchema<undefined>;
-        readonly actions: v.ObjectSchema<{
-            readonly addPrivateKey: v.BooleanSchema<undefined>;
-            readonly openPopup: v.BooleanSchema<undefined>;
-            readonly openFullPage: v.BooleanSchema<undefined>;
-            readonly readAllAccounts: v.BooleanSchema<undefined>;
-        }, undefined>;
-    }, "clientId">;
-    readonly _run: (dataset: v.Dataset<unknown, never>, config: v.Config<v.BaseIssue<unknown>>) => v.Dataset<{
-        type: "wallet";
-        resourceId: "wallet";
-        actions: {
-            addPrivateKey: boolean;
-            openPopup: boolean;
-            openFullPage: boolean;
-            readAllAccounts: boolean;
-        };
-    }, v.LiteralIssue | v.ObjectIssue | v.BooleanIssue>;
-    readonly _types?: {
-        readonly input: {
-            type: "wallet";
-            resourceId: "wallet";
-            actions: {
-                addPrivateKey: boolean;
-                openPopup: boolean;
-                openFullPage: boolean;
-                readAllAccounts: boolean;
-            };
-        };
-        readonly output: {
-            type: "wallet";
-            resourceId: "wallet";
-            actions: {
-                addPrivateKey: boolean;
-                openPopup: boolean;
-                openFullPage: boolean;
-                readAllAccounts: boolean;
-            };
-        };
-        readonly issue: v.LiteralIssue | v.ObjectIssue | v.BooleanIssue;
-    } | undefined;
-}], undefined>, undefined>, never>;
+}, undefined>], undefined>, undefined>, never>;
+type RequestPermissionsParams = v.InferOutput<typeof requestPermissionsParamsSchema>;
 declare const requestPermissionsResultSchema: v.LiteralSchema<true, undefined>;
+type RequestPermissionsResult = v.InferOutput<typeof requestPermissionsResultSchema>;
 declare const requestPermissionsRequestMessageSchema: v.ObjectSchema<{
     readonly method: v.LiteralSchema<"wallet_requestPermissions", undefined>;
-    readonly params: v.NullishSchema<v.ArraySchema<v.VariantSchema<"type", [Omit<v.ObjectSchema<{
+    readonly params: v.NullishSchema<v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
         readonly type: v.LiteralSchema<"account", undefined>;
         readonly resourceId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string, undefined>, v.BrandAction<string, "AccountResourceId">]>;
-        readonly clientId: v.StringSchema<undefined>;
         readonly actions: v.ObjectSchema<{
-            readonly read: v.BooleanSchema<undefined>;
-            readonly autoSign: v.BooleanSchema<undefined>;
-            readonly rename: v.BooleanSchema<undefined>;
+            readonly read: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+            readonly autoSign: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+            readonly rename: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
         }, undefined>;
-    }, undefined>, "_types" | "_run" | "entries"> & {
-        readonly entries: Omit<{
-            readonly type: v.LiteralSchema<"account", undefined>;
-            readonly resourceId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string, undefined>, v.BrandAction<string, "AccountResourceId">]>;
-            readonly clientId: v.StringSchema<undefined>;
-            readonly actions: v.ObjectSchema<{
-                readonly read: v.BooleanSchema<undefined>;
-                readonly autoSign: v.BooleanSchema<undefined>;
-                readonly rename: v.BooleanSchema<undefined>;
-            }, undefined>;
-        }, "clientId">;
-        readonly _run: (dataset: v.Dataset<unknown, never>, config: v.Config<v.BaseIssue<unknown>>) => v.Dataset<{
-            type: "account";
-            resourceId: string & v.Brand<"AccountResourceId">;
-            actions: {
-                read: boolean;
-                autoSign: boolean;
-                rename: boolean;
-            };
-        }, v.StringIssue | v.LiteralIssue | v.ObjectIssue | v.BooleanIssue | v.CheckIssue<string>>;
-        readonly _types?: {
-            readonly input: {
-                type: "account";
-                resourceId: string;
-                actions: {
-                    read: boolean;
-                    autoSign: boolean;
-                    rename: boolean;
-                };
-            };
-            readonly output: {
-                type: "account";
-                resourceId: string & v.Brand<"AccountResourceId">;
-                actions: {
-                    read: boolean;
-                    autoSign: boolean;
-                    rename: boolean;
-                };
-            };
-            readonly issue: v.StringIssue | v.LiteralIssue | v.ObjectIssue | v.BooleanIssue | v.CheckIssue<string>;
-        } | undefined;
-    }, Omit<v.ObjectSchema<{
+    }, undefined>, v.ObjectSchema<{
         readonly type: v.LiteralSchema<"wallet", undefined>;
         readonly resourceId: v.LiteralSchema<"wallet", undefined>;
-        readonly clientId: v.StringSchema<undefined>;
         readonly actions: v.ObjectSchema<{
-            readonly addPrivateKey: v.BooleanSchema<undefined>;
-            readonly openPopup: v.BooleanSchema<undefined>;
-            readonly openFullPage: v.BooleanSchema<undefined>;
-            readonly readAllAccounts: v.BooleanSchema<undefined>;
+            readonly addPrivateKey: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+            readonly openPopup: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+            readonly openFullPage: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+            readonly readAllAccounts: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
         }, undefined>;
-    }, undefined>, "_types" | "_run" | "entries"> & {
-        readonly entries: Omit<{
-            readonly type: v.LiteralSchema<"wallet", undefined>;
-            readonly resourceId: v.LiteralSchema<"wallet", undefined>;
-            readonly clientId: v.StringSchema<undefined>;
-            readonly actions: v.ObjectSchema<{
-                readonly addPrivateKey: v.BooleanSchema<undefined>;
-                readonly openPopup: v.BooleanSchema<undefined>;
-                readonly openFullPage: v.BooleanSchema<undefined>;
-                readonly readAllAccounts: v.BooleanSchema<undefined>;
-            }, undefined>;
-        }, "clientId">;
-        readonly _run: (dataset: v.Dataset<unknown, never>, config: v.Config<v.BaseIssue<unknown>>) => v.Dataset<{
-            type: "wallet";
-            resourceId: "wallet";
-            actions: {
-                addPrivateKey: boolean;
-                openPopup: boolean;
-                openFullPage: boolean;
-                readAllAccounts: boolean;
-            };
-        }, v.LiteralIssue | v.ObjectIssue | v.BooleanIssue>;
-        readonly _types?: {
-            readonly input: {
-                type: "wallet";
-                resourceId: "wallet";
-                actions: {
-                    addPrivateKey: boolean;
-                    openPopup: boolean;
-                    openFullPage: boolean;
-                    readAllAccounts: boolean;
-                };
-            };
-            readonly output: {
-                type: "wallet";
-                resourceId: "wallet";
-                actions: {
-                    addPrivateKey: boolean;
-                    openPopup: boolean;
-                    openFullPage: boolean;
-                    readAllAccounts: boolean;
-                };
-            };
-            readonly issue: v.LiteralIssue | v.ObjectIssue | v.BooleanIssue;
-        } | undefined;
-    }], undefined>, undefined>, never>;
+    }, undefined>], undefined>, undefined>, never>;
     readonly id: v.StringSchema<undefined>;
     readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
 }, undefined>;
-type RequestPermissions = MethodParamsAndResult<v.InferOutput<typeof requestPermissionsParamsSchema>, v.InferOutput<typeof requestPermissionsResultSchema>>;
+type RequestPermissionsRequestMessage = v.InferOutput<typeof requestPermissionsRequestMessageSchema>;
+type RequestPermissions = MethodParamsAndResult<RequestPermissionsParams, RequestPermissionsResult>;
 declare const renouncePermissionsMethodName = "wallet_renouncePermissions";
 declare const renouncePermissionsParamsSchema: v.NullishSchema<v.NullSchema<undefined>, never>;
+type RenouncePermissionsParams = v.InferOutput<typeof renouncePermissionsParamsSchema>;
 declare const renouncePermissionsResultSchema: v.NullishSchema<v.NullSchema<undefined>, never>;
+type RenouncePermissionsResult = v.InferOutput<typeof renouncePermissionsResultSchema>;
 declare const renouncePermissionsRequestMessageSchema: v.ObjectSchema<{
     readonly method: v.LiteralSchema<"wallet_renouncePermissions", undefined>;
     readonly params: v.NullishSchema<v.NullSchema<undefined>, never>;
     readonly id: v.StringSchema<undefined>;
     readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
 }, undefined>;
-type RenouncePermissions = MethodParamsAndResult<v.InferOutput<typeof renouncePermissionsParamsSchema>, v.InferOutput<typeof renouncePermissionsResultSchema>>;
+type RenouncePermissionsRequestMessage = v.InferOutput<typeof renouncePermissionsRequestMessageSchema>;
+type RenouncePermissions = MethodParamsAndResult<RenouncePermissionsParams, RenouncePermissionsResult>;
 declare const disconnectMethodName = "wallet_disconnect";
 declare const disconnectParamsSchema: v.NullishSchema<v.NullSchema<undefined>, never>;
+type DisconnectParams = v.InferOutput<typeof disconnectParamsSchema>;
 declare const disconnectResultSchema: v.NullishSchema<v.NullSchema<undefined>, never>;
+type DisconnectResult = v.InferOutput<typeof disconnectResultSchema>;
 declare const disconnectRequestMessageSchema: v.ObjectSchema<{
     readonly method: v.LiteralSchema<"wallet_disconnect", undefined>;
     readonly params: v.NullishSchema<v.NullSchema<undefined>, never>;
     readonly id: v.StringSchema<undefined>;
     readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
 }, undefined>;
-type Disconnect = MethodParamsAndResult<v.InferOutput<typeof disconnectParamsSchema>, v.InferOutput<typeof disconnectResultSchema>>;
+type DisconnectRequestMessage = v.InferOutput<typeof disconnectRequestMessageSchema>;
+type Disconnect = MethodParamsAndResult<DisconnectParams, DisconnectResult>;
 declare const getWalletTypeMethodName = "wallet_getWalletType";
 declare const getWalletTypeParamsSchema: v.NullishSchema<v.NullSchema<undefined>, never>;
+type GetWalletTypeParams = v.InferOutput<typeof getWalletTypeParamsSchema>;
 declare const getWalletTypeResultSchema: v.PicklistSchema<readonly ["software", "ledger"], undefined>;
+type GetWalletTypeResult = v.InferOutput<typeof getWalletTypeResultSchema>;
 declare const getWalletTypeRequestMessageSchema: v.ObjectSchema<{
     readonly method: v.LiteralSchema<"wallet_getWalletType", undefined>;
     readonly params: v.NullishSchema<v.NullSchema<undefined>, never>;
     readonly id: v.StringSchema<undefined>;
     readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
 }, undefined>;
-type GetWalletType = MethodParamsAndResult<v.InferOutput<typeof getWalletTypeParamsSchema>, v.InferOutput<typeof getWalletTypeResultSchema>>;
+type GetWalletTypeRequestMessage = v.InferOutput<typeof getWalletTypeRequestMessageSchema>;
+type GetWalletType = MethodParamsAndResult<GetWalletTypeParams, GetWalletTypeResult>;
 declare const getCurrentPermissionsMethodName = "wallet_getCurrentPermissions";
 declare const getCurrentPermissionsParamsSchema: v.NullishSchema<v.NullSchema<undefined>, never>;
+type GetCurrentPermissionsParams = v.InferOutput<typeof getCurrentPermissionsParamsSchema>;
 declare const getCurrentPermissionsResultSchema: v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
     readonly type: v.LiteralSchema<"account", undefined>;
     readonly resourceId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string, undefined>, v.BrandAction<string, "AccountResourceId">]>;
     readonly clientId: v.StringSchema<undefined>;
     readonly actions: v.ObjectSchema<{
-        readonly read: v.BooleanSchema<undefined>;
-        readonly autoSign: v.BooleanSchema<undefined>;
-        readonly rename: v.BooleanSchema<undefined>;
+        readonly read: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+        readonly autoSign: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+        readonly rename: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
     }, undefined>;
 }, undefined>, v.ObjectSchema<{
     readonly type: v.LiteralSchema<"wallet", undefined>;
     readonly resourceId: v.LiteralSchema<"wallet", undefined>;
     readonly clientId: v.StringSchema<undefined>;
     readonly actions: v.ObjectSchema<{
-        readonly addPrivateKey: v.BooleanSchema<undefined>;
-        readonly openPopup: v.BooleanSchema<undefined>;
-        readonly openFullPage: v.BooleanSchema<undefined>;
-        readonly readAllAccounts: v.BooleanSchema<undefined>;
+        readonly addPrivateKey: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+        readonly openPopup: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+        readonly openFullPage: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+        readonly readAllAccounts: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
     }, undefined>;
 }, undefined>], undefined>, undefined>;
+type GetCurrentPermissionsResult = v.InferOutput<typeof getCurrentPermissionsResultSchema>;
 declare const getCurrentPermissionsRequestMessageSchema: v.ObjectSchema<{
     readonly method: v.LiteralSchema<"wallet_getCurrentPermissions", undefined>;
     readonly params: v.NullishSchema<v.NullSchema<undefined>, never>;
     readonly id: v.StringSchema<undefined>;
     readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
 }, undefined>;
-type GetCurrentPermissions = MethodParamsAndResult<v.InferOutput<typeof getCurrentPermissionsParamsSchema>, v.InferOutput<typeof getCurrentPermissionsResultSchema>>;
+type GetCurrentPermissionsRequestMessage = v.InferOutput<typeof getCurrentPermissionsRequestMessageSchema>;
+type GetCurrentPermissions = MethodParamsAndResult<GetCurrentPermissionsParams, GetCurrentPermissionsResult>;
 declare const getAccountMethodName = "wallet_getAccount";
 declare const getAccountParamsSchema: v.NullishSchema<v.NullSchema<undefined>, never>;
+type GetAccountParams = v.InferOutput<typeof getAccountParamsSchema>;
 declare const getAccountResultSchema: v.ObjectSchema<{
     readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.BrandAction<string, "AccountId">]>;
     readonly addresses: v.ArraySchema<v.ObjectSchema<{
@@ -1452,144 +1548,37 @@ declare const getAccountResultSchema: v.ObjectSchema<{
     }, undefined>, undefined>;
     readonly walletType: v.PicklistSchema<readonly ["software", "ledger"], undefined>;
 }, undefined>;
+type GetAccountResult = v.InferOutput<typeof getAccountResultSchema>;
 declare const getAccountRequestMessageSchema: v.ObjectSchema<{
     readonly method: v.LiteralSchema<"wallet_getAccount", undefined>;
     readonly params: v.NullishSchema<v.NullSchema<undefined>, never>;
     readonly id: v.StringSchema<undefined>;
     readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
 }, undefined>;
-type GetAccount = MethodParamsAndResult<v.InferOutput<typeof getAccountParamsSchema>, v.InferOutput<typeof getAccountResultSchema>>;
-declare const registerClientMethodName = "wallet_registerClient";
-declare const registerClientParamsSchema: v.ObjectSchema<{
-    readonly name: v.OptionalSchema<v.StringSchema<undefined>, never>;
-    readonly description: v.OptionalSchema<v.StringSchema<undefined>, never>;
-}, undefined>;
-declare const registerClientResultSchema: v.ObjectSchema<{
-    readonly id: v.StringSchema<undefined>;
-}, undefined>;
-declare const registerClientRequestMessageSchema: v.ObjectSchema<{
-    readonly method: v.LiteralSchema<"wallet_registerClient", undefined>;
-    readonly params: v.ObjectSchema<{
-        readonly name: v.OptionalSchema<v.StringSchema<undefined>, never>;
-        readonly description: v.OptionalSchema<v.StringSchema<undefined>, never>;
-    }, undefined>;
-    readonly id: v.StringSchema<undefined>;
-    readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
-}, undefined>;
-type RegisterClient = MethodParamsAndResult<v.InferOutput<typeof registerClientParamsSchema>, v.InferOutput<typeof registerClientResultSchema>>;
+type GetAccountRequestMessage = v.InferOutput<typeof getAccountRequestMessageSchema>;
+type GetAccount = MethodParamsAndResult<GetAccountParams, GetAccountResult>;
 declare const connectMethodName = "wallet_connect";
 declare const connectParamsSchema: v.NullishSchema<v.ObjectSchema<{
-    readonly permissions: v.OptionalSchema<v.ArraySchema<v.VariantSchema<"type", [Omit<v.ObjectSchema<{
+    readonly permissions: v.OptionalSchema<v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
         readonly type: v.LiteralSchema<"account", undefined>;
         readonly resourceId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string, undefined>, v.BrandAction<string, "AccountResourceId">]>;
-        readonly clientId: v.StringSchema<undefined>;
         readonly actions: v.ObjectSchema<{
-            readonly read: v.BooleanSchema<undefined>;
-            readonly autoSign: v.BooleanSchema<undefined>;
-            readonly rename: v.BooleanSchema<undefined>;
+            readonly read: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+            readonly autoSign: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+            readonly rename: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
         }, undefined>;
-    }, undefined>, "_types" | "_run" | "entries"> & {
-        readonly entries: Omit<{
-            readonly type: v.LiteralSchema<"account", undefined>;
-            readonly resourceId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string, undefined>, v.BrandAction<string, "AccountResourceId">]>;
-            readonly clientId: v.StringSchema<undefined>;
-            readonly actions: v.ObjectSchema<{
-                readonly read: v.BooleanSchema<undefined>;
-                readonly autoSign: v.BooleanSchema<undefined>;
-                readonly rename: v.BooleanSchema<undefined>;
-            }, undefined>;
-        }, "clientId">;
-        readonly _run: (dataset: v.Dataset<unknown, never>, config: v.Config<v.BaseIssue<unknown>>) => v.Dataset<{
-            type: "account";
-            resourceId: string & v.Brand<"AccountResourceId">;
-            actions: {
-                read: boolean;
-                autoSign: boolean;
-                rename: boolean;
-            };
-        }, v.StringIssue | v.LiteralIssue | v.ObjectIssue | v.BooleanIssue | v.CheckIssue<string>>;
-        readonly _types?: {
-            readonly input: {
-                type: "account";
-                resourceId: string;
-                actions: {
-                    read: boolean;
-                    autoSign: boolean;
-                    rename: boolean;
-                };
-            };
-            readonly output: {
-                type: "account";
-                resourceId: string & v.Brand<"AccountResourceId">;
-                actions: {
-                    read: boolean;
-                    autoSign: boolean;
-                    rename: boolean;
-                };
-            };
-            readonly issue: v.StringIssue | v.LiteralIssue | v.ObjectIssue | v.BooleanIssue | v.CheckIssue<string>;
-        } | undefined;
-    }, Omit<v.ObjectSchema<{
+    }, undefined>, v.ObjectSchema<{
         readonly type: v.LiteralSchema<"wallet", undefined>;
         readonly resourceId: v.LiteralSchema<"wallet", undefined>;
-        readonly clientId: v.StringSchema<undefined>;
         readonly actions: v.ObjectSchema<{
-            readonly addPrivateKey: v.BooleanSchema<undefined>;
-            readonly openPopup: v.BooleanSchema<undefined>;
-            readonly openFullPage: v.BooleanSchema<undefined>;
-            readonly readAllAccounts: v.BooleanSchema<undefined>;
+            readonly addPrivateKey: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+            readonly openPopup: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+            readonly openFullPage: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+            readonly readAllAccounts: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
         }, undefined>;
-    }, undefined>, "_types" | "_run" | "entries"> & {
-        readonly entries: Omit<{
-            readonly type: v.LiteralSchema<"wallet", undefined>;
-            readonly resourceId: v.LiteralSchema<"wallet", undefined>;
-            readonly clientId: v.StringSchema<undefined>;
-            readonly actions: v.ObjectSchema<{
-                readonly addPrivateKey: v.BooleanSchema<undefined>;
-                readonly openPopup: v.BooleanSchema<undefined>;
-                readonly openFullPage: v.BooleanSchema<undefined>;
-                readonly readAllAccounts: v.BooleanSchema<undefined>;
-            }, undefined>;
-        }, "clientId">;
-        readonly _run: (dataset: v.Dataset<unknown, never>, config: v.Config<v.BaseIssue<unknown>>) => v.Dataset<{
-            type: "wallet";
-            resourceId: "wallet";
-            actions: {
-                addPrivateKey: boolean;
-                openPopup: boolean;
-                openFullPage: boolean;
-                readAllAccounts: boolean;
-            };
-        }, v.LiteralIssue | v.ObjectIssue | v.BooleanIssue>;
-        readonly _types?: {
-            readonly input: {
-                type: "wallet";
-                resourceId: "wallet";
-                actions: {
-                    addPrivateKey: boolean;
-                    openPopup: boolean;
-                    openFullPage: boolean;
-                    readAllAccounts: boolean;
-                };
-            };
-            readonly output: {
-                type: "wallet";
-                resourceId: "wallet";
-                actions: {
-                    addPrivateKey: boolean;
-                    openPopup: boolean;
-                    openFullPage: boolean;
-                    readAllAccounts: boolean;
-                };
-            };
-            readonly issue: v.LiteralIssue | v.ObjectIssue | v.BooleanIssue;
-        } | undefined;
-    }], undefined>, undefined>, never>;
-    readonly clientInfo: v.ObjectSchema<{
-        readonly name: v.OptionalSchema<v.StringSchema<undefined>, never>;
-        readonly description: v.OptionalSchema<v.StringSchema<undefined>, never>;
-    }, undefined>;
+    }, undefined>], undefined>, undefined>, never>;
 }, undefined>, never>;
+type ConnectParams = v.InferOutput<typeof connectParamsSchema>;
 declare const connectResultSchema: v.ObjectSchema<{
     readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.BrandAction<string, "AccountId">]>;
     readonly addresses: v.ArraySchema<v.ObjectSchema<{
@@ -1600,124 +1589,34 @@ declare const connectResultSchema: v.ObjectSchema<{
     }, undefined>, undefined>;
     readonly walletType: v.PicklistSchema<readonly ["software", "ledger"], undefined>;
 }, undefined>;
+type ConnectResult = v.InferOutput<typeof connectResultSchema>;
 declare const connectRequestMessageSchema: v.ObjectSchema<{
     readonly method: v.LiteralSchema<"wallet_connect", undefined>;
     readonly params: v.NullishSchema<v.ObjectSchema<{
-        readonly permissions: v.OptionalSchema<v.ArraySchema<v.VariantSchema<"type", [Omit<v.ObjectSchema<{
+        readonly permissions: v.OptionalSchema<v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
             readonly type: v.LiteralSchema<"account", undefined>;
             readonly resourceId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string, undefined>, v.BrandAction<string, "AccountResourceId">]>;
-            readonly clientId: v.StringSchema<undefined>;
             readonly actions: v.ObjectSchema<{
-                readonly read: v.BooleanSchema<undefined>;
-                readonly autoSign: v.BooleanSchema<undefined>;
-                readonly rename: v.BooleanSchema<undefined>;
+                readonly read: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+                readonly autoSign: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+                readonly rename: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
             }, undefined>;
-        }, undefined>, "_types" | "_run" | "entries"> & {
-            readonly entries: Omit<{
-                readonly type: v.LiteralSchema<"account", undefined>;
-                readonly resourceId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string, undefined>, v.BrandAction<string, "AccountResourceId">]>;
-                readonly clientId: v.StringSchema<undefined>;
-                readonly actions: v.ObjectSchema<{
-                    readonly read: v.BooleanSchema<undefined>;
-                    readonly autoSign: v.BooleanSchema<undefined>;
-                    readonly rename: v.BooleanSchema<undefined>;
-                }, undefined>;
-            }, "clientId">;
-            readonly _run: (dataset: v.Dataset<unknown, never>, config: v.Config<v.BaseIssue<unknown>>) => v.Dataset<{
-                type: "account";
-                resourceId: string & v.Brand<"AccountResourceId">;
-                actions: {
-                    read: boolean;
-                    autoSign: boolean;
-                    rename: boolean;
-                };
-            }, v.StringIssue | v.LiteralIssue | v.ObjectIssue | v.BooleanIssue | v.CheckIssue<string>>;
-            readonly _types?: {
-                readonly input: {
-                    type: "account";
-                    resourceId: string;
-                    actions: {
-                        read: boolean;
-                        autoSign: boolean;
-                        rename: boolean;
-                    };
-                };
-                readonly output: {
-                    type: "account";
-                    resourceId: string & v.Brand<"AccountResourceId">;
-                    actions: {
-                        read: boolean;
-                        autoSign: boolean;
-                        rename: boolean;
-                    };
-                };
-                readonly issue: v.StringIssue | v.LiteralIssue | v.ObjectIssue | v.BooleanIssue | v.CheckIssue<string>;
-            } | undefined;
-        }, Omit<v.ObjectSchema<{
+        }, undefined>, v.ObjectSchema<{
             readonly type: v.LiteralSchema<"wallet", undefined>;
             readonly resourceId: v.LiteralSchema<"wallet", undefined>;
-            readonly clientId: v.StringSchema<undefined>;
             readonly actions: v.ObjectSchema<{
-                readonly addPrivateKey: v.BooleanSchema<undefined>;
-                readonly openPopup: v.BooleanSchema<undefined>;
-                readonly openFullPage: v.BooleanSchema<undefined>;
-                readonly readAllAccounts: v.BooleanSchema<undefined>;
+                readonly addPrivateKey: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+                readonly openPopup: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+                readonly openFullPage: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+                readonly readAllAccounts: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
             }, undefined>;
-        }, undefined>, "_types" | "_run" | "entries"> & {
-            readonly entries: Omit<{
-                readonly type: v.LiteralSchema<"wallet", undefined>;
-                readonly resourceId: v.LiteralSchema<"wallet", undefined>;
-                readonly clientId: v.StringSchema<undefined>;
-                readonly actions: v.ObjectSchema<{
-                    readonly addPrivateKey: v.BooleanSchema<undefined>;
-                    readonly openPopup: v.BooleanSchema<undefined>;
-                    readonly openFullPage: v.BooleanSchema<undefined>;
-                    readonly readAllAccounts: v.BooleanSchema<undefined>;
-                }, undefined>;
-            }, "clientId">;
-            readonly _run: (dataset: v.Dataset<unknown, never>, config: v.Config<v.BaseIssue<unknown>>) => v.Dataset<{
-                type: "wallet";
-                resourceId: "wallet";
-                actions: {
-                    addPrivateKey: boolean;
-                    openPopup: boolean;
-                    openFullPage: boolean;
-                    readAllAccounts: boolean;
-                };
-            }, v.LiteralIssue | v.ObjectIssue | v.BooleanIssue>;
-            readonly _types?: {
-                readonly input: {
-                    type: "wallet";
-                    resourceId: "wallet";
-                    actions: {
-                        addPrivateKey: boolean;
-                        openPopup: boolean;
-                        openFullPage: boolean;
-                        readAllAccounts: boolean;
-                    };
-                };
-                readonly output: {
-                    type: "wallet";
-                    resourceId: "wallet";
-                    actions: {
-                        addPrivateKey: boolean;
-                        openPopup: boolean;
-                        openFullPage: boolean;
-                        readAllAccounts: boolean;
-                    };
-                };
-                readonly issue: v.LiteralIssue | v.ObjectIssue | v.BooleanIssue;
-            } | undefined;
-        }], undefined>, undefined>, never>;
-        readonly clientInfo: v.ObjectSchema<{
-            readonly name: v.OptionalSchema<v.StringSchema<undefined>, never>;
-            readonly description: v.OptionalSchema<v.StringSchema<undefined>, never>;
-        }, undefined>;
+        }, undefined>], undefined>, undefined>, never>;
     }, undefined>, never>;
     readonly id: v.StringSchema<undefined>;
     readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
 }, undefined>;
-type Connect = MethodParamsAndResult<v.InferOutput<typeof connectParamsSchema>, v.InferOutput<typeof connectResultSchema>>;
+type ConnectRequestMessage = v.InferOutput<typeof connectRequestMessageSchema>;
+type Connect = MethodParamsAndResult<ConnectParams, ConnectResult>;
 
 declare const walletTypes: readonly ["software", "ledger"];
 declare const walletTypeSchema: v.PicklistSchema<readonly ["software", "ledger"], undefined>;
@@ -1728,7 +1627,7 @@ interface StxRequests {
     stx_deployContract: StxDeployContract;
     stx_getAccounts: StxGetAccounts;
     stx_getAddresses: StxGetAddresses;
-    stx_signMessage: StxSignStxMessage;
+    stx_signMessage: StxSignMessage;
     stx_signStructuredMessage: StxSignStructuredMessage;
     stx_signTransaction: StxSignTransaction;
     stx_transferStx: StxTransferStx;
@@ -1745,15 +1644,15 @@ interface BtcRequests {
 }
 type BtcRequestMethod = keyof BtcRequests;
 interface RunesRequests {
-    runes_estimateMint: EstimateRunesMint;
-    runes_mint: MintRunes;
-    runes_estimateEtch: EstimateRunesEtch;
-    runes_etch: EtchRunes;
-    runes_getOrder: GetOrder;
-    runes_estimateRbfOrder: EstimateRbfOrder;
-    runes_rbfOrder: RbfOrder;
-    runes_getBalance: GetRunesBalance;
-    runes_transfer: TransferRunes;
+    runes_estimateEtch: RunesEstimateEtch;
+    runes_estimateMint: RunesEstimateMint;
+    runes_estimateRbfOrder: RunesEstimateRbfOrder;
+    runes_etch: RunesEtch;
+    runes_getBalance: RunesGetBalance;
+    runes_getOrder: RunesGetOrder;
+    runes_mint: RunesMint;
+    runes_rbfOrder: RunesRbfOrder;
+    runes_transfer: RunesTransfer;
 }
 type RunesRequestMethod = keyof RunesRequests;
 interface OrdinalsRequests {
@@ -1798,4 +1697,4 @@ declare class BaseAdapter extends SatsConnectAdapter {
 declare const DefaultAdaptersInfo: Record<string, Provider>;
 declare const defaultAdapters: Record<string, new () => SatsConnectAdapter>;
 
-export { type AccountChangeEvent, type AddListener, type Address$1 as Address, AddressPurpose, AddressType, BaseAdapter, type BitcoinNetwork, BitcoinNetworkType, type BitcoinProvider, type BtcRequestMethod, type BtcRequests, type CallContractParams, type CallContractResult, type Capability, type Connect, type CreateInscriptionOptions, type CreateInscriptionPayload, type CreateInscriptionResponse, type CreateRepeatInscriptionsOptions, type CreateRepeatInscriptionsPayload, type CreateRepeatInscriptionsResponse, DefaultAdaptersInfo, type DeployContractParams, type DeployContractResult, type Disconnect, type DisconnectEvent, type EstimateRbfOrder, type EstimateRunesEtch, type EstimateRunesEtchParams, type EstimateRunesEtchResult, type EstimateRunesMint, type EstimateRunesMintParams, type EstimateRunesMintResult, type EtchRunes, type EtchRunesParams, type EtchRunesResult, type GetAccount, type GetAccounts, type GetAccountsParams, type GetAccountsRequestMessage, type GetAccountsResult, type GetAddressOptions, type GetAddressPayload, type GetAddressResponse, type GetAddresses, type GetAddressesParams, type GetAddressesRequestMessage, type GetAddressesResult, type GetBalance, type GetCapabilitiesOptions, type GetCapabilitiesPayload, type GetCapabilitiesResponse, type GetCurrentPermissions, type GetInfo, type GetInfoParams, type GetInfoRequestMessage, type GetInfoResult, type GetInscriptions, type GetOrder, type GetRunesBalance, type GetRunesBalanceParams, type GetRunesBalanceRequestMessage, type GetRunesBalanceResult, type GetWalletType, type InputToSign, MessageSigningProtocols, type MethodParamsAndResult, type MintRunes, type MintRunesParams, type MintRunesResult, type NetworkChangeEvent, type OrdinalsRequestMethod, type OrdinalsRequests, type Params, type PermissionsWithoutClientId, type Provider, type PsbtPayload, type RbfOrder, type Recipient$2 as Recipient, type RegisterClient, type RenouncePermissions, type RequestOptions, type RequestPayload, type RequestPermissions, type Requests, type Return, type RpcBase, type RpcError, RpcErrorCode, type RpcErrorResponse, type RpcErrorResponseMessage, type RpcId, RpcIdSchema, type RpcRequest, type RpcRequestMessage, type RpcResponse, type RpcResponseMessage, type RpcResult, type RpcSuccessResponse, type RpcSuccessResponseMessage, type RunesRequestMethod, type RunesRequests, SatsConnectAdapter, type SendBtcTransactionOptions, type SendBtcTransactionPayload, type SendBtcTransactionResponse, type SendInscriptions, type SendTransfer, type SendTransferParams, type SerializedRecipient, type SerializedSendBtcTransactionPayload, type SignMessage, type SignMessageOptions, type SignMessageParams, type SignMessagePayload, type SignMessageRequestMessage, type SignMessageResponse, type SignMessageResult, type SignMultiplePsbtPayload, type SignMultipleTransactionOptions, type SignMultipleTransactionsPayload, type SignMultipleTransactionsResponse, type SignPsbt, type SignPsbtParams, type SignPsbtResult, type SignStructuredMessageResult, type SignStxMessageParams, type SignStxMessageResult, type SignTransactionOptions, type SignTransactionPayload, type SignTransactionResponse, type StxCallContract, type StxDeployContract, type StxGetAccounts, type StxGetAccountsResult, type StxGetAddresses, type StxGetAddressesParams, type StxGetAddressesRequestMessage, type StxGetAddressesResult, type StxRequestMethod, type StxRequests, type StxSignStructuredMessage, type StxSignStxMessage, type StxSignTransaction, type StxSignTransactionParams, type StxSignTransactionRequestMessage, type StxSignTransactionResult, type StxTransferStx, type SupportedWallet, type TransferRunes, type TransferRunesParams, type TransferRunesRequest, type TransferRunesResult, TransferRunesResultSchema, type TransferStxParams, type TransferStxResult, type WalletEvent, type WalletRequests, type WalletType, accountChangeEventName, accountChangeSchema, addListener, addressSchema, connectMethodName, connectParamsSchema, connectRequestMessageSchema, connectResultSchema, createInscription, createRepeatInscriptions, defaultAdapters, disconnectEventName, disconnectMethodName, disconnectParamsSchema, disconnectRequestMessageSchema, disconnectResultSchema, disconnectSchema, getAccountMethodName, getAccountParamsSchema, getAccountRequestMessageSchema, getAccountResultSchema, getAccountsMethodName, getAccountsParamsSchema, getAccountsRequestMessageSchema, getAccountsResultSchema, getAddress, getAddressesMethodName, getAddressesParamsSchema, getAddressesRequestMessageSchema, getAddressesResultSchema, getBalanceMethodName, getBalanceParamsSchema, getBalanceRequestMessageSchema, getBalanceResultSchema, getCapabilities, getCurrentPermissionsMethodName, getCurrentPermissionsParamsSchema, getCurrentPermissionsRequestMessageSchema, getCurrentPermissionsResultSchema, getDefaultProvider, getInfoMethodName, getInfoParamsSchema, getInfoRequestMessageSchema, getInfoResultSchema, getInscriptionsMethodName, getInscriptionsParamsSchema, getInscriptionsResultSchema, getInscriptionsSchema, getProviderById, getProviderOrThrow, getProviders, getRunesBalanceMethodName, getRunesBalanceParamsSchema, getRunesBalanceRequestMessageSchema, getRunesBalanceResultSchema, getSupportedWallets, getWalletTypeMethodName, getWalletTypeParamsSchema, getWalletTypeRequestMessageSchema, getWalletTypeResultSchema, isProviderInstalled, networkChangeEventName, networkChangeSchema, permissionWithoutClientId, registerClientMethodName, registerClientParamsSchema, registerClientRequestMessageSchema, registerClientResultSchema, removeDefaultProvider, renouncePermissionsMethodName, renouncePermissionsParamsSchema, renouncePermissionsRequestMessageSchema, renouncePermissionsResultSchema, request, requestPermissionsMethodName, requestPermissionsParamsSchema, requestPermissionsRequestMessageSchema, requestPermissionsResultSchema, rpcErrorResponseMessageSchema, rpcRequestMessageSchema, rpcResponseMessageSchema, rpcSuccessResponseMessageSchema, sendBtcTransaction, sendInscriptionsMethodName, sendInscriptionsParamsSchema, sendInscriptionsResultSchema, sendInscriptionsSchema, setDefaultProvider, signMessage, signMessageMethodName, signMessageParamsSchema, signMessageRequestMessageSchema, signMessageResultSchema, signMultipleTransactions, signTransaction, stxGetAddressesMethodName, stxGetAddressesParamsSchema, stxGetAddressesRequestMessageSchema, stxGetAddressesResultSchema, stxSignTransactionMethodName, stxSignTransactionParamsSchema, stxSignTransactionRequestMessageSchema, stxSignTransactionResultSchema, transferRunesMethodName, transferRunesParamsSchema, transferRunesRequestSchema, walletEventSchema, walletTypeSchema, walletTypes };
+export { type AccountChangeEvent, type AddListener, type Address, AddressPurpose, AddressType, BaseAdapter, type BitcoinNetwork, BitcoinNetworkType, type BitcoinProvider, type BtcRequestMethod, type BtcRequests, type Capability, type Connect, type ConnectParams, type ConnectRequestMessage, type ConnectResult, type CreateInscriptionOptions, type CreateInscriptionPayload, type CreateInscriptionResponse, type CreateRepeatInscriptionsOptions, type CreateRepeatInscriptionsPayload, type CreateRepeatInscriptionsResponse, DefaultAdaptersInfo, type Disconnect, type DisconnectEvent, type DisconnectParams, type DisconnectRequestMessage, type DisconnectResult, type GetAccount, type GetAccountParams, type GetAccountRequestMessage, type GetAccountResult, type GetAccounts, type GetAccountsParams, type GetAccountsRequestMessage, type GetAccountsResult, type GetAddressOptions, type GetAddressPayload, type GetAddressResponse, type GetAddresses, type GetAddressesParams, type GetAddressesRequestMessage, type GetAddressesResult, type GetBalance, type GetBalanceParams, type GetBalanceRequestMessage, type GetBalanceResult, type GetCapabilitiesOptions, type GetCapabilitiesPayload, type GetCapabilitiesResponse, type GetCurrentPermissions, type GetCurrentPermissionsParams, type GetCurrentPermissionsRequestMessage, type GetCurrentPermissionsResult, type GetInfo, type GetInfoParams, type GetInfoRequestMessage, type GetInfoResult, type GetInscriptions, type GetInscriptionsParams, type GetInscriptionsRequestMessage, type GetInscriptionsResult, type GetWalletType, type GetWalletTypeParams, type GetWalletTypeRequestMessage, type GetWalletTypeResult, type InputToSign, MessageSigningProtocols, type MethodParamsAndResult, type NetworkChangeEvent, type OrdinalsRequestMethod, type OrdinalsRequests, type Params, type PermissionWithoutClientId, type Provider, type PsbtPayload, type Recipient, type RenouncePermissions, type RenouncePermissionsParams, type RenouncePermissionsRequestMessage, type RenouncePermissionsResult, type RequestOptions, type RequestPayload, type RequestPermissions, type RequestPermissionsParams, type RequestPermissionsRequestMessage, type RequestPermissionsResult, type Requests, type Return, type RpcBase, type RpcError, RpcErrorCode, type RpcErrorResponse, type RpcErrorResponseMessage, type RpcId, RpcIdSchema, type RpcRequest, type RpcRequestMessage, type RpcResponse, type RpcResponseMessage, type RpcResult, type RpcSuccessResponse, type RpcSuccessResponseMessage, type RunesEstimateEtch, type RunesEstimateEtchParams, type RunesEstimateEtchResult, type RunesEstimateMint, type RunesEstimateRbfOrder, type RunesEtch, type RunesEtchParams, type RunesEtchRequestMessage, type RunesEtchResult, type RunesGetBalance, type RunesGetBalanceParams, type RunesGetBalanceResult, type RunesGetOrder, type RunesMint, type RunesMintParams, type RunesMintRequestMessage, type RunesMintResult, type RunesRbfOrder, type RunesRequestMethod, type RunesRequests, type RunesTransfer, type RunesTransferRequestMessage, type RunesTransferResult, SatsConnectAdapter, type SendBtcTransactionOptions, type SendBtcTransactionPayload, type SendBtcTransactionResponse, type SendInscriptions, type SendInscriptionsParams, type SendInscriptionsRequestMessage, type SendInscriptionsResult, type SendTransfer, type SendTransferParams, type SendTransferRequestMessage, type SendTransferResult, type SerializedRecipient, type SerializedSendBtcTransactionPayload, type SignMessage, type SignMessageOptions, type SignMessageParams, type SignMessagePayload, type SignMessageRequestMessage, type SignMessageResponse, type SignMessageResult, type SignMultiplePsbtPayload, type SignMultipleTransactionOptions, type SignMultipleTransactionsPayload, type SignMultipleTransactionsResponse, type SignPsbt, type SignPsbtParams, type SignPsbtRequestMessage, type SignPsbtResult, type SignTransactionOptions, type SignTransactionPayload, type SignTransactionResponse, type StxCallContract, type StxCallContractParams, type StxCallContractRequestMessage, type StxCallContractResult, type StxDeployContract, type StxDeployContractParams, type StxDeployContractRequestMessage, type StxDeployContractResult, type StxGetAccounts, type StxGetAccountsParams, type StxGetAccountsRequestMessage, type StxGetAccountsResult, type StxGetAddresses, type StxGetAddressesParams, type StxGetAddressesRequestMessage, type StxGetAddressesResult, type StxRequestMethod, type StxRequests, type StxSignMessage, type StxSignMessageParams, type StxSignMessageRequestMessage, type StxSignMessageResult, type StxSignStructuredMessage, type StxSignStructuredMessageParams, type StxSignStructuredMessageRequestMessage, type StxSignStructuredMessageResult, type StxSignTransaction, type StxSignTransactionParams, type StxSignTransactionRequestMessage, type StxSignTransactionResult, type StxTransferStx, type StxTransferStxParams, type StxTransferStxRequestMessage, type StxTransferStxResult, type SupportedWallet, type TransferRunesParams, type WalletEvent, type WalletRequests, type WalletType, accountChangeEventName, accountChangeSchema, addListener, addressSchema, connectMethodName, connectParamsSchema, connectRequestMessageSchema, connectResultSchema, createInscription, createRepeatInscriptions, defaultAdapters, disconnectEventName, disconnectMethodName, disconnectParamsSchema, disconnectRequestMessageSchema, disconnectResultSchema, disconnectSchema, getAccountMethodName, getAccountParamsSchema, getAccountRequestMessageSchema, getAccountResultSchema, getAccountsMethodName, getAccountsParamsSchema, getAccountsRequestMessageSchema, getAccountsResultSchema, getAddress, getAddressesMethodName, getAddressesParamsSchema, getAddressesRequestMessageSchema, getAddressesResultSchema, getBalanceMethodName, getBalanceParamsSchema, getBalanceRequestMessageSchema, getBalanceResultSchema, getCapabilities, getCurrentPermissionsMethodName, getCurrentPermissionsParamsSchema, getCurrentPermissionsRequestMessageSchema, getCurrentPermissionsResultSchema, getDefaultProvider, getInfoMethodName, getInfoParamsSchema, getInfoRequestMessageSchema, getInfoResultSchema, getInscriptionsMethodName, getInscriptionsParamsSchema, getInscriptionsRequestMessageSchema, getInscriptionsResultSchema, getProviderById, getProviderOrThrow, getProviders, getSupportedWallets, getWalletTypeMethodName, getWalletTypeParamsSchema, getWalletTypeRequestMessageSchema, getWalletTypeResultSchema, isProviderInstalled, networkChangeEventName, networkChangeSchema, permissionTemplate, removeDefaultProvider, renouncePermissionsMethodName, renouncePermissionsParamsSchema, renouncePermissionsRequestMessageSchema, renouncePermissionsResultSchema, request, requestPermissionsMethodName, requestPermissionsParamsSchema, requestPermissionsRequestMessageSchema, requestPermissionsResultSchema, rpcErrorResponseMessageSchema, rpcRequestMessageSchema, rpcResponseMessageSchema, rpcSuccessResponseMessageSchema, type runesEstimateMintParams, type runesEstimateMintResult, runesEtchMethodName, runesEtchParamsSchema, runesEtchRequestMessageSchema, runesEtchResultSchema, runesGetBalanceMethodName, runesGetBalanceParamsSchema, type runesGetBalanceRequestMessage, runesGetBalanceRequestMessageSchema, runesGetBalanceResultSchema, runesMintMethodName, runesMintParamsSchema, runesMintRequestMessageSchema, runesMintResultSchema, runesTransferMethodName, runesTransferParamsSchema, runesTransferRequestMessageSchema, runesTransferResultSchema, sendBtcTransaction, sendInscriptionsMethodName, sendInscriptionsParamsSchema, sendInscriptionsRequestMessageSchema, sendInscriptionsResultSchema, sendTransferMethodName, sendTransferParamsSchema, sendTransferRequestMessageSchema, sendTransferResultSchema, setDefaultProvider, signMessage, signMessageMethodName, signMessageParamsSchema, signMessageRequestMessageSchema, signMessageResultSchema, signMultipleTransactions, signPsbtMethodName, signPsbtParamsSchema, signPsbtRequestMessageSchema, signPsbtResultSchema, signTransaction, stxCallContractMethodName, stxCallContractParamsSchema, stxCallContractRequestMessageSchema, stxCallContractResultSchema, stxDeployContractMethodName, stxDeployContractParamsSchema, stxDeployContractRequestMessageSchema, stxDeployContractResultSchema, stxGetAccountsMethodName, stxGetAccountsParamsSchema, stxGetAccountsRequestMessageSchema, stxGetAccountsResultSchema, stxGetAddressesMethodName, stxGetAddressesParamsSchema, stxGetAddressesRequestMessageSchema, stxGetAddressesResultSchema, stxSignMessageMethodName, stxSignMessageParamsSchema, stxSignMessageRequestMessageSchema, stxSignMessageResultSchema, stxSignStructuredMessageMethodName, stxSignStructuredMessageParamsSchema, stxSignStructuredMessageRequestMessageSchema, stxSignStructuredMessageResultSchema, stxSignTransactionMethodName, stxSignTransactionParamsSchema, stxSignTransactionRequestMessageSchema, stxSignTransactionResultSchema, stxTransferStxMethodName, stxTransferStxParamsSchema, stxTransferStxRequestMessageSchema, stxTransferStxResultSchema, walletEventSchema, walletTypeSchema, walletTypes };