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

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

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

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

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

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

@@ -0,0 +1,84 @@
+export declare const VERIFY_NEW_ACCOUNT_KEY = "VERIFY_NEW_ACCOUNT";
+/**
+ * React hook for the `verifyNewAccount` mutation.
+ *
+ * Returns a mutation result object with all standard fields from `useMutation`, except:
+ * - `mutate` and `mutateAsync` are replaced by:
+ *   - `verifyNewAccount`: function to trigger the mutation (same as `mutate`)
+ *   - `verifyNewAccountAsync`: async function to trigger the mutation (same as `mutateAsync`)
+ *
+ * @example
+ * const { verifyNewAccount, verifyNewAccountAsync } = useVerifyNewAccount();
+ * verifyNewAccount({ ...params });
+ * // or
+ * await verifyNewAccountAsync({ ...params });
+ */
+export declare const useVerifyNewAccount: () => {
+    status: "error" | "idle" | "pending" | "success";
+    data: {
+        username?: string | undefined;
+        displayName?: string | undefined;
+        pfpUrl?: string | undefined;
+        externalWallet?: import("@getpara/web-sdk").ExternalWalletInfo | undefined;
+        auth: import("@getpara/user-management-client").PrimaryAuth;
+        userId: string;
+        stage: "signup";
+        isPasskeySupported: boolean;
+        passkeyUrl?: string | undefined;
+        passwordUrl?: string | undefined;
+        passkeyId?: string | undefined;
+        passwordId?: string | undefined;
+    } | undefined;
+    isSuccess: boolean;
+    variables: {
+        portalTheme?: import("@getpara/web-sdk").Theme | undefined;
+        useShortUrls?: boolean | undefined;
+        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;
+    verifyNewAccount: import("@tanstack/react-query").UseMutateFunction<{
+        username?: string | undefined;
+        displayName?: string | undefined;
+        pfpUrl?: string | undefined;
+        externalWallet?: import("@getpara/web-sdk").ExternalWalletInfo | undefined;
+        auth: import("@getpara/user-management-client").PrimaryAuth;
+        userId: string;
+        stage: "signup";
+        isPasskeySupported: boolean;
+        passkeyUrl?: string | undefined;
+        passwordUrl?: string | undefined;
+        passkeyId?: string | undefined;
+        passwordId?: string | undefined;
+    }, Error, {
+        portalTheme?: import("@getpara/web-sdk").Theme | undefined;
+        useShortUrls?: boolean | undefined;
+        verificationCode: string;
+    }, unknown>;
+    verifyNewAccountAsync: import("@tanstack/react-query").UseMutateAsyncFunction<{
+        username?: string | undefined;
+        displayName?: string | undefined;
+        pfpUrl?: string | undefined;
+        externalWallet?: import("@getpara/web-sdk").ExternalWalletInfo | undefined;
+        auth: import("@getpara/user-management-client").PrimaryAuth;
+        userId: string;
+        stage: "signup";
+        isPasskeySupported: boolean;
+        passkeyUrl?: string | undefined;
+        passwordUrl?: string | undefined;
+        passkeyId?: string | undefined;
+        passwordId?: string | undefined;
+    }, Error, {
+        portalTheme?: import("@getpara/web-sdk").Theme | undefined;
+        useShortUrls?: boolean | undefined;
+        verificationCode: string;
+    }, unknown>;
+};

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

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

@@ -0,0 +1,64 @@
+import { Compute } from '../../types/utils.js';
+export declare const VERIFY_OAUTH_KEY = "VERIFY_OAUTH";
+/**
+ * React hook for the `verifyOAuth` mutation.
+ *
+ * Returns a mutation result object with all standard fields from `useMutation`, except:
+ * - `mutate` and `mutateAsync` are replaced by:
+ *   - `verifyOAuth`: function to trigger the mutation (same as `mutate`)
+ *   - `verifyOAuthAsync`: async function to trigger the mutation (same as `mutateAsync`)
+ *
+ * @example
+ * const { verifyOAuth, verifyOAuthAsync } = useVerifyOAuth();
+ * verifyOAuth({ ...params });
+ * // or
+ * await verifyOAuthAsync({ ...params });
+ */
+export declare const useVerifyOAuth: () => {
+    status: "error" | "idle" | "pending" | "success";
+    data: Compute<import("@getpara/core-sdk/dist/types/types/methods.js").AuthStateSignupOrLogin> | undefined;
+    isSuccess: boolean;
+    variables: {
+        portalTheme?: import("@getpara/web-sdk").Theme | undefined;
+        useShortUrls?: boolean | undefined;
+        method: Exclude<import("@getpara/web-sdk").TOAuthMethod, "TELEGRAM" | "FARCASTER">;
+        appScheme?: string | undefined;
+        onPoll?: (() => void) | undefined;
+        onCancel?: (() => void) | undefined;
+        isCanceled?: (() => boolean) | undefined;
+        onOAuthUrl?: ((url: string) => void) | undefined;
+        onOAuthPopup?: ((popup: Window) => void) | undefined;
+    } | undefined;
+    error: Error | null;
+    isError: boolean;
+    isIdle: boolean;
+    isPending: boolean;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    verifyOAuth: import("@tanstack/react-query").UseMutateFunction<Compute<import("@getpara/core-sdk/dist/types/types/methods.js").AuthStateSignupOrLogin>, Error, {
+        portalTheme?: import("@getpara/web-sdk").Theme | undefined;
+        useShortUrls?: boolean | undefined;
+        method: Exclude<import("@getpara/web-sdk").TOAuthMethod, "TELEGRAM" | "FARCASTER">;
+        appScheme?: string | undefined;
+        onPoll?: (() => void) | undefined;
+        onCancel?: (() => void) | undefined;
+        isCanceled?: (() => boolean) | undefined;
+        onOAuthUrl?: ((url: string) => void) | undefined;
+        onOAuthPopup?: ((popup: Window) => void) | undefined;
+    }, unknown>;
+    verifyOAuthAsync: import("@tanstack/react-query").UseMutateAsyncFunction<Compute<import("@getpara/core-sdk/dist/types/types/methods.js").AuthStateSignupOrLogin>, Error, {
+        portalTheme?: import("@getpara/web-sdk").Theme | undefined;
+        useShortUrls?: boolean | undefined;
+        method: Exclude<import("@getpara/web-sdk").TOAuthMethod, "TELEGRAM" | "FARCASTER">;
+        appScheme?: string | undefined;
+        onPoll?: (() => void) | undefined;
+        onCancel?: (() => void) | undefined;
+        isCanceled?: (() => boolean) | undefined;
+        onOAuthUrl?: ((url: string) => void) | undefined;
+        onOAuthPopup?: ((popup: Window) => void) | undefined;
+    }, unknown>;
+};

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

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

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

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

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

@@ -0,0 +1,57 @@
+export declare const WAIT_FOR_LOG_IN_KEY = "WAIT_FOR_LOG_IN";
+/**
+ * React hook for the `waitForLogin` mutation.
+ *
+ * Returns a mutation result object with all standard fields from `useMutation`, except:
+ * - `mutate` and `mutateAsync` are replaced by:
+ *   - `waitForLogin`: function to trigger the mutation (same as `mutate`)
+ *   - `waitForLoginAsync`: async function to trigger the mutation (same as `mutateAsync`)
+ *
+ * @example
+ * const { waitForLogin, waitForLoginAsync } = useWaitForLogin();
+ * waitForLogin({ ...params });
+ * // or
+ * await waitForLoginAsync({ ...params });
+ */
+export declare const useWaitForLogin: () => {
+    status: "error" | "idle" | "pending" | "success";
+    data: {
+        needsWallet?: boolean | undefined;
+        partnerId?: string | undefined;
+    } | undefined;
+    isSuccess: boolean;
+    variables: {
+        onPoll?: (() => void) | undefined;
+        onCancel?: (() => void) | undefined;
+        skipSessionRefresh?: boolean | undefined;
+        isCanceled?: (() => 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;
+    waitForLogin: import("@tanstack/react-query").UseMutateFunction<{
+        needsWallet?: boolean | undefined;
+        partnerId?: string | undefined;
+    }, Error, {
+        onPoll?: (() => void) | undefined;
+        onCancel?: (() => void) | undefined;
+        skipSessionRefresh?: boolean | undefined;
+        isCanceled?: (() => boolean) | undefined;
+    }, unknown>;
+    waitForLoginAsync: import("@tanstack/react-query").UseMutateAsyncFunction<{
+        needsWallet?: boolean | undefined;
+        partnerId?: string | undefined;
+    }, Error, {
+        onPoll?: (() => void) | undefined;
+        onCancel?: (() => void) | undefined;
+        skipSessionRefresh?: boolean | undefined;
+        isCanceled?: (() => boolean) | undefined;
+    }, unknown>;
+};

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

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

@@ -0,0 +1,45 @@
+export declare const WAIT_FOR_SIGN_UP_KEY = "WAIT_FOR_SIGN_UP";
+/**
+ * React hook for the `waitForSignup` mutation.
+ *
+ * Returns a mutation result object with all standard fields from `useMutation`, except:
+ * - `mutate` and `mutateAsync` are replaced by:
+ *   - `waitForSignup`: function to trigger the mutation (same as `mutate`)
+ *   - `waitForSignupAsync`: async function to trigger the mutation (same as `mutateAsync`)
+ *
+ * @example
+ * const { waitForSignup, waitForSignupAsync } = useWaitForSignup();
+ * waitForSignup({ ...params });
+ * // or
+ * await waitForSignupAsync({ ...params });
+ */
+export declare const useWaitForSignup: () => {
+    status: "error" | "idle" | "pending" | "success";
+    data: true | undefined;
+    isSuccess: boolean;
+    variables: {
+        onPoll?: (() => void) | undefined;
+        onCancel?: (() => void) | undefined;
+        isCanceled?: (() => 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;
+    waitForSignup: import("@tanstack/react-query").UseMutateFunction<true, Error, {
+        onPoll?: (() => void) | undefined;
+        onCancel?: (() => void) | undefined;
+        isCanceled?: (() => boolean) | undefined;
+    }, unknown>;
+    waitForSignupAsync: import("@tanstack/react-query").UseMutateAsyncFunction<true, Error, {
+        onPoll?: (() => void) | undefined;
+        onCancel?: (() => void) | undefined;
+        isCanceled?: (() => boolean) | undefined;
+    }, unknown>;
+};

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

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

@@ -0,0 +1,54 @@
+export declare const WAIT_FOR_WALLET_CREATION_KEY = "WAIT_FOR_WALLET_CREATION";
+/**
+ * React hook for the `waitForWalletCreation` mutation.
+ *
+ * Returns a mutation result object with all standard fields from `useMutation`, except:
+ * - `mutate` and `mutateAsync` are replaced by:
+ *   - `waitForWalletCreation`: function to trigger the mutation (same as `mutate`)
+ *   - `waitForWalletCreationAsync`: async function to trigger the mutation (same as `mutateAsync`)
+ *
+ * @example
+ * const { waitForWalletCreation, waitForWalletCreationAsync } = useWaitForWalletCreation();
+ * waitForWalletCreation({ ...params });
+ * // or
+ * await waitForWalletCreationAsync({ ...params });
+ */
+export declare const useWaitForWalletCreation: () => {
+    status: "error" | "idle" | "pending" | "success";
+    data: {
+        walletIds: import("@getpara/web-sdk").CurrentWalletIds;
+        recoverySecret?: string | undefined;
+    } | undefined;
+    isSuccess: boolean;
+    variables: {
+        onPoll?: (() => void) | undefined;
+        onCancel?: (() => void) | undefined;
+        isCanceled?: (() => 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;
+    waitForWalletCreation: import("@tanstack/react-query").UseMutateFunction<{
+        walletIds: import("@getpara/web-sdk").CurrentWalletIds;
+        recoverySecret?: string | undefined;
+    }, Error, {
+        onPoll?: (() => void) | undefined;
+        onCancel?: (() => void) | undefined;
+        isCanceled?: (() => boolean) | undefined;
+    }, unknown>;
+    waitForWalletCreationAsync: import("@tanstack/react-query").UseMutateAsyncFunction<{
+        walletIds: import("@getpara/web-sdk").CurrentWalletIds;
+        recoverySecret?: string | undefined;
+    }, Error, {
+        onPoll?: (() => void) | undefined;
+        onCancel?: (() => void) | undefined;
+        isCanceled?: (() => boolean) | undefined;
+    }, unknown>;
+};

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

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

@@ -1,10 +1,5 @@
-import { CoreMethodName, CoreMethodParams, CoreMethods, InternalAction, InternalMethodName, InternalMethodParams, InternalMethods } from '@getpara/web-sdk';
-import { CoreMethodMutationHook, CoreMethodMutationStateHook, InternalMethodMutationHook } from '../../types/utils.js';
-import { CoreAction } from '../../actions/utils.js';
-export declare function generateCoreMutation<const method extends CoreMethodName & keyof CoreMethods>(method: method, action: CoreAction<method>, { delay, defaultParams, }?: {
-    delay?: number;
-    defaultParams?: CoreMethodParams<method>;
-}): () => CoreMethodMutationHook<method>;
+import { CoreMethodName, CoreMethods, InternalAction, InternalMethodName, InternalMethodParams, InternalMethods } from '@getpara/web-sdk';
+import { CoreMethodMutationStateHook, InternalMethodMutationHook } from '../../types/utils.js';
 export declare function generateInternalMutation<const method extends InternalMethodName & keyof InternalMethods>(method: method, action: InternalAction<method>, { delay, defaultParams, }?: {
     delay?: number;
     defaultParams?: InternalMethodParams<method>;