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

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/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>;
+};

package/dist/provider/hooks/mutations/useLogout.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 { logout } from "../../actions/index.js";
+const LOGOUT_KEY = "LOGOUT";
+const useLogout = () => {
+  const para = useClient();
+  const mutation = useMutation({
+    mutationKey: [LOGOUT_KEY],
+    mutationFn: (..._0) => __async(void 0, [..._0], function* (args = {}) {
+      try {
+        const result = yield logout(para, args);
+        return result;
+      } catch (error) {
+        throw error;
+      }
+    })
+  });
+  return renameMutations(mutation, "logout");
+};
+export {
+  LOGOUT_KEY,
+  useLogout
+};

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

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

package/dist/provider/hooks/mutations/useResendVerificationCode.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 { resendVerificationCode } from "../../actions/index.js";
+const RESEND_VERIFICATION_CODE_KEY = "RESEND_VERIFICATION_CODE";
+const useResendVerificationCode = () => {
+  const para = useClient();
+  const mutation = useMutation({
+    mutationKey: [RESEND_VERIFICATION_CODE_KEY],
+    mutationFn: (args) => __async(void 0, null, function* () {
+      try {
+        const result = yield resendVerificationCode(para, args);
+        return result;
+      } catch (error) {
+        throw error;
+      }
+    })
+  });
+  return renameMutations(mutation, "resendVerificationCode");
+};
+export {
+  RESEND_VERIFICATION_CODE_KEY,
+  useResendVerificationCode
+};

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

@@ -0,0 +1,34 @@
+import { Compute } from '../../types/utils.js';
+export declare const SETUP_2FA_KEY = "SETUP_2FA";
+/**
+ * React hook for the `setup2fa` mutation.
+ *
+ * Returns a mutation result object with all standard fields from `useMutation`, except:
+ * - `mutate` and `mutateAsync` are replaced by:
+ *   - `setup2fa`: function to trigger the mutation (same as `mutate`)
+ *   - `setup2faAsync`: async function to trigger the mutation (same as `mutateAsync`)
+ *
+ * @example
+ * const { setup2fa, setup2faAsync } = useSetup2fa();
+ * setup2fa({ ...params });
+ * // or
+ * await setup2faAsync({ ...params });
+ */
+export declare const useSetup2fa: () => {
+    status: "error" | "idle" | "pending" | "success";
+    data: Compute<import("@getpara/web-sdk").Setup2faResponse> | 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;
+    setup2fa: import("@tanstack/react-query").UseMutateFunction<Compute<import("@getpara/web-sdk").Setup2faResponse>, Error, void, unknown>;
+    setup2faAsync: import("@tanstack/react-query").UseMutateAsyncFunction<Compute<import("@getpara/web-sdk").Setup2faResponse>, Error, void, unknown>;
+};

package/dist/provider/hooks/mutations/useSetup2fa.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 { setup2fa } from "../../actions/index.js";
+const SETUP_2FA_KEY = "SETUP_2FA";
+const useSetup2fa = () => {
+  const para = useClient();
+  const mutation = useMutation({
+    mutationKey: [SETUP_2FA_KEY],
+    mutationFn: (args) => __async(void 0, null, function* () {
+      try {
+        const result = yield setup2fa(para, args);
+        return result;
+      } catch (error) {
+        throw error;
+      }
+    })
+  });
+  return renameMutations(mutation, "setup2fa");
+};
+export {
+  SETUP_2FA_KEY,
+  useSetup2fa
+};