@sats-connect/core 0.4.0-1187a26 → 0.4.0-20feed3

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;
 }
@@ -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,13 +608,15 @@ 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<{
@@ -798,127 +834,21 @@ declare const TransferRunesResultSchema: v.ObjectSchema<{
 type TransferRunesResult = v.InferOutput<typeof TransferRunesResultSchema>;
 type TransferRunes = MethodParamsAndResult<TransferRunesParams, TransferRunesResult>;
 
-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 {
+declare const stxCallContractMethodName = "stx_callContract";
+declare const stxCallContractParamsSchema: v.ObjectSchema<{
     /**
-     * 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 {
-    /**
-     * 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 +863,130 @@ 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 stxDeployContractParamsSchema: v.ObjectSchema<{
     /**
      * Name of the contract.
      */
-    name: string;
+    readonly name: v.StringSchema<undefined>;
     /**
      * The code of the Clarity contract.
      */
-    clarityCode: string;
+    readonly codeBody: 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 version: 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 code of the Clarity contract.
+         */
+        readonly codeBody: v.StringSchema<undefined>;
+        /**
+         * The version of the Clarity contract.
+         */
+        readonly version: 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 +1020,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,50 +1174,610 @@ 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 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 permissionTemplate: v.VariantSchema<"type", [v.ObjectSchema<{
+    readonly actions: Omit<v.ObjectSchema<{
+        readonly read: v.BooleanSchema<undefined>;
+        readonly autoSign: v.BooleanSchema<undefined>;
+        readonly rename: v.BooleanSchema<undefined>;
+    }, undefined>, "_types" | "_run" | "entries"> & {
+        readonly entries: {
+            readonly read: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+            readonly autoSign: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+            readonly rename: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+        };
+        readonly _run: (dataset: v.Dataset<unknown, never>, config: v.Config<v.BaseIssue<unknown>>) => v.Dataset<{
+            read?: boolean | undefined;
+            autoSign?: boolean | undefined;
+            rename?: boolean | undefined;
+        }, v.ObjectIssue | v.BooleanIssue>;
+        readonly _types?: {
+            readonly input: {
+                read?: boolean | undefined;
+                autoSign?: boolean | undefined;
+                rename?: boolean | undefined;
+            };
+            readonly output: {
+                read?: boolean | undefined;
+                autoSign?: boolean | undefined;
+                rename?: boolean | undefined;
+            };
+            readonly issue: v.ObjectIssue | v.BooleanIssue;
+        } | undefined;
+    };
+    readonly type: v.LiteralSchema<"account", undefined>;
+    readonly resourceId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string, undefined>, v.BrandAction<string, "AccountResourceId">]>;
+}, undefined>, v.ObjectSchema<{
+    readonly actions: Omit<v.ObjectSchema<{
+        readonly addPrivateKey: v.BooleanSchema<undefined>;
+        readonly openPopup: v.BooleanSchema<undefined>;
+        readonly openFullPage: v.BooleanSchema<undefined>;
+        readonly readAllAccounts: v.BooleanSchema<undefined>;
+    }, undefined>, "_types" | "_run" | "entries"> & {
+        readonly entries: {
+            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>;
+        };
+        readonly _run: (dataset: v.Dataset<unknown, never>, config: v.Config<v.BaseIssue<unknown>>) => v.Dataset<{
+            addPrivateKey?: boolean | undefined;
+            openPopup?: boolean | undefined;
+            openFullPage?: boolean | undefined;
+            readAllAccounts?: boolean | undefined;
+        }, v.ObjectIssue | v.BooleanIssue>;
+        readonly _types?: {
+            readonly input: {
+                addPrivateKey?: boolean | undefined;
+                openPopup?: boolean | undefined;
+                openFullPage?: boolean | undefined;
+                readAllAccounts?: boolean | undefined;
+            };
+            readonly output: {
+                addPrivateKey?: boolean | undefined;
+                openPopup?: boolean | undefined;
+                openFullPage?: boolean | undefined;
+                readAllAccounts?: boolean | undefined;
+            };
+            readonly issue: v.ObjectIssue | v.BooleanIssue;
+        } | undefined;
+    };
+    readonly type: v.LiteralSchema<"wallet", undefined>;
+    readonly resourceId: v.LiteralSchema<"wallet", undefined>;
+}, undefined>], undefined>;
+type PermissionWithoutClientId = v.InferOutput<typeof permissionTemplate>;
 declare const requestPermissionsMethodName = "wallet_requestPermissions";
-declare const requestPermissionsParamsSchema: v.UndefinedSchema<undefined>;
+declare const requestPermissionsParamsSchema: v.NullishSchema<v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
+    readonly actions: Omit<v.ObjectSchema<{
+        readonly read: v.BooleanSchema<undefined>;
+        readonly autoSign: v.BooleanSchema<undefined>;
+        readonly rename: v.BooleanSchema<undefined>;
+    }, undefined>, "_types" | "_run" | "entries"> & {
+        readonly entries: {
+            readonly read: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+            readonly autoSign: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+            readonly rename: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+        };
+        readonly _run: (dataset: v.Dataset<unknown, never>, config: v.Config<v.BaseIssue<unknown>>) => v.Dataset<{
+            read?: boolean | undefined;
+            autoSign?: boolean | undefined;
+            rename?: boolean | undefined;
+        }, v.ObjectIssue | v.BooleanIssue>;
+        readonly _types?: {
+            readonly input: {
+                read?: boolean | undefined;
+                autoSign?: boolean | undefined;
+                rename?: boolean | undefined;
+            };
+            readonly output: {
+                read?: boolean | undefined;
+                autoSign?: boolean | undefined;
+                rename?: boolean | undefined;
+            };
+            readonly issue: v.ObjectIssue | v.BooleanIssue;
+        } | undefined;
+    };
+    readonly type: v.LiteralSchema<"account", undefined>;
+    readonly resourceId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string, undefined>, v.BrandAction<string, "AccountResourceId">]>;
+}, undefined>, v.ObjectSchema<{
+    readonly actions: Omit<v.ObjectSchema<{
+        readonly addPrivateKey: v.BooleanSchema<undefined>;
+        readonly openPopup: v.BooleanSchema<undefined>;
+        readonly openFullPage: v.BooleanSchema<undefined>;
+        readonly readAllAccounts: v.BooleanSchema<undefined>;
+    }, undefined>, "_types" | "_run" | "entries"> & {
+        readonly entries: {
+            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>;
+        };
+        readonly _run: (dataset: v.Dataset<unknown, never>, config: v.Config<v.BaseIssue<unknown>>) => v.Dataset<{
+            addPrivateKey?: boolean | undefined;
+            openPopup?: boolean | undefined;
+            openFullPage?: boolean | undefined;
+            readAllAccounts?: boolean | undefined;
+        }, v.ObjectIssue | v.BooleanIssue>;
+        readonly _types?: {
+            readonly input: {
+                addPrivateKey?: boolean | undefined;
+                openPopup?: boolean | undefined;
+                openFullPage?: boolean | undefined;
+                readAllAccounts?: boolean | undefined;
+            };
+            readonly output: {
+                addPrivateKey?: boolean | undefined;
+                openPopup?: boolean | undefined;
+                openFullPage?: boolean | undefined;
+                readAllAccounts?: boolean | undefined;
+            };
+            readonly issue: v.ObjectIssue | v.BooleanIssue;
+        } | undefined;
+    };
+    readonly type: v.LiteralSchema<"wallet", undefined>;
+    readonly resourceId: v.LiteralSchema<"wallet", undefined>;
+}, 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.UndefinedSchema<undefined>;
+    readonly params: v.NullishSchema<v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
+        readonly actions: Omit<v.ObjectSchema<{
+            readonly read: v.BooleanSchema<undefined>;
+            readonly autoSign: v.BooleanSchema<undefined>;
+            readonly rename: v.BooleanSchema<undefined>;
+        }, undefined>, "_types" | "_run" | "entries"> & {
+            readonly entries: {
+                readonly read: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+                readonly autoSign: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+                readonly rename: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+            };
+            readonly _run: (dataset: v.Dataset<unknown, never>, config: v.Config<v.BaseIssue<unknown>>) => v.Dataset<{
+                read?: boolean | undefined;
+                autoSign?: boolean | undefined;
+                rename?: boolean | undefined;
+            }, v.ObjectIssue | v.BooleanIssue>;
+            readonly _types?: {
+                readonly input: {
+                    read?: boolean | undefined;
+                    autoSign?: boolean | undefined;
+                    rename?: boolean | undefined;
+                };
+                readonly output: {
+                    read?: boolean | undefined;
+                    autoSign?: boolean | undefined;
+                    rename?: boolean | undefined;
+                };
+                readonly issue: v.ObjectIssue | v.BooleanIssue;
+            } | undefined;
+        };
+        readonly type: v.LiteralSchema<"account", undefined>;
+        readonly resourceId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string, undefined>, v.BrandAction<string, "AccountResourceId">]>;
+    }, undefined>, v.ObjectSchema<{
+        readonly actions: Omit<v.ObjectSchema<{
+            readonly addPrivateKey: v.BooleanSchema<undefined>;
+            readonly openPopup: v.BooleanSchema<undefined>;
+            readonly openFullPage: v.BooleanSchema<undefined>;
+            readonly readAllAccounts: v.BooleanSchema<undefined>;
+        }, undefined>, "_types" | "_run" | "entries"> & {
+            readonly entries: {
+                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>;
+            };
+            readonly _run: (dataset: v.Dataset<unknown, never>, config: v.Config<v.BaseIssue<unknown>>) => v.Dataset<{
+                addPrivateKey?: boolean | undefined;
+                openPopup?: boolean | undefined;
+                openFullPage?: boolean | undefined;
+                readAllAccounts?: boolean | undefined;
+            }, v.ObjectIssue | v.BooleanIssue>;
+            readonly _types?: {
+                readonly input: {
+                    addPrivateKey?: boolean | undefined;
+                    openPopup?: boolean | undefined;
+                    openFullPage?: boolean | undefined;
+                    readAllAccounts?: boolean | undefined;
+                };
+                readonly output: {
+                    addPrivateKey?: boolean | undefined;
+                    openPopup?: boolean | undefined;
+                    openFullPage?: boolean | undefined;
+                    readAllAccounts?: boolean | undefined;
+                };
+                readonly issue: v.ObjectIssue | v.BooleanIssue;
+            } | undefined;
+        };
+        readonly type: v.LiteralSchema<"wallet", undefined>;
+        readonly resourceId: v.LiteralSchema<"wallet", undefined>;
+    }, 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.UndefinedSchema<undefined>;
-declare const renouncePermissionsResultSchema: v.LiteralSchema<true, undefined>;
+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.UndefinedSchema<undefined>;
+    readonly params: v.NullishSchema<v.NullSchema<undefined>, never>;
+    readonly id: v.StringSchema<undefined>;
+    readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+}, undefined>;
+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 RenouncePermissions = MethodParamsAndResult<v.InferOutput<typeof renouncePermissionsParamsSchema>, v.InferOutput<typeof renouncePermissionsResultSchema>>;
+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>;
-    readonly params: v.OptionalSchema<v.UnionSchema<[v.ArraySchema<v.UnknownSchema, undefined>, v.LooseObjectSchema<{}, undefined>, v.NullSchema<undefined>], undefined>, never>;
 }, 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>;
-declare const getCurrentPermissionsResultSchema: v.ArraySchema<v.ObjectSchema<{
-    readonly clientId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.UrlAction<string, undefined>, v.BrandAction<string, "ClientId">]>;
-    readonly resourceId: v.UnionSchema<[v.SchemaWithPipe<[v.StringSchema<undefined>, v.BrandAction<string, "AccountResourceId">]>], undefined>;
-    readonly actions: v.SetSchema<v.PicklistSchema<["create", "read", "update", "delete"], undefined>, undefined>;
-}, undefined>, undefined>;
+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>;
+    }, 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>;
+    }, 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 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<{
+        readonly address: v.StringSchema<undefined>;
+        readonly publicKey: v.StringSchema<undefined>;
+        readonly purpose: v.EnumSchema<typeof AddressPurpose, undefined>;
+        readonly addressType: v.EnumSchema<typeof AddressType, undefined>;
+    }, undefined>, undefined>;
+    readonly 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 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", [v.ObjectSchema<{
+        readonly actions: Omit<v.ObjectSchema<{
+            readonly read: v.BooleanSchema<undefined>;
+            readonly autoSign: v.BooleanSchema<undefined>;
+            readonly rename: v.BooleanSchema<undefined>;
+        }, undefined>, "_types" | "_run" | "entries"> & {
+            readonly entries: {
+                readonly read: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+                readonly autoSign: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+                readonly rename: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+            };
+            readonly _run: (dataset: v.Dataset<unknown, never>, config: v.Config<v.BaseIssue<unknown>>) => v.Dataset<{
+                read?: boolean | undefined;
+                autoSign?: boolean | undefined;
+                rename?: boolean | undefined;
+            }, v.ObjectIssue | v.BooleanIssue>;
+            readonly _types?: {
+                readonly input: {
+                    read?: boolean | undefined;
+                    autoSign?: boolean | undefined;
+                    rename?: boolean | undefined;
+                };
+                readonly output: {
+                    read?: boolean | undefined;
+                    autoSign?: boolean | undefined;
+                    rename?: boolean | undefined;
+                };
+                readonly issue: v.ObjectIssue | v.BooleanIssue;
+            } | undefined;
+        };
+        readonly type: v.LiteralSchema<"account", undefined>;
+        readonly resourceId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string, undefined>, v.BrandAction<string, "AccountResourceId">]>;
+    }, undefined>, v.ObjectSchema<{
+        readonly actions: Omit<v.ObjectSchema<{
+            readonly addPrivateKey: v.BooleanSchema<undefined>;
+            readonly openPopup: v.BooleanSchema<undefined>;
+            readonly openFullPage: v.BooleanSchema<undefined>;
+            readonly readAllAccounts: v.BooleanSchema<undefined>;
+        }, undefined>, "_types" | "_run" | "entries"> & {
+            readonly entries: {
+                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>;
+            };
+            readonly _run: (dataset: v.Dataset<unknown, never>, config: v.Config<v.BaseIssue<unknown>>) => v.Dataset<{
+                addPrivateKey?: boolean | undefined;
+                openPopup?: boolean | undefined;
+                openFullPage?: boolean | undefined;
+                readAllAccounts?: boolean | undefined;
+            }, v.ObjectIssue | v.BooleanIssue>;
+            readonly _types?: {
+                readonly input: {
+                    addPrivateKey?: boolean | undefined;
+                    openPopup?: boolean | undefined;
+                    openFullPage?: boolean | undefined;
+                    readAllAccounts?: boolean | undefined;
+                };
+                readonly output: {
+                    addPrivateKey?: boolean | undefined;
+                    openPopup?: boolean | undefined;
+                    openFullPage?: boolean | undefined;
+                    readAllAccounts?: boolean | undefined;
+                };
+                readonly issue: v.ObjectIssue | v.BooleanIssue;
+            } | undefined;
+        };
+        readonly type: v.LiteralSchema<"wallet", undefined>;
+        readonly resourceId: v.LiteralSchema<"wallet", 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<{
+        readonly address: v.StringSchema<undefined>;
+        readonly publicKey: v.StringSchema<undefined>;
+        readonly purpose: v.EnumSchema<typeof AddressPurpose, undefined>;
+        readonly addressType: v.EnumSchema<typeof AddressType, undefined>;
+    }, undefined>, undefined>;
+    readonly 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", [v.ObjectSchema<{
+            readonly actions: Omit<v.ObjectSchema<{
+                readonly read: v.BooleanSchema<undefined>;
+                readonly autoSign: v.BooleanSchema<undefined>;
+                readonly rename: v.BooleanSchema<undefined>;
+            }, undefined>, "_types" | "_run" | "entries"> & {
+                readonly entries: {
+                    readonly read: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+                    readonly autoSign: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+                    readonly rename: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+                };
+                readonly _run: (dataset: v.Dataset<unknown, never>, config: v.Config<v.BaseIssue<unknown>>) => v.Dataset<{
+                    read?: boolean | undefined;
+                    autoSign?: boolean | undefined;
+                    rename?: boolean | undefined;
+                }, v.ObjectIssue | v.BooleanIssue>;
+                readonly _types?: {
+                    readonly input: {
+                        read?: boolean | undefined;
+                        autoSign?: boolean | undefined;
+                        rename?: boolean | undefined;
+                    };
+                    readonly output: {
+                        read?: boolean | undefined;
+                        autoSign?: boolean | undefined;
+                        rename?: boolean | undefined;
+                    };
+                    readonly issue: v.ObjectIssue | v.BooleanIssue;
+                } | undefined;
+            };
+            readonly type: v.LiteralSchema<"account", undefined>;
+            readonly resourceId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.CheckAction<string, undefined>, v.BrandAction<string, "AccountResourceId">]>;
+        }, undefined>, v.ObjectSchema<{
+            readonly actions: Omit<v.ObjectSchema<{
+                readonly addPrivateKey: v.BooleanSchema<undefined>;
+                readonly openPopup: v.BooleanSchema<undefined>;
+                readonly openFullPage: v.BooleanSchema<undefined>;
+                readonly readAllAccounts: v.BooleanSchema<undefined>;
+            }, undefined>, "_types" | "_run" | "entries"> & {
+                readonly entries: {
+                    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>;
+                };
+                readonly _run: (dataset: v.Dataset<unknown, never>, config: v.Config<v.BaseIssue<unknown>>) => v.Dataset<{
+                    addPrivateKey?: boolean | undefined;
+                    openPopup?: boolean | undefined;
+                    openFullPage?: boolean | undefined;
+                    readAllAccounts?: boolean | undefined;
+                }, v.ObjectIssue | v.BooleanIssue>;
+                readonly _types?: {
+                    readonly input: {
+                        addPrivateKey?: boolean | undefined;
+                        openPopup?: boolean | undefined;
+                        openFullPage?: boolean | undefined;
+                        readAllAccounts?: boolean | undefined;
+                    };
+                    readonly output: {
+                        addPrivateKey?: boolean | undefined;
+                        openPopup?: boolean | undefined;
+                        openFullPage?: boolean | undefined;
+                        readAllAccounts?: boolean | undefined;
+                    };
+                    readonly issue: v.ObjectIssue | v.BooleanIssue;
+                } | undefined;
+            };
+            readonly type: v.LiteralSchema<"wallet", undefined>;
+            readonly resourceId: v.LiteralSchema<"wallet", undefined>;
+        }, undefined>], undefined>, undefined>, never>;
+    }, undefined>, never>;
     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 GetCurrentPermissions = MethodParamsAndResult<v.InferOutput<typeof getCurrentPermissionsParamsSchema>, v.InferOutput<typeof getCurrentPermissionsResultSchema>>;
+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>;
@@ -1103,7 +1788,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;
@@ -1173,4 +1858,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 CreateInscriptionOptions, type CreateInscriptionPayload, type CreateInscriptionResponse, type CreateRepeatInscriptionsOptions, type CreateRepeatInscriptionsPayload, type CreateRepeatInscriptionsResponse, DefaultAdaptersInfo, type DeployContractParams, type DeployContractResult, type DisconnectEvent, type EstimateRbfOrder, type EstimateRunesEtch, type EstimateRunesEtchParams, type EstimateRunesEtchResult, type EstimateRunesMint, type EstimateRunesMintParams, type EstimateRunesMintResult, type EtchRunes, type EtchRunesParams, type EtchRunesResult, 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 Provider, type PsbtPayload, type RbfOrder, type Recipient$2 as Recipient, 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, createInscription, createRepeatInscriptions, defaultAdapters, disconnectEventName, disconnectSchema, 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, 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 EstimateRbfOrder, type EstimateRunesEtch, type EstimateRunesEtchParams, type EstimateRunesEtchResult, type EstimateRunesMint, type EstimateRunesMintParams, type EstimateRunesMintResult, type EtchRunes, type EtchRunesParams, type EtchRunesResult, 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 GetOrder, type GetRunesBalance, type GetRunesBalanceParams, type GetRunesBalanceRequestMessage, type GetRunesBalanceResult, type GetWalletType, type GetWalletTypeParams, type GetWalletTypeRequestMessage, type GetWalletTypeResult, type InputToSign, MessageSigningProtocols, type MethodParamsAndResult, type MintRunes, type MintRunesParams, type MintRunesResult, type NetworkChangeEvent, type OrdinalsRequestMethod, type OrdinalsRequests, type Params, type PermissionWithoutClientId, type Provider, type PsbtPayload, type RbfOrder, 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 RunesRequestMethod, type RunesRequests, SatsConnectAdapter, type SendBtcTransactionOptions, type SendBtcTransactionPayload, type SendBtcTransactionResponse, type SendInscriptions, 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 TransferRunes, type TransferRunesParams, type TransferRunesRequest, type TransferRunesResult, TransferRunesResultSchema, 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, permissionTemplate, removeDefaultProvider, renouncePermissionsMethodName, renouncePermissionsParamsSchema, renouncePermissionsRequestMessageSchema, renouncePermissionsResultSchema, request, requestPermissionsMethodName, requestPermissionsParamsSchema, requestPermissionsRequestMessageSchema, requestPermissionsResultSchema, rpcErrorResponseMessageSchema, rpcRequestMessageSchema, rpcResponseMessageSchema, rpcSuccessResponseMessageSchema, sendBtcTransaction, sendInscriptionsMethodName, sendInscriptionsParamsSchema, sendInscriptionsResultSchema, sendInscriptionsSchema, sendTransferMethodName, sendTransferParamsSchema, sendTransferRequestMessageSchema, sendTransferResultSchema, setDefaultProvider, signMessage, signMessageMethodName, signMessageParamsSchema, signMessageRequestMessageSchema, signMessageResultSchema, signMultipleTransactions, signPsbtMethodName, signPsbtParamsSchema, signPsbtRequestMessageSchema, signPsbtResultSchema, signTransaction, stxCallContractMethodName, stxCallContractParamsSchema, stxCallContractRequestMessageSchema, stxCallContractResultSchema, 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, transferRunesMethodName, transferRunesParamsSchema, transferRunesRequestSchema, walletEventSchema, walletTypeSchema, walletTypes };