@openfort/react 0.0.1

package/build/components/OpenfortKit/types.d.ts

@@ -0,0 +1,136 @@
+import React, { ReactNode } from 'react';
+import { CustomAvatarProps, CustomTheme, Languages, Mode, Theme } from '../../types';
+import { RecoveryMethod } from '@openfort/openfort-js';
+import { OpenfortProviderProps } from '../../openfort/OpenfortProvider';
+export declare const routes: {
+    readonly PROVIDERS: "providers";
+    readonly SOCIAL_PROVIDERS: "socialProviders";
+    readonly LOADING: "loading";
+    readonly RECOVER: "recover";
+    readonly EMAIL_LOGIN: "emailLogin";
+    readonly EMAIL_SIGNUP: "emailSignup";
+    readonly FORGOT_PASSWORD: "forgotPassword";
+    readonly EMAIL_VERIFICATION: "emailVerification";
+    readonly LINK_EMAIL: "linkEmail";
+    readonly ONBOARDING: "onboarding";
+    readonly ABOUT: "about";
+    readonly CONNECTORS: "connectors";
+    readonly MOBILECONNECTORS: "mobileConnectors";
+    readonly CONNECT: "connect";
+    readonly DOWNLOAD: "download";
+    readonly PROFILE: "profile";
+    readonly SWITCHNETWORKS: "switchNetworks";
+};
+export declare enum AuthProvider {
+    GOOGLE = "google",
+    TWITTER = "twitter",
+    FACEBOOK = "facebook",
+    EMAIL = "email",
+    WALLET = "wallet",
+    GUEST = "guest"
+}
+export declare const socialProviders: AuthProvider[];
+type CommonWalletConfig = {
+    /** Publishable key for the Shield API */
+    shieldPublishableKey: string;
+    /** Policy ID (pol_...) for the embedded signer */
+    ethereumProviderPolicyId?: string;
+    debug?: boolean;
+};
+type EncryptionSession = {
+    /** Function to retrieve an encryption session using a session ID */
+    getEncryptionSession: () => Promise<string>;
+    createEncryptedSessionEndpoint?: never;
+} | {
+    /** API endpoint for creating an encrypted session */
+    getEncryptionSession?: never;
+    createEncryptedSessionEndpoint: string;
+};
+/**
+ * Configuration for automatic recovery, which requires an encryption session.
+ */
+type AutomaticRecoveryWalletConfig = {
+    /** Specifies that the recovery method is automatic */
+    recoveryMethod: RecoveryMethod.AUTOMATIC;
+} & EncryptionSession;
+type PasswordRecoveryWalletConfig = {
+    /** Specifies that the recovery method is password-based */
+    recoveryMethod: RecoveryMethod.PASSWORD;
+} & ((EncryptionSession & {
+    shieldEncryptionKey?: never;
+}) | {
+    /** Required shield encryption key when no encryption session is used */
+    shieldEncryptionKey: string;
+    createEncryptedSessionEndpoint?: never;
+    getEncryptionSession?: never;
+});
+/**
+ * Configuration for automatic recovery.
+ * - An encryption session is required.
+ *
+ * Configuration for password-based recovery.
+ * - An encryption session, OR
+ * - A `shieldEncryptionKey` without an encryption session.
+ *
+ * Encryption session can be created using either:
+ * - `createEncryptedSessionEndpoint` as a string, OR
+ * - `getEncryptionSession.` as a function that returns a promise.
+ */
+export type OpenfortWalletConfig = CommonWalletConfig & (AutomaticRecoveryWalletConfig | PasswordRecoveryWalletConfig);
+export type OpenfortOptions = {
+    linkWalletOnSignUp?: boolean;
+    authProviders?: AuthProvider[];
+    skipEmailVerification?: boolean;
+    termsOfServiceUrl?: string;
+    privacyPolicyUrl?: string;
+    logo?: React.ReactNode;
+    openfortUrlOverrides?: OpenfortProviderProps['overrides'];
+};
+export type ConnectKitOptions = {
+    theme?: Theme;
+    mode?: Mode;
+    customTheme?: CustomTheme;
+    hideBalance?: boolean;
+    hideTooltips?: boolean;
+    hideRecentBadge?: boolean;
+    walletConnectCTA?: 'link' | 'modal' | 'both';
+    avoidLayoutShift?: boolean;
+    embedGoogleFonts?: boolean;
+    truncateLongENSAddress?: boolean;
+    walletConnectName?: string;
+    reducedMotion?: boolean;
+    disclaimer?: ReactNode | string;
+    /** Buffer Polyfill, needed for bundlers that don't provide Node polyfills (e.g CRA, Vite, etc.) */
+    bufferPolyfill?: boolean;
+    customAvatar?: React.FC<CustomAvatarProps>;
+    initialChainId?: number;
+    enforceSupportedChains?: boolean;
+    overlayBlur?: number;
+} & OpenfortOptions;
+export type ConnectKitOptionsExtended = {
+    theme: Theme;
+    mode: Mode;
+    customTheme?: CustomTheme;
+    language?: Languages;
+    hideBalance?: boolean;
+    hideTooltips?: boolean;
+    hideQuestionMarkCTA?: boolean;
+    hideNoWalletCTA?: boolean;
+    hideRecentBadge?: boolean;
+    walletConnectCTA?: 'link' | 'modal' | 'both';
+    avoidLayoutShift?: boolean;
+    embedGoogleFonts?: boolean;
+    truncateLongENSAddress?: boolean;
+    walletConnectName?: string;
+    reducedMotion?: boolean;
+    disclaimer?: ReactNode | string;
+    bufferPolyfill?: boolean;
+    customAvatar?: React.FC<CustomAvatarProps>;
+    initialChainId?: number;
+    enforceSupportedChains?: boolean;
+    ethereumOnboardingUrl?: string;
+    walletOnboardingUrl?: string;
+    disableSiweRedirect?: boolean;
+    overlayBlur?: number;
+} & OpenfortOptions;
+export {};

package/build/components/OpenfortKit/useOpenfortKit.d.ts

@@ -0,0 +1 @@
+export declare const useOpenfortKit: () => import("./context").ContextValue;

package/build/components/Pages/About/graphics.d.ts

@@ -0,0 +1,11 @@
+import { EasingFunction } from 'framer-motion';
+export type Easing = [number, number, number, number] | 'linear' | 'easeIn' | 'easeOut' | 'easeInOut' | 'circIn' | 'circOut' | 'circInOut' | 'backIn' | 'backOut' | 'backInOut' | 'anticipate' | EasingFunction;
+type Slide = {
+    layoutId?: string;
+    duration: number;
+    ease: Easing;
+};
+export declare const SlideOne: ({ layoutId }: Slide) => import("react/jsx-runtime").JSX.Element;
+export declare const SlideTwo: ({ layoutId }: Slide) => import("react/jsx-runtime").JSX.Element;
+export declare const SlideThree: ({ layoutId }: Slide) => import("react/jsx-runtime").JSX.Element;
+export {};

package/build/components/Pages/About/index.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const About: React.FC;
+export default About;

package/build/components/Pages/About/styles.d.ts

@@ -0,0 +1,12 @@
+export declare const ImageContainer: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const ImageContainerInner: import("styled-components").StyledComponent<import("framer-motion").ForwardRefComponent<HTMLDivElement, import("framer-motion").HTMLMotionProps<"div">>, any, {}, never>;
+export declare const MobileImageContainer: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const Slides: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const Slide: import("styled-components").StyledComponent<import("framer-motion").ForwardRefComponent<HTMLDivElement, import("framer-motion").HTMLMotionProps<"div">>, any, {
+    $active?: boolean;
+}, never>;
+export declare const Slider: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const Dots: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const Dot: import("styled-components").StyledComponent<"button", any, {
+    $active: boolean;
+}, never>;

package/build/components/Pages/Connectors/index.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const Wallets: React.FC;
+export default Wallets;

package/build/components/Pages/Connectors/styles.d.ts

@@ -0,0 +1,9 @@
+export declare const InfoBox: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const InfoBoxButtons: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const LearnMoreContainer: import("styled-components").StyledComponent<import("framer-motion").ForwardRefComponent<HTMLDivElement, import("framer-motion").HTMLMotionProps<"div">>, any, {}, never>;
+export declare const LearnMoreButton: import("styled-components").StyledComponent<import("framer-motion").ForwardRefComponent<HTMLButtonElement, import("framer-motion").HTMLMotionProps<"button">>, any, {}, never>;
+export declare const ConnectorsContainer: import("styled-components").StyledComponent<import("framer-motion").ForwardRefComponent<HTMLDivElement, import("framer-motion").HTMLMotionProps<"div">>, any, {}, never>;
+export declare const ConnectorButton: import("styled-components").StyledComponent<import("framer-motion").ForwardRefComponent<HTMLButtonElement, import("framer-motion").HTMLMotionProps<"button">>, any, {}, never>;
+export declare const ConnectorRecentlyUsed: import("styled-components").StyledComponent<import("framer-motion").ForwardRefComponent<HTMLSpanElement, import("framer-motion").HTMLMotionProps<"span">>, any, {}, never>;
+export declare const ConnectorLabel: import("styled-components").StyledComponent<import("framer-motion").ForwardRefComponent<HTMLSpanElement, import("framer-motion").HTMLMotionProps<"span">>, any, {}, never>;
+export declare const ConnectorIcon: import("styled-components").StyledComponent<import("framer-motion").ForwardRefComponent<HTMLDivElement, import("framer-motion").HTMLMotionProps<"div">>, any, {}, never>;

package/build/components/Pages/DownloadApp/index.d.ts

@@ -0,0 +1,2 @@
+declare const DownloadApp: () => import("react/jsx-runtime").JSX.Element;
+export default DownloadApp;

package/build/components/Pages/EmailLogin/index.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+declare const EmailLogin: React.FC;
+export default EmailLogin;

package/build/components/Pages/EmailSignup/index.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+declare const EmailSignup: React.FC;
+export default EmailSignup;

package/build/components/Pages/EmailVerification/index.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+declare const EmailVerification: React.FC;
+export default EmailVerification;

package/build/components/Pages/ForgotPassword/index.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+declare const ForgotPassword: React.FC;
+export default ForgotPassword;

package/build/components/Pages/LinkEmail/index.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+declare const LinkEmail: React.FC;
+export default LinkEmail;

package/build/components/Pages/Loading/index.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+declare const Loading: React.FC;
+export default Loading;

package/build/components/Pages/MobileConnectors/index.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const MobileConnectors: React.FC;
+export default MobileConnectors;

package/build/components/Pages/MobileConnectors/styles.d.ts

@@ -0,0 +1,11 @@
+export declare const WalletItem: import("styled-components").StyledComponent<"div", any, {
+    $waiting?: boolean;
+}, never>;
+export declare const WalletIcon: import("styled-components").StyledComponent<"div", any, {
+    $outline?: boolean;
+}, never>;
+export declare const WalletLabel: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const WalletList: import("styled-components").StyledComponent<"div", any, {
+    $disabled?: boolean;
+}, never>;
+export declare const Container: import("styled-components").StyledComponent<"div", any, {}, never>;

package/build/components/Pages/Onboarding/index.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const Introduction: React.FC;
+export default Introduction;

package/build/components/Pages/Profile/LinkedProviders.d.ts

@@ -0,0 +1 @@
+export declare const LinkedProviders: React.FC;

package/build/components/Pages/Profile/index.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+declare const Profile: React.FC<{
+    closeModal?: () => void;
+}>;
+export default Profile;

package/build/components/Pages/Profile/styles.d.ts

@@ -0,0 +1,10 @@
+export declare const AvatarContainer: import("styled-components").StyledComponent<import("framer-motion").ForwardRefComponent<HTMLDivElement, import("framer-motion").HTMLMotionProps<"div">>, any, {}, never>;
+export declare const AvatarInner: import("styled-components").StyledComponent<import("framer-motion").ForwardRefComponent<HTMLDivElement, import("framer-motion").HTMLMotionProps<"div">>, any, {}, never>;
+export declare const ChainSelectorContainer: import("styled-components").StyledComponent<import("framer-motion").ForwardRefComponent<HTMLDivElement, import("framer-motion").HTMLMotionProps<"div">>, any, {}, never>;
+export declare const BalanceContainer: import("styled-components").StyledComponent<import("framer-motion").ForwardRefComponent<HTMLDivElement, import("framer-motion").HTMLMotionProps<"div">>, any, {}, never>;
+export declare const Balance: import("styled-components").StyledComponent<import("framer-motion").ForwardRefComponent<HTMLDivElement, import("framer-motion").HTMLMotionProps<"div">>, any, {}, never>;
+export declare const LoadingBalance: import("styled-components").StyledComponent<import("framer-motion").ForwardRefComponent<HTMLDivElement, import("framer-motion").HTMLMotionProps<"div">>, any, {}, never>;
+export declare const Unsupported: import("styled-components").StyledComponent<import("framer-motion").ForwardRefComponent<HTMLDivElement, import("framer-motion").HTMLMotionProps<"div">>, any, {}, never>;
+export declare const LinkedProviderContainer: import("styled-components").StyledComponent<import("framer-motion").ForwardRefComponent<HTMLDivElement, import("framer-motion").HTMLMotionProps<"div">>, any, {}, never>;
+export declare const LinkedProviderButton: import("styled-components").StyledComponent<import("react").FC<import("../../Common/Button/types").ButtonProps>, any, {}, never>;
+export declare const ProvidersHeader: import("styled-components").StyledComponent<import("framer-motion").ForwardRefComponent<HTMLHeadingElement, import("framer-motion").HTMLMotionProps<"h3">>, any, {}, never>;

package/build/components/Pages/Providers/index.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+import { AuthProvider } from "../../OpenfortKit/types";
+export declare const ProviderButtonSwitch: React.FC<{
+    provider: AuthProvider;
+}>;
+declare const Providers: React.FC;
+export default Providers;

package/build/components/Pages/Providers/styles.d.ts

@@ -0,0 +1,3 @@
+export declare const ProvidersButton: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const ProviderLabel: import("styled-components").StyledComponent<"span", any, {}, never>;
+export declare const ProviderIcon: import("styled-components").StyledComponent<"div", any, {}, never>;

package/build/components/Pages/Recover/index.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+declare const CreateEmbeddedSigner: React.FC;
+export default CreateEmbeddedSigner;

package/build/components/Pages/SoicalProviders/index.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+declare const SocialProviders: React.FC;
+export default SocialProviders;

package/build/components/Pages/SoicalProviders/styles.d.ts

@@ -0,0 +1,3 @@
+export declare const ProvidersButton: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const ProviderLabel: import("styled-components").StyledComponent<"span", any, {}, never>;
+export declare const ProviderIcon: import("styled-components").StyledComponent<"div", any, {}, never>;

package/build/components/Pages/SwitchNetworks/index.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const SwitchNetworks: React.FC;
+export default SwitchNetworks;

package/build/components/contexts/web3/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * This provider is responsible for handling reusable web3 logic across the app.
+ */
+import React from 'react';
+import { Address, Chain } from 'viem';
+type Web3Context = {
+    connect: {
+        getUri: (id?: string) => string;
+    };
+    dapp: {
+        chains: Chain[];
+    };
+    account?: {
+        chain: Chain;
+        chainIsSupported: boolean;
+        address: Address;
+    };
+};
+declare const Web3Context: React.Context<Web3Context>;
+export declare const Web3ContextProvider: ({ enabled, children, }: {
+    enabled?: boolean;
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const useWeb3: () => Web3Context;
+export {};

package/build/constants/chainConfigs.d.ts

@@ -0,0 +1,18 @@
+import { ReactNode } from 'react';
+type Chain = {
+    id: number;
+    name: string;
+    logo: ReactNode;
+    rpcUrls?: {
+        alchemy?: {
+            http?: string[];
+            webSocket?: string[];
+        };
+        infura?: {
+            http?: string[];
+            webSocket?: string[];
+        };
+    };
+};
+export declare const chainConfigs: Chain[];
+export {};

package/build/constants/defaultTheme.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    mobileWidth: number;
+};
+export default _default;

package/build/constants/openfort.d.ts

@@ -0,0 +1,2 @@
+export declare const embeddedWalletId = "xyz.openfort";
+export declare const emailToVerifyLocalStorageKey = "openfort:email-to-verify";

package/build/defaultConfig.d.ts

@@ -0,0 +1,14 @@
+import { type CreateConfigParameters } from '@wagmi/core';
+import { CoinbaseWalletParameters } from 'wagmi/connectors';
+export declare const getAppName: () => string;
+export declare const getAppIcon: () => string;
+type DefaultConfigProps = {
+    appName: string;
+    appIcon?: string;
+    appDescription?: string;
+    appUrl?: string;
+    walletConnectProjectId: string;
+    coinbaseWalletPreference?: CoinbaseWalletParameters<'4'>['preference'];
+} & Partial<CreateConfigParameters>;
+declare const defaultConfig: ({ appName, appIcon, appDescription, appUrl, walletConnectProjectId, coinbaseWalletPreference, chains, client, ...props }: DefaultConfigProps) => CreateConfigParameters;
+export default defaultConfig;

package/build/defaultConnectors.d.ts

@@ -0,0 +1,14 @@
+import { CreateConnectorFn } from 'wagmi';
+import { CoinbaseWalletParameters } from '@wagmi/connectors';
+type DefaultConnectorsProps = {
+    app: {
+        name: string;
+        icon?: string;
+        description?: string;
+        url?: string;
+    };
+    walletConnectProjectId?: string;
+    coinbaseWalletPreference?: CoinbaseWalletParameters<'4'>['preference'];
+};
+declare const defaultConnectors: ({ app, walletConnectProjectId, coinbaseWalletPreference, }: DefaultConnectorsProps) => CreateConnectorFn[];
+export default defaultConnectors;

package/build/defaultTransports.d.ts

@@ -0,0 +1,15 @@
+/**
+ * TODO: Automate transports based on configured chains
+ *
+ * Developers using this causes loss of granular control over a dapps transports,
+ * but for simple use cases, it's nice to have and saves a lot of boilerplate.
+ *
+ */
+import { type CreateConfigParameters } from '@wagmi/core';
+type GetDefaultTransportsProps = {
+    chains?: CreateConfigParameters['chains'];
+    alchemyId?: string;
+    infuraId?: string;
+};
+export declare const getDefaultTransports: ({ chains, alchemyId, infuraId, }: GetDefaultTransportsProps) => CreateConfigParameters["transports"];
+export {};

package/build/hooks/connectors/useWalletConnectUri.d.ts

@@ -0,0 +1,7 @@
+type Props = {
+    enabled?: boolean;
+};
+export declare function useWalletConnectUri({ enabled }?: Props): {
+    uri: string | undefined;
+};
+export {};

package/build/hooks/openfort/auth/requestEmailVerification.d.ts

@@ -0,0 +1,5 @@
+export declare const buildCallbackUrl: ({ email, callbackUrl, provider, }: {
+    email?: string;
+    callbackUrl?: string;
+    provider: string;
+}) => string;

package/build/hooks/openfort/auth/status.d.ts

@@ -0,0 +1,14 @@
+import { OpenfortKitError } from "../../../types";
+export type BaseFlowState = {
+    status: "idle" | 'awaiting-input' | 'loading' | 'success';
+    error?: never;
+} | {
+    status: 'error';
+    error: OpenfortKitError | null;
+};
+export declare const mapStatus: (status: BaseFlowState) => {
+    isLoading: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    error: OpenfortKitError | null | undefined;
+};

package/build/hooks/openfort/auth/useAuthCallback.d.ts

@@ -0,0 +1,39 @@
+import { OpenfortHookOptions, OpenfortKitError } from "../../../types";
+import { AuthProvider } from "../../../components/OpenfortKit/types";
+import { UserWallet } from "../useWallets";
+import { type AuthPlayerResponse as OpenfortUser } from '@openfort/openfort-js';
+type CallbackResult = StoreCredentialsResult | EmailVerificationResult;
+type EmailVerificationResult = {
+    type: "verifyEmail";
+    email?: string;
+    error?: OpenfortKitError;
+};
+type StoreCredentialsResult = {
+    type: "storeCredentials";
+    user?: OpenfortUser;
+    wallet?: UserWallet;
+    error?: OpenfortKitError;
+};
+type VerifyEmailOptions = {
+    email: string;
+    state: string;
+} & OpenfortHookOptions<EmailVerificationResult>;
+type StoreCredentialsOptions = {
+    player: string;
+    accessToken: string;
+    refreshToken: string;
+} & OpenfortHookOptions<StoreCredentialsResult>;
+type UseAuthCallbackOptions = {
+    automaticallyHandleCallback?: boolean;
+} & OpenfortHookOptions<CallbackResult>;
+export declare const useAuthCallback: ({ automaticallyHandleCallback, ...hookOptions }?: UseAuthCallbackOptions) => {
+    isLoading: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    error: OpenfortKitError | null | undefined;
+    email: string | null;
+    provider: AuthProvider | null;
+    verifyEmail: ({ email, state, ...options }: VerifyEmailOptions) => Promise<EmailVerificationResult>;
+    storeCredentials: ({ player, accessToken, refreshToken, ...options }: StoreCredentialsOptions) => Promise<StoreCredentialsResult>;
+};
+export {};

package/build/hooks/openfort/auth/useCreateWalletPostAuth.d.ts

@@ -0,0 +1,6 @@
+export declare const useCreateWalletPostAuth: () => {
+    tryUseWallet: () => Promise<{
+        error?: string;
+        wallet?: import("../useWallets").UserWallet;
+    }>;
+};

package/build/hooks/openfort/auth/useEmailAuth.d.ts

@@ -0,0 +1,51 @@
+import { type AuthPlayerResponse as OpenfortUser } from '@openfort/openfort-js';
+import { OpenfortHookOptions, OpenfortKitError } from "../../../types";
+import { UserWallet } from '../useWallets';
+export type EmailAuthResult = {
+    error?: OpenfortKitError;
+    user?: OpenfortUser;
+    wallet?: UserWallet;
+    requiresEmailVerification?: boolean;
+};
+export type SignInEmailOptions = {
+    email: string;
+    password: string;
+    emailVerificationRedirectTo?: string;
+} & OpenfortHookOptions<EmailAuthResult>;
+export type SignUpEmailOptions = {
+    email: string;
+    password: string;
+    name?: string;
+    emailVerificationRedirectTo?: string;
+} & OpenfortHookOptions<EmailAuthResult>;
+export type RequestResetPasswordOptions = {
+    email: string;
+    emailVerificationRedirectTo?: string;
+} & OpenfortHookOptions<EmailAuthResult>;
+export type ResetPasswordOptions = {
+    email: string;
+    password: string;
+    state: string;
+} & OpenfortHookOptions<EmailAuthResult>;
+export type LinkEmailOptions = {
+    email: string;
+    password: string;
+    emailVerificationRedirectTo?: string;
+} & OpenfortHookOptions<EmailAuthResult>;
+export type UseEmailHookOptions = {
+    emailVerificationRedirectTo?: string;
+} & OpenfortHookOptions<EmailAuthResult>;
+export declare const useEmailAuth: (hookOptions?: UseEmailHookOptions) => {
+    requiresEmailVerification: boolean;
+    isAwaitingInput: boolean;
+    isLoading: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    error: OpenfortKitError | null | undefined;
+    signInEmail: (options: SignInEmailOptions) => Promise<EmailAuthResult>;
+    signUpEmail: (options: SignUpEmailOptions) => Promise<EmailAuthResult>;
+    linkEmail: (options: LinkEmailOptions) => Promise<EmailAuthResult>;
+    requestResetPassword: (options: RequestResetPasswordOptions) => Promise<EmailAuthResult>;
+    resetPassword: (options: ResetPasswordOptions) => Promise<EmailAuthResult>;
+    reset: () => void;
+};

package/build/hooks/openfort/auth/useGuestAuth.d.ts

@@ -0,0 +1,16 @@
+import { type AuthPlayerResponse as OpenfortUser } from '@openfort/openfort-js';
+import { OpenfortHookOptions, OpenfortKitError } from "../../../types";
+import { UserWallet } from "../useWallets";
+export type GuestHookResult = {
+    error?: OpenfortKitError;
+    user?: OpenfortUser;
+    wallet?: UserWallet;
+};
+export type GuestHookOptions = OpenfortHookOptions<OpenfortUser>;
+export declare const useGuestAuth: (hookOptions?: GuestHookOptions) => {
+    isLoading: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    error: OpenfortKitError | null | undefined;
+    signUpGuest: (options?: GuestHookOptions) => Promise<GuestHookResult>;
+};

package/build/hooks/openfort/auth/useOAuth.d.ts

@@ -0,0 +1,20 @@
+import { AuthProvider } from '../../../components/OpenfortKit/types';
+import { OpenfortHookOptions, OpenfortKitError } from '../../../types';
+export type InitializeOAuthOptions = {
+    provider: AuthProvider;
+    redirectTo?: string;
+} & OpenfortHookOptions;
+export type AuthHookOptions = {
+    redirectTo?: string;
+} & OpenfortHookOptions;
+export type InitOAuthReturnType = {
+    error?: OpenfortKitError;
+};
+export declare const useOAuth: (hookOptions?: AuthHookOptions) => {
+    isLoading: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    error: OpenfortKitError | null | undefined;
+    initOAuth: (options: InitializeOAuthOptions) => Promise<InitOAuthReturnType>;
+    linkOauth: (options: InitializeOAuthOptions) => Promise<InitOAuthReturnType>;
+};

package/build/hooks/openfort/auth/useSignOut.d.ts

@@ -0,0 +1,8 @@
+import { OpenfortHookOptions, OpenfortKitError } from '../../../types';
+export declare function useSignOut(hookOptions?: OpenfortHookOptions): {
+    signOut: (options?: OpenfortHookOptions) => Promise<{} | undefined>;
+    isLoading: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    error: OpenfortKitError | null | undefined;
+};

package/build/hooks/openfort/auth/useThirdPartyAuth.d.ts

@@ -0,0 +1 @@
+export declare const useThirdPartyAuth: () => void;

package/build/hooks/openfort/auth/useWalletAuth.d.ts

@@ -0,0 +1,20 @@
+import { Connector } from "wagmi";
+import { OpenfortHookOptions, OpenfortKitError } from "../../../types";
+type ConnectWalletOptions = {
+    connector: Connector | string;
+};
+export declare const useWalletAuth: (hookOptions?: OpenfortHookOptions) => {
+    isLoading: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    error: OpenfortKitError | null | undefined;
+    walletConnectingTo: string | null;
+    connectWallet: (options: ConnectWalletOptions) => Promise<{
+        error: OpenfortKitError;
+    } | undefined>;
+    linkWallet: (options: ConnectWalletOptions) => Promise<{
+        error: OpenfortKitError;
+    } | undefined>;
+    availableWallets: import("../../../wallets/useWallets").WalletProps[];
+};
+export {};

package/build/hooks/openfort/hookConsistency.d.ts

@@ -0,0 +1,13 @@
+import { OpenfortHookOptions, OpenfortKitError } from "../../types";
+export declare const onSuccess: <T>({ hookOptions, options, data, }: {
+    hookOptions?: OpenfortHookOptions<T>;
+    options?: OpenfortHookOptions<T>;
+    data: T;
+}) => T;
+export declare const onError: <T>({ hookOptions, options, error, }: {
+    hookOptions?: OpenfortHookOptions<T>;
+    options?: OpenfortHookOptions<T>;
+    error: OpenfortKitError;
+}) => {
+    error: OpenfortKitError;
+};

package/build/hooks/openfort/useConnectWithSiwe.d.ts

@@ -0,0 +1,4 @@
+export declare function useConnectWithSiwe(): ({ onError, onConnect, }: {
+    onError?: (error: string, status?: number) => void;
+    onConnect?: () => void;
+}) => Promise<void>;