@getpara/react-sdk-lite 2.0.0-alpha.33 → 2.0.0-alpha.35

package/dist/provider/hooks/mutations/useCreatePregenWalletPerType.d.ts

@@ -0,0 +1,42 @@
+export declare const CREATE_PREGEN_WALLET_PER_TYPE_KEY = "CREATE_PREGEN_WALLET_PER_TYPE";
+/**
+ * React hook for the `createPregenWalletPerType` mutation.
+ *
+ * Returns a mutation result object with all standard fields from `useMutation`, except:
+ * - `mutate` and `mutateAsync` are replaced by:
+ *   - `createPregenWalletPerType`: function to trigger the mutation (same as `mutate`)
+ *   - `createPregenWalletPerTypeAsync`: async function to trigger the mutation (same as `mutateAsync`)
+ *
+ * @example
+ * const { createPregenWalletPerType, createPregenWalletPerTypeAsync } = useCreatePregenWalletPerType();
+ * createPregenWalletPerType({ ...params });
+ * // or
+ * await createPregenWalletPerTypeAsync({ ...params });
+ */
+export declare const useCreatePregenWalletPerType: () => {
+    status: "error" | "idle" | "pending" | "success";
+    data: import("@getpara/web-sdk").Wallet[] | undefined;
+    isSuccess: boolean;
+    variables: {
+        types?: import("@getpara/web-sdk").TWalletType[] | undefined;
+        pregenId: import("@getpara/web-sdk").PregenAuth;
+    } | undefined;
+    error: Error | null;
+    isError: boolean;
+    isIdle: boolean;
+    isPending: boolean;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    createPregenWalletPerType: import("@tanstack/react-query").UseMutateFunction<import("@getpara/web-sdk").Wallet[], Error, {
+        types?: import("@getpara/web-sdk").TWalletType[] | undefined;
+        pregenId: import("@getpara/web-sdk").PregenAuth;
+    }, unknown>;
+    createPregenWalletPerTypeAsync: import("@tanstack/react-query").UseMutateAsyncFunction<import("@getpara/web-sdk").Wallet[], Error, {
+        types?: import("@getpara/web-sdk").TWalletType[] | undefined;
+        pregenId: import("@getpara/web-sdk").PregenAuth;
+    }, unknown>;
+};

package/dist/provider/hooks/mutations/useCreatePregenWalletPerType.js

@@ -0,0 +1,28 @@
+"use client";
+import {
+  __async
+} from "../../../chunk-MMUBH76A.js";
+import { useMutation } from "@tanstack/react-query";
+import { useClient } from "../utils/index.js";
+import { renameMutations } from "../../utils/renameMutations.js";
+import { createPregenWalletPerType } from "../../actions/index.js";
+const CREATE_PREGEN_WALLET_PER_TYPE_KEY = "CREATE_PREGEN_WALLET_PER_TYPE";
+const useCreatePregenWalletPerType = () => {
+  const para = useClient();
+  const mutation = useMutation({
+    mutationKey: [CREATE_PREGEN_WALLET_PER_TYPE_KEY],
+    mutationFn: (args) => __async(void 0, null, function* () {
+      try {
+        const result = yield createPregenWalletPerType(para, args);
+        return result;
+      } catch (error) {
+        throw error;
+      }
+    })
+  });
+  return renameMutations(mutation, "createPregenWalletPerType");
+};
+export {
+  CREATE_PREGEN_WALLET_PER_TYPE_KEY,
+  useCreatePregenWalletPerType
+};

package/dist/provider/hooks/mutations/useCreateWallet.d.ts

@@ -0,0 +1,42 @@
+export declare const CREATE_WALLET_KEY = "CREATE_WALLET";
+/**
+ * React hook for the `createWallet` mutation.
+ *
+ * Returns a mutation result object with all standard fields from `useMutation`, except:
+ * - `mutate` and `mutateAsync` are replaced by:
+ *   - `createWallet`: function to trigger the mutation (same as `mutate`)
+ *   - `createWalletAsync`: async function to trigger the mutation (same as `mutateAsync`)
+ *
+ * @example
+ * const { createWallet, createWalletAsync } = useCreateWallet();
+ * createWallet({ ...params });
+ * // or
+ * await createWalletAsync({ ...params });
+ */
+export declare const useCreateWallet: () => {
+    status: "error" | "idle" | "pending" | "success";
+    data: [import("@getpara/web-sdk").Wallet, string | undefined] | undefined;
+    isSuccess: boolean;
+    variables: {
+        type?: Uppercase<import("@getpara/web-sdk").TWalletType> | undefined;
+        skipDistribute?: boolean | undefined;
+    } | undefined;
+    error: Error | null;
+    isError: boolean;
+    isIdle: boolean;
+    isPending: boolean;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    createWallet: import("@tanstack/react-query").UseMutateFunction<[import("@getpara/web-sdk").Wallet, string | undefined], Error, {
+        type?: Uppercase<import("@getpara/web-sdk").TWalletType> | undefined;
+        skipDistribute?: boolean | undefined;
+    }, unknown>;
+    createWalletAsync: import("@tanstack/react-query").UseMutateAsyncFunction<[import("@getpara/web-sdk").Wallet, string | undefined], Error, {
+        type?: Uppercase<import("@getpara/web-sdk").TWalletType> | undefined;
+        skipDistribute?: boolean | undefined;
+    }, unknown>;
+};

package/dist/provider/hooks/mutations/useCreateWallet.js

@@ -0,0 +1,28 @@
+"use client";
+import {
+  __async
+} from "../../../chunk-MMUBH76A.js";
+import { useMutation } from "@tanstack/react-query";
+import { useClient } from "../utils/index.js";
+import { renameMutations } from "../../utils/renameMutations.js";
+import { createWallet } from "../../actions/index.js";
+const CREATE_WALLET_KEY = "CREATE_WALLET";
+const useCreateWallet = () => {
+  const para = useClient();
+  const mutation = useMutation({
+    mutationKey: [CREATE_WALLET_KEY],
+    mutationFn: (args) => __async(void 0, null, function* () {
+      try {
+        const result = yield createWallet(para, args);
+        return result;
+      } catch (error) {
+        throw error;
+      }
+    })
+  });
+  return renameMutations(mutation, "createWallet");
+};
+export {
+  CREATE_WALLET_KEY,
+  useCreateWallet
+};

package/dist/provider/hooks/mutations/useCreateWalletPerType.d.ts

@@ -0,0 +1,54 @@
+export declare const CREATE_WALLET_PER_TYPE_KEY = "CREATE_WALLET_PER_TYPE";
+/**
+ * React hook for the `createWalletPerType` mutation.
+ *
+ * Returns a mutation result object with all standard fields from `useMutation`, except:
+ * - `mutate` and `mutateAsync` are replaced by:
+ *   - `createWalletPerType`: function to trigger the mutation (same as `mutate`)
+ *   - `createWalletPerTypeAsync`: async function to trigger the mutation (same as `mutateAsync`)
+ *
+ * @example
+ * const { createWalletPerType, createWalletPerTypeAsync } = useCreateWalletPerType();
+ * createWalletPerType({ ...params });
+ * // or
+ * await createWalletPerTypeAsync({ ...params });
+ */
+export declare const useCreateWalletPerType: () => {
+    status: "error" | "idle" | "pending" | "success";
+    data: {
+        wallets: import("@getpara/web-sdk").Wallet[];
+        walletIds: import("@getpara/web-sdk").CurrentWalletIds;
+        recoverySecret?: string | undefined;
+    } | undefined;
+    isSuccess: boolean;
+    variables: {
+        types?: Uppercase<import("@getpara/web-sdk").TWalletType>[] | undefined;
+        skipDistribute?: boolean | undefined;
+    } | undefined;
+    error: Error | null;
+    isError: boolean;
+    isIdle: boolean;
+    isPending: boolean;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    createWalletPerType: import("@tanstack/react-query").UseMutateFunction<{
+        wallets: import("@getpara/web-sdk").Wallet[];
+        walletIds: import("@getpara/web-sdk").CurrentWalletIds;
+        recoverySecret?: string | undefined;
+    }, Error, {
+        types?: Uppercase<import("@getpara/web-sdk").TWalletType>[] | undefined;
+        skipDistribute?: boolean | undefined;
+    }, unknown>;
+    createWalletPerTypeAsync: import("@tanstack/react-query").UseMutateAsyncFunction<{
+        wallets: import("@getpara/web-sdk").Wallet[];
+        walletIds: import("@getpara/web-sdk").CurrentWalletIds;
+        recoverySecret?: string | undefined;
+    }, Error, {
+        types?: Uppercase<import("@getpara/web-sdk").TWalletType>[] | undefined;
+        skipDistribute?: boolean | undefined;
+    }, unknown>;
+};

package/dist/provider/hooks/mutations/useCreateWalletPerType.js

@@ -0,0 +1,28 @@
+"use client";
+import {
+  __async
+} from "../../../chunk-MMUBH76A.js";
+import { useMutation } from "@tanstack/react-query";
+import { useClient } from "../utils/index.js";
+import { renameMutations } from "../../utils/renameMutations.js";
+import { createWalletPerType } from "../../actions/index.js";
+const CREATE_WALLET_PER_TYPE_KEY = "CREATE_WALLET_PER_TYPE";
+const useCreateWalletPerType = () => {
+  const para = useClient();
+  const mutation = useMutation({
+    mutationKey: [CREATE_WALLET_PER_TYPE_KEY],
+    mutationFn: (args) => __async(void 0, null, function* () {
+      try {
+        const result = yield createWalletPerType(para, args);
+        return result;
+      } catch (error) {
+        throw error;
+      }
+    })
+  });
+  return renameMutations(mutation, "createWalletPerType");
+};
+export {
+  CREATE_WALLET_PER_TYPE_KEY,
+  useCreateWalletPerType
+};

package/dist/provider/hooks/mutations/useEnable2fa.d.ts

@@ -0,0 +1,39 @@
+export declare const ENABLE_2FA_KEY = "ENABLE_2FA";
+/**
+ * React hook for the `enable2fa` mutation.
+ *
+ * Returns a mutation result object with all standard fields from `useMutation`, except:
+ * - `mutate` and `mutateAsync` are replaced by:
+ *   - `enable2fa`: function to trigger the mutation (same as `mutate`)
+ *   - `enable2faAsync`: async function to trigger the mutation (same as `mutateAsync`)
+ *
+ * @example
+ * const { enable2fa, enable2faAsync } = useEnable2fa();
+ * enable2fa({ ...params });
+ * // or
+ * await enable2faAsync({ ...params });
+ */
+export declare const useEnable2fa: () => {
+    status: "error" | "idle" | "pending" | "success";
+    data: void | undefined;
+    isSuccess: boolean;
+    variables: {
+        verificationCode: string;
+    } | undefined;
+    error: Error | null;
+    isError: boolean;
+    isIdle: boolean;
+    isPending: boolean;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    enable2fa: import("@tanstack/react-query").UseMutateFunction<void, Error, {
+        verificationCode: string;
+    }, unknown>;
+    enable2faAsync: import("@tanstack/react-query").UseMutateAsyncFunction<void, Error, {
+        verificationCode: string;
+    }, unknown>;
+};

package/dist/provider/hooks/mutations/useEnable2fa.js

@@ -0,0 +1,28 @@
+"use client";
+import {
+  __async
+} from "../../../chunk-MMUBH76A.js";
+import { useMutation } from "@tanstack/react-query";
+import { useClient } from "../utils/index.js";
+import { renameMutations } from "../../utils/renameMutations.js";
+import { enable2fa } from "../../actions/index.js";
+const ENABLE_2FA_KEY = "ENABLE_2FA";
+const useEnable2fa = () => {
+  const para = useClient();
+  const mutation = useMutation({
+    mutationKey: [ENABLE_2FA_KEY],
+    mutationFn: (args) => __async(void 0, null, function* () {
+      try {
+        const result = yield enable2fa(para, args);
+        return result;
+      } catch (error) {
+        throw error;
+      }
+    })
+  });
+  return renameMutations(mutation, "enable2fa");
+};
+export {
+  ENABLE_2FA_KEY,
+  useEnable2fa
+};

package/dist/provider/hooks/mutations/useHasPregenWallet.d.ts

@@ -0,0 +1,40 @@
+import { Compute } from '../../types/utils.js';
+export declare const HAS_PREGEN_WALLET_KEY = "HAS_PREGEN_WALLET";
+/**
+ * React hook for the `hasPregenWallet` mutation.
+ *
+ * Returns a mutation result object with all standard fields from `useMutation`, except:
+ * - `mutate` and `mutateAsync` are replaced by:
+ *   - `hasPregenWallet`: function to trigger the mutation (same as `mutate`)
+ *   - `hasPregenWalletAsync`: async function to trigger the mutation (same as `mutateAsync`)
+ *
+ * @example
+ * const { hasPregenWallet, hasPregenWalletAsync } = useHasPregenWallet();
+ * hasPregenWallet({ ...params });
+ * // or
+ * await hasPregenWalletAsync({ ...params });
+ */
+export declare const useHasPregenWallet: () => {
+    status: "error" | "idle" | "pending" | "success";
+    data: Compute<boolean> | undefined;
+    isSuccess: boolean;
+    variables: {
+        pregenId: import("@getpara/web-sdk").PregenAuth;
+    } | undefined;
+    error: Error | null;
+    isError: boolean;
+    isIdle: boolean;
+    isPending: boolean;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    hasPregenWallet: import("@tanstack/react-query").UseMutateFunction<Compute<boolean>, Error, {
+        pregenId: import("@getpara/web-sdk").PregenAuth;
+    }, unknown>;
+    hasPregenWalletAsync: import("@tanstack/react-query").UseMutateAsyncFunction<Compute<boolean>, Error, {
+        pregenId: import("@getpara/web-sdk").PregenAuth;
+    }, unknown>;
+};

package/dist/provider/hooks/mutations/useHasPregenWallet.js

@@ -0,0 +1,28 @@
+"use client";
+import {
+  __async
+} from "../../../chunk-MMUBH76A.js";
+import { useMutation } from "@tanstack/react-query";
+import { useClient } from "../utils/index.js";
+import { renameMutations } from "../../utils/renameMutations.js";
+import { hasPregenWallet } from "../../actions/index.js";
+const HAS_PREGEN_WALLET_KEY = "HAS_PREGEN_WALLET";
+const useHasPregenWallet = () => {
+  const para = useClient();
+  const mutation = useMutation({
+    mutationKey: [HAS_PREGEN_WALLET_KEY],
+    mutationFn: (args) => __async(void 0, null, function* () {
+      try {
+        const result = yield hasPregenWallet(para, args);
+        return result;
+      } catch (error) {
+        throw error;
+      }
+    })
+  });
+  return renameMutations(mutation, "hasPregenWallet");
+};
+export {
+  HAS_PREGEN_WALLET_KEY,
+  useHasPregenWallet
+};

package/dist/provider/hooks/mutations/useIssueJwt.d.ts

@@ -0,0 +1,48 @@
+export declare const ISSUE_JWT_KEY = "ISSUE_JWT";
+/**
+ * React hook for the `issueJwt` mutation.
+ *
+ * Returns a mutation result object with all standard fields from `useMutation`, except:
+ * - `mutate` and `mutateAsync` are replaced by:
+ *   - `issueJwt`: function to trigger the mutation (same as `mutate`)
+ *   - `issueJwtAsync`: async function to trigger the mutation (same as `mutateAsync`)
+ *
+ * @example
+ * const { issueJwt, issueJwtAsync } = useIssueJwt();
+ * issueJwt({ ...params });
+ * // or
+ * await issueJwtAsync({ ...params });
+ */
+export declare const useIssueJwt: () => {
+    status: "error" | "idle" | "pending" | "success";
+    data: {
+        token: string;
+        keyId: string;
+    } | undefined;
+    isSuccess: boolean;
+    variables: {
+        keyIndex?: number | undefined;
+    } | undefined;
+    error: Error | null;
+    isError: boolean;
+    isIdle: boolean;
+    isPending: boolean;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    issueJwt: import("@tanstack/react-query").UseMutateFunction<{
+        token: string;
+        keyId: string;
+    }, Error, {
+        keyIndex?: number | undefined;
+    }, unknown>;
+    issueJwtAsync: import("@tanstack/react-query").UseMutateAsyncFunction<{
+        token: string;
+        keyId: string;
+    }, Error, {
+        keyIndex?: number | undefined;
+    }, unknown>;
+};

package/dist/provider/hooks/mutations/useIssueJwt.js

@@ -0,0 +1,28 @@
+"use client";
+import {
+  __async
+} from "../../../chunk-MMUBH76A.js";
+import { useMutation } from "@tanstack/react-query";
+import { useClient } from "../utils/index.js";
+import { renameMutations } from "../../utils/renameMutations.js";
+import { issueJwt } from "../../actions/index.js";
+const ISSUE_JWT_KEY = "ISSUE_JWT";
+const useIssueJwt = () => {
+  const para = useClient();
+  const mutation = useMutation({
+    mutationKey: [ISSUE_JWT_KEY],
+    mutationFn: (args) => __async(void 0, null, function* () {
+      try {
+        const result = yield issueJwt(para, args);
+        return result;
+      } catch (error) {
+        throw error;
+      }
+    })
+  });
+  return renameMutations(mutation, "issueJwt");
+};
+export {
+  ISSUE_JWT_KEY,
+  useIssueJwt
+};

package/dist/provider/hooks/mutations/useKeepSessionAlive.d.ts

@@ -0,0 +1,34 @@
+import { Compute } from '../../types/utils.js';
+export declare const KEEP_SESSION_ALIVE_KEY = "KEEP_SESSION_ALIVE";
+/**
+ * React hook for the `keepSessionAlive` mutation.
+ *
+ * Returns a mutation result object with all standard fields from `useMutation`, except:
+ * - `mutate` and `mutateAsync` are replaced by:
+ *   - `keepSessionAlive`: function to trigger the mutation (same as `mutate`)
+ *   - `keepSessionAliveAsync`: async function to trigger the mutation (same as `mutateAsync`)
+ *
+ * @example
+ * const { keepSessionAlive, keepSessionAliveAsync } = useKeepSessionAlive();
+ * keepSessionAlive({ ...params });
+ * // or
+ * await keepSessionAliveAsync({ ...params });
+ */
+export declare const useKeepSessionAlive: () => {
+    status: "error" | "idle" | "pending" | "success";
+    data: Compute<boolean> | undefined;
+    isSuccess: boolean;
+    variables: void | undefined;
+    error: Error | null;
+    isError: boolean;
+    isIdle: boolean;
+    isPending: boolean;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    keepSessionAlive: import("@tanstack/react-query").UseMutateFunction<Compute<boolean>, Error, void, unknown>;
+    keepSessionAliveAsync: import("@tanstack/react-query").UseMutateAsyncFunction<Compute<boolean>, Error, void, unknown>;
+};

package/dist/provider/hooks/mutations/useKeepSessionAlive.js

@@ -0,0 +1,28 @@
+"use client";
+import {
+  __async
+} from "../../../chunk-MMUBH76A.js";
+import { useMutation } from "@tanstack/react-query";
+import { useClient } from "../utils/index.js";
+import { renameMutations } from "../../utils/renameMutations.js";
+import { keepSessionAlive } from "../../actions/index.js";
+const KEEP_SESSION_ALIVE_KEY = "KEEP_SESSION_ALIVE";
+const useKeepSessionAlive = () => {
+  const para = useClient();
+  const mutation = useMutation({
+    mutationKey: [KEEP_SESSION_ALIVE_KEY],
+    mutationFn: (args) => __async(void 0, null, function* () {
+      try {
+        const result = yield keepSessionAlive(para, args);
+        return result;
+      } catch (error) {
+        throw error;
+      }
+    })
+  });
+  return renameMutations(mutation, "keepSessionAlive");
+};
+export {
+  KEEP_SESSION_ALIVE_KEY,
+  useKeepSessionAlive
+};

package/dist/provider/hooks/mutations/useLinkAccount.d.ts

@@ -1,5 +1,34 @@
+import { TExternalWallet, TWalletType } from '@getpara/web-sdk';
+import { ModalLinkAccountArgs } from '../../providers/AccountLinkProvider.js';
+/**
+ * Arguments for linking accounts via modal
+ * @example
+ * // Open modal for user to select link type
+ * linkAccount()
+ *
+ * @example
+ * // Link with email
+ * linkAccount({ auth: { email: "user@example.com" } })
+ *
+ * @example
+ * // Link specific account type
+ * linkAccount({ type: "TWITTER" })
+ *
+ * @example
+ * // Link external wallet and allow user to select type
+ * linkAccount({ externalWallet: { provider: "METAMASK" } })
+ * OR
+ * // Link external wallet with specific type
+ * linkAccount({ externalWallet: { provider: "METAMASK", type: "EVM" } })
+ */
+export type LinkAccountArgs = Omit<ModalLinkAccountArgs, 'externalWallet'> | {
+    externalWallet: {
+        provider: TExternalWallet;
+        type?: TWalletType;
+    };
+} | undefined;
 export declare const useLinkAccount: () => {
-    linkAccount: (_: import("../../providers/AccountLinkProvider.js").ModalLinkAccountArgs) => Promise<void>;
+    linkAccount: (args: LinkAccountArgs) => Promise<void>;
     error: string | null;
     status: import("@tanstack/query-core").MutationStatus;
     isPending: boolean;

package/dist/provider/hooks/mutations/useLinkAccount.js

@@ -4,7 +4,9 @@ import { useAccountLinking } from "../../providers/AccountLinkProvider.js";
 const useLinkAccount = () => {
   const { linkAccount, linkAccountError, linkAccountStatus } = useAccountLinking();
   return {
-    linkAccount,
+    linkAccount: (args) => {
+      return linkAccount(args);
+    },
     error: linkAccountError,
     status: linkAccountStatus,
     isPending: linkAccountStatus === "pending",

package/dist/provider/hooks/mutations/useLoginExternalWallet.d.ts

@@ -0,0 +1,46 @@
+import { Compute } from '../../types/utils.js';
+export declare const LOGIN_EXTERNAL_WALLET_KEY = "LOGIN_EXTERNAL_WALLET";
+/**
+ * React hook for the `loginExternalWallet` mutation.
+ *
+ * Returns a mutation result object with all standard fields from `useMutation`, except:
+ * - `mutate` and `mutateAsync` are replaced by:
+ *   - `loginExternalWallet`: function to trigger the mutation (same as `mutate`)
+ *   - `loginExternalWalletAsync`: async function to trigger the mutation (same as `mutateAsync`)
+ *
+ * @example
+ * const { loginExternalWallet, loginExternalWalletAsync } = useLoginExternalWallet();
+ * loginExternalWallet({ ...params });
+ * // or
+ * await loginExternalWalletAsync({ ...params });
+ */
+export declare const useLoginExternalWallet: () => {
+    status: "error" | "idle" | "pending" | "success";
+    data: Compute<import("@getpara/core-sdk/dist/types/types/methods.js").AuthStateVerifyOrLogin> | undefined;
+    isSuccess: boolean;
+    variables: {
+        portalTheme?: import("@getpara/web-sdk").Theme | undefined;
+        useShortUrls?: boolean | undefined;
+        externalWallet: import("@getpara/web-sdk").ExternalWalletInfo | import("@getpara/web-sdk").ExternalWalletInfo[];
+    } | undefined;
+    error: Error | null;
+    isError: boolean;
+    isIdle: boolean;
+    isPending: boolean;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    loginExternalWallet: import("@tanstack/react-query").UseMutateFunction<Compute<import("@getpara/core-sdk/dist/types/types/methods.js").AuthStateVerifyOrLogin>, Error, {
+        portalTheme?: import("@getpara/web-sdk").Theme | undefined;
+        useShortUrls?: boolean | undefined;
+        externalWallet: import("@getpara/web-sdk").ExternalWalletInfo | import("@getpara/web-sdk").ExternalWalletInfo[];
+    }, unknown>;
+    loginExternalWalletAsync: import("@tanstack/react-query").UseMutateAsyncFunction<Compute<import("@getpara/core-sdk/dist/types/types/methods.js").AuthStateVerifyOrLogin>, Error, {
+        portalTheme?: import("@getpara/web-sdk").Theme | undefined;
+        useShortUrls?: boolean | undefined;
+        externalWallet: import("@getpara/web-sdk").ExternalWalletInfo | import("@getpara/web-sdk").ExternalWalletInfo[];
+    }, unknown>;
+};

package/dist/provider/hooks/mutations/useLoginExternalWallet.js

@@ -0,0 +1,28 @@
+"use client";
+import {
+  __async
+} from "../../../chunk-MMUBH76A.js";
+import { useMutation } from "@tanstack/react-query";
+import { useClient } from "../utils/index.js";
+import { renameMutations } from "../../utils/renameMutations.js";
+import { loginExternalWallet } from "../../actions/index.js";
+const LOGIN_EXTERNAL_WALLET_KEY = "LOGIN_EXTERNAL_WALLET";
+const useLoginExternalWallet = () => {
+  const para = useClient();
+  const mutation = useMutation({
+    mutationKey: [LOGIN_EXTERNAL_WALLET_KEY],
+    mutationFn: (args) => __async(void 0, null, function* () {
+      try {
+        const result = yield loginExternalWallet(para, args);
+        return result;
+      } catch (error) {
+        throw error;
+      }
+    })
+  });
+  return renameMutations(mutation, "loginExternalWallet");
+};
+export {
+  LOGIN_EXTERNAL_WALLET_KEY,
+  useLoginExternalWallet
+};

package/dist/provider/hooks/mutations/useLogout.d.ts

@@ -0,0 +1,39 @@
+export declare const LOGOUT_KEY = "LOGOUT";
+/**
+ * React hook for the `logout` mutation.
+ *
+ * Returns a mutation result object with all standard fields from `useMutation`, except:
+ * - `mutate` and `mutateAsync` are replaced by:
+ *   - `logout`: function to trigger the mutation (same as `mutate`)
+ *   - `logoutAsync`: async function to trigger the mutation (same as `mutateAsync`)
+ *
+ * @example
+ * const { logout, logoutAsync } = useLogout();
+ * logout({ ...params });
+ * // or
+ * await logoutAsync({ ...params });
+ */
+export declare const useLogout: () => {
+    status: "error" | "idle" | "pending" | "success";
+    data: void | undefined;
+    isSuccess: boolean;
+    variables: void | {
+        clearPregenWallets?: boolean | undefined;
+    } | undefined;
+    error: Error | null;
+    isError: boolean;
+    isIdle: boolean;
+    isPending: boolean;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    logout: import("@tanstack/react-query").UseMutateFunction<void, Error, void | {
+        clearPregenWallets?: boolean | undefined;
+    }, unknown>;
+    logoutAsync: import("@tanstack/react-query").UseMutateAsyncFunction<void, Error, void | {
+        clearPregenWallets?: boolean | undefined;
+    }, unknown>;
+};