@veliseev93/clerk-react-native 0.0.1-dev.0

package/dist/index.d.mts

@@ -0,0 +1,653 @@
+import { ClerkAPIError, SignInResource, SignInStatus, SignUpResource, SignUpCreateParams, OAuthStrategy, UserResource, PhoneNumberResource, EmailAddressResource, SetActive, SignOut, UpdateUserPasswordParams } from '@clerk/types';
+
+/**
+ * Enum containing common Clerk API error codes
+ */
+declare enum ClerkApiError {
+    /** Error when a session already exists */
+    SESSION_EXISTS = "session_exists",
+    /** Error when an identifier (email/phone) already exists */
+    FORM_IDENTIFIER_EXIST = "form_identifier_exists",
+    /** Error when the verification code is incorrect */
+    FORM_CODE_INCORRECT = "form_code_incorrect"
+}
+
+type BaseSuccessReturn = {
+    isSuccess: true;
+    error?: never;
+};
+type BaseFailureReturn = {
+    isSuccess?: false;
+    error: ClerkAPIError | unknown;
+};
+type WithTokenSuccessReturn = BaseSuccessReturn & {
+    sessionToken: string;
+};
+type WithTokenFailureReturn = BaseFailureReturn & {
+    sessionToken?: null;
+};
+type WithSignInReturn = {
+    /** Provides access to SignIn object: https://clerk.com/docs/references/javascript/sign-in */
+    signIn?: SignInResource;
+    /** The current status of the sign-in. */
+    status?: SignInStatus;
+};
+type WithSignUpReturn = {
+    /** Provides access to SignUp object: https://clerk.com/docs/references/javascript/sign-up */
+    signUp?: SignUpResource;
+};
+type WithClerkReturn = WithSignInReturn & WithSignUpReturn;
+type StartSignUpReturn = (BaseSuccessReturn | BaseFailureReturn) & WithSignUpReturn;
+type StartSignInReturn = (BaseSuccessReturn | BaseFailureReturn) & WithSignInReturn;
+type StartAuthorizationReturn = (BaseSuccessReturn | BaseFailureReturn) & WithClerkReturn & {
+    isSignUp?: boolean;
+};
+type AuthorizationFinishedReturn = (WithTokenSuccessReturn | WithTokenFailureReturn) & WithClerkReturn;
+/** Type for OTP methods (email or phone) */
+type OtpMethod = 'emailAddress' | 'phoneNumber';
+/** Type for OTP strategies (email code or phone code) */
+type OtpStrategy = 'email_code' | 'phone_code';
+/** Type for extra params during SignUp process */
+type SignUpParams = Pick<SignUpCreateParams, 'firstName' | 'lastName' | 'locale' | 'unsafeMetadata' | 'username'>;
+type UseClerkResourcesReturn = WithClerkReturn & {
+    /** A function that sets the active session */
+    setActive: SetActive;
+    /** A function that signs out the current user */
+    signOut: SignOut;
+};
+/**
+ * Retrieves the session token for the currently authenticated user.
+ *
+ * @param params - Optional parameters for retrieving the session token.
+ * @param params.tokenTemplate - (Optional) Name of the token template to use.
+ *
+ * @returns A Promise resolving to:
+ * - { isSuccess: true, sessionToken: string } on success
+ * - { isSuccess: false, sessionToken: null, error } on failure
+ */
+type GetSessionTokenFn = (params: {
+    tokenTemplate?: string;
+}) => Promise<GetSessionTokenReturn>;
+interface UseGetSessionTokenReturn {
+    /** Function to retrieve the session token */
+    getSessionToken: GetSessionTokenFn;
+}
+type GetSessionTokenReturn = WithTokenSuccessReturn | WithTokenFailureReturn;
+type StartAuthorizationWithTicketReturn = (WithTokenSuccessReturn | WithTokenFailureReturn) & WithSignInReturn;
+interface UseAuthWithTicketReturn {
+    /**
+     * Initiates authentication using a one-time ticket issued by the backend.
+     *
+     * @param params - Parameters required to start the ticket-based authentication flow.
+     * @param params.ticket - A valid ticket string issued by Clerk or your backend.
+     * @param params.tokenTemplate - (Optional) The name of a token template to use when retrieving the session token.
+     *
+     * @returns A Promise that resolves to a `StartAuthorizationWithTicketReturn` object, which can be either:
+     *
+     * On success:
+     * - `isSuccess: true`
+     * - `sessionToken: string` — A valid session token string.
+     * - `signIn?: SignInResource` — (Optional) SignIn object, present if the user needs to complete additional steps.
+     *
+     * On failure:
+     * - `isSuccess: false` or undefined
+     * - `sessionToken: null`
+     * - `error: ClerkAPIError | unknown` — Details about the error occurred.
+     * - `signIn?: SignInResource` — (Optional) SignIn object if available.
+     */
+    startAuthorization: (params: {
+        ticket: string;
+        tokenTemplate?: string;
+    }) => Promise<StartAuthorizationWithTicketReturn>;
+    /** Indicates whether the authentication process with the ticket is currently in progress. `true` or `false` */
+    isLoading: boolean;
+}
+/** Parameters for SSO flow */
+interface StartSSOArgs {
+    /**
+     * The OAuth strategy to use (e.g., 'oauth_google', 'oauth_facebook', etc.).
+     * See Clerk's documentation for a full list of supported strategies: https://clerk.com/docs/references/expo/use-sso
+     */
+    strategy: OAuthStrategy;
+    /** Optional URL to redirect the user to after successful authentication. */
+    redirectUrl?: string;
+    /** Optional name of a token template to use for customizing the returned session token. */
+    tokenTemplate?: string;
+}
+/** Return type for useAuthWithSSO hook */
+interface UseAuthWithSSOReturn {
+    /**
+     * Initiates a Single Sign-On (SSO) authentication flow using the specified OAuth strategy.
+     *
+     * @param params - Parameters for initiating the SSO flow.
+     * @param params.strategy - The OAuth strategy to use (e.g., 'oauth_google', 'oauth_facebook').
+     * @param params.redirectUrl - (Optional) A URL to which the user will be redirected after the flow completes.
+     * @param params.tokenTemplate - (Optional) A token template to use when requesting a session token.
+     *
+     * @returns A Promise that resolves to an object indicating the result of the authorization:
+     * - `{ isSuccess: true, sessionToken: string, signIn?, signUp? }` on success
+     * - `{ isSuccess: false, sessionToken: null, error, signIn?, signUp? }` on failure
+     *
+     * `signIn` and `signUp` may be present depending on the outcome and stage of the flow.
+     */
+    startSSOFlow: (params: StartSSOArgs) => Promise<AuthorizationFinishedReturn>;
+    /** Indicates whether the SSO authentication flow is currently in progress. `true` or `false` */
+    isLoading: boolean;
+}
+/** Provides functionality for sending and verifying OTP (one-time password) codes using email or phone. */
+interface UseOtpVerificationReturn {
+    /**
+     * Sends a one-time password (OTP) code to the user's identifier (email or phone number),
+     * using the selected strategy.
+     *
+     * @param strategy - The delivery method for the OTP code.
+     * - `'email_code'` – send code via email
+     * - `'phone_code'` – send code via SMS
+     * @param isSignUp - Indicates whether the OTP flow is used for sign-up (true) or sign-in (false)
+     * @param isSecondFactor - (Optional) Indicates whether the OTP flow is used for a second factor verification (true) or not (false)
+     *
+     * @returns A Promise that resolves once the OTP has been successfully sent, or rejects if sending fails.
+     */
+    sendOtpCode: (params: {
+        strategy: OtpStrategy;
+        isSignUp: boolean;
+        isSecondFactor?: boolean;
+    }) => Promise<void>;
+    /**
+     * Verifies the OTP code entered by the user.
+     *
+     * @param params - Parameters required to verify the code.
+     * @param params.code - The OTP code received by the user.
+     * @param params.strategy - The strategy used to send the code (`'email_code'` or `'phone_code'`).
+     * @param params.tokenTemplate - (Optional) The name of the token template to use when retrieving the session token.
+     * @param isSignUp - Indicates whether the OTP flow is used for sign-up (true) or sign-in (false)
+     * @param isSecondFactor - (Optional) Indicates whether the OTP flow is used for a second factor verification (true) or not (false)
+     *
+     * @returns A Promise that resolves to:
+     * - `{ isSuccess: true, sessionToken: string, signIn?, signUp? }` on success
+     * - `{ isSuccess: false, sessionToken: null, error, signIn?, signUp? }` on failure
+     */
+    verifyCode: (params: {
+        code: string;
+        strategy: OtpStrategy;
+        isSignUp: boolean;
+        tokenTemplate?: string;
+        isSecondFactor?: boolean;
+    }) => Promise<AuthorizationFinishedReturn>;
+    /** Indicates whether the OTP verification process is currently in progress. `true` or `false` */
+    isVerifying: boolean;
+}
+type IdentifierType = 'email' | 'phone';
+/**
+ * Return type for a hook that manages adding a new authentication identifier
+ * (such as an email address or phone number) to the currently signed-in user's account.
+ */
+interface UseAddIdentifierReturn {
+    /**
+     * Sends a request to create and link a new identifier (email or phone) to the current user.
+     *
+     * This triggers a verification flow (e.g., a code sent via email or SMS) and returns
+     * a result indicating success or failure. On success, the identifier is pending verification.
+     *
+     * @param params - Parameters for identifier creation.
+     * @param params.identifier - The new identifier to be added (e.g., email or phone number).
+     *
+     * @returns A Promise resolving to a result object:
+     * - On success: `BaseSuccessReturn` with optional `user`.
+     * - On failure: `BaseFailureReturn` with optional `user`.
+     */
+    createIdentifier: (params: {
+        identifier: string;
+    }) => Promise<(BaseSuccessReturn | BaseFailureReturn) & {
+        user?: UserResource | null;
+    }>;
+    /**
+     * Verifies the code sent to the newly added identifier.
+     *
+     * @param params - Parameters for verification.
+     * @param params.code - The one-time code sent to the identifier.
+     *
+     * @returns A Promise resolving to a result object:
+     * - On success: `BaseSuccessReturn` with optional `user`.
+     * - On failure: `BaseFailureReturn` with optional `verifyAttempt` (email or phone resource) and `user`.
+     */
+    verifyCode: (params: {
+        code: string;
+        identifier: string;
+    }) => Promise<(BaseSuccessReturn | (BaseFailureReturn & {
+        verifyAttempt?: PhoneNumberResource | EmailAddressResource;
+    })) & {
+        user?: UserResource | null;
+    }>;
+    /** Indicates whether an identifier is currently being added via `createIdentifier`. `true` or `false` */
+    isCreating: boolean;
+    /** Indicates whether a verification request is currently being processed via `verifyCode`. `true` or `false` */
+    isVerifying: boolean;
+}
+/**
+ * Return type for a hook that manages updating a new authentication identifier
+ * (such as an email address or phone number) to the currently signed-in user's account.
+ */
+interface UseUpdateIdentifierReturn extends Omit<UseAddIdentifierReturn, 'verifyCode'> {
+    /**
+     * Verifies the code and select the provided identifier as primary.
+     *
+     * @param params - Parameters for verification.
+     * @param params.code - The one-time code sent to the identifier.
+     * @param params.identifier - The one-time code sent to the identifier.
+     *
+     * @returns A Promise resolving to a result object:
+     * - On success: `BaseSuccessReturn` with optional `user`.
+     * - On failure: `BaseFailureReturn` with optional `verifyAttempt` (email or phone resource) and `user`.
+     */
+    verifyCode: (params: {
+        code: string;
+        identifier: string;
+    }) => Promise<(BaseSuccessReturn | (BaseFailureReturn & {
+        verifyAttempt?: PhoneNumberResource | EmailAddressResource;
+    })) & {
+        user?: UserResource | null;
+    }>;
+    /** Indicates whether a update identifier request is currently being processed. `true` or `false` */
+    isUpdating: boolean;
+}
+/** Type for authentication identifier methods */
+type AuthIdentifierMethod = 'emailAddress' | 'phoneNumber' | 'username';
+/** Type for authentication verification methods */
+type AuthIdentifierVerifyBy = 'otp' | 'password';
+/**
+ * Maps verification method to the allowed identifier methods.
+ *
+ * - For `'otp'`, only email and phone are allowed.
+ * - For `'password'`, all methods are allowed.
+ */
+type IdentifierMethodFor<VerifyBy extends AuthIdentifierVerifyBy> = VerifyBy extends 'otp' ? Exclude<AuthIdentifierMethod, 'username'> : AuthIdentifierMethod;
+/**
+ * Parameters for starting an authentication flow, based on the selected verification method.
+ *
+ * - For `'otp'`: requires only an identifier (email or phone).
+ * - For `'password'`: requires identifier and password, and optionally a token template.
+ */
+type StartAuthParams<VerifyBy extends AuthIdentifierVerifyBy> = VerifyBy extends 'otp' ? {
+    /** Identifier (email address or phone number). */
+    identifier: string;
+} : {
+    /** Identifier (email address, phone number, or username). */
+    identifier: string;
+    /** User's password. */
+    password: string;
+    /** Optional name of a token template for customizing the session token. */
+    tokenTemplate?: string;
+};
+/**
+ * Return type for starting a sign-in flow.
+ *
+ * - For `'password'`: may include a `sessionToken`.
+ * - For `'otp'`: standard return type.
+ */
+type StartSignInWithIdentifierReturn<VerifyBy extends AuthIdentifierVerifyBy> = VerifyBy extends 'password' ? StartSignInReturn & {
+    /** Optional session token returned upon successful password sign-in. */
+    sessionToken?: string;
+} : StartSignInReturn;
+/**
+ * Return type for starting a sign-up flow.
+ *
+ * - For `'username'`: may include a `sessionToken`.
+ * - For others: standard return type.
+ */
+type StartSignUpWithIdentifierReturn<Method extends AuthIdentifierMethod> = Method extends 'username' ? StartSignUpReturn & {
+    /** Optional session token returned upon successful username sign-up. */
+    sessionToken?: string;
+} : StartSignUpReturn;
+/**
+ * Return type for starting a generic authorization (sign-up or sign-in).
+ *
+ * - For `'username'`: may include a `sessionToken`.
+ * - For others: standard return type.
+ */
+type StartAuthorizationWithIdentifierReturn<Method extends AuthIdentifierMethod> = Method extends 'username' ? StartAuthorizationReturn & {
+    /** Optional session token returned upon successful username authorization. */
+    sessionToken?: string;
+} : StartAuthorizationReturn;
+type StartSignUpParams<VerifyBy extends AuthIdentifierVerifyBy> = StartAuthParams<VerifyBy> & SignUpParams;
+/**
+ * Base return type for useAuthWithIdentifier hook.
+ *
+ * Provides common methods and status flags for both verification methods (`otp`, `password`).
+ */
+interface BaseUseAuthWithIdentifierReturn<VerifyBy extends AuthIdentifierVerifyBy> {
+    /**
+     * Initiates the sign-in flow using the provided identifier and verification method.
+     *
+     * @param params - Authentication parameters depending on `VerifyBy` type.
+     * @returns A Promise resolving to a result of sign-in attempt.
+     *
+     * @example
+     * // Example for email + password
+     * await startSignIn({
+     *  identifier: 'user@example.com',
+     *  password: 'securePassword123'
+     * });
+     *
+     * @example
+     * // Example for phone + OTP
+     * await startSignIn({
+     *  identifier: '+1234567890'
+     * });
+     */
+    startSignIn: (params: StartAuthParams<VerifyBy>) => Promise<StartSignInWithIdentifierReturn<VerifyBy>>;
+    /**
+     * Initiates the sign-up flow using the provided identifier and verification method.
+     *
+     * @param params - Authentication parameters depending on `VerifyBy` type.
+     * @returns A Promise resolving to a result of sign-up attempt.
+     *
+     * @example
+     * // Example 1: Sign up with email + OTP
+     * await startSignUp({
+     *  identifier: 'user@example.com',
+     * });
+     *
+     * @example
+     * // Example 2: Sign up with phone + OTP
+     * await startSignUp({
+     *  identifier: '+1234567890',
+     * });
+     *
+     * @example
+     * // Example 3: Sign up with username + password
+     * await startSignUp({
+     *  identifier: 'username',
+     *  password: 'password!'
+     * });
+     *
+     * @example
+     * // Example 4: Sign up with email + password + custom token template
+     * await startSignUp({
+     *  identifier: 'user@example.com',
+     *  password: 'password',
+     *  tokenTemplate: 'my_template'
+     * });
+     */
+    startSignUp: (params: StartSignUpParams<VerifyBy>) => Promise<StartSignUpWithIdentifierReturn<any>>;
+    /**
+     * Initiates a combined authorization flow (sign-up or sign-in) based on user existence.
+     *
+     * @param params - Authentication parameters depending on `VerifyBy` type.
+     * @returns A Promise resolving to a result of the authorization flow.
+     *
+     * @example
+     * // Example 1: Authorize with email + OTP (sign-in or sign-up automatically)
+     * await startAuthorization({
+     *  identifier: 'user@example.com',
+     * });
+     *
+     * @example
+     * // Example 2: Authorize with phone + OTP
+     * await startAuthorization({
+     *  identifier: '+1234567890',
+     * });
+     *
+     * @example
+     * // Example 3: Authorize with username + password
+     * await startAuthorization({
+     *  identifier: 'username',
+     *  password: 'password'
+     * });
+     *
+     * @example
+     * // Example 4: Authorize with email + password + token template
+     * await startAuthorization({
+     *  identifier: 'user@example.com',
+     *  password: 'password',
+     *  tokenTemplate: 'my_template'
+     * });
+     */
+    startAuthorization: (params: StartAuthParams<VerifyBy>) => Promise<StartAuthorizationWithIdentifierReturn<any>>;
+    /** Indicates whether an authentication request is currently being processed. `true` or `false` */
+    isLoading: boolean;
+}
+/**
+ * Conditional return type for `useAuthWithIdentifier` depending on identifier method.
+ *
+ * - Adds OTP-specific fields (`verifyCode`, `isVerifying`) for `emailAddress` and `phoneNumber`.
+ * - These fields are omitted for `username`.
+ */
+type ConditionalUseAuthWithIdentifierReturn<VerifyBy extends AuthIdentifierVerifyBy, Method extends AuthIdentifierMethod> = Method extends 'username' ? BaseUseAuthWithIdentifierReturn<VerifyBy> : BaseUseAuthWithIdentifierReturn<VerifyBy> & {
+    /**
+     * Verifies the OTP code sent to the user.
+     *
+     * Only available when using `emailAddress` or `phoneNumber`.
+     *
+     * @param params.code - The one-time code entered by the user.
+     * @param params.isSignUp - Whether the flow is sign-up (true) or sign-in (false).
+     * @param params.tokenTemplate - (Optional) Token template to customize the session.
+     * @returns A Promise resolving to the final result of the authorization flow.
+     */
+    verifyCode: (params: {
+        code: string;
+        isSignUp: boolean;
+        tokenTemplate?: string;
+    }) => Promise<AuthorizationFinishedReturn>;
+    /** Indicates whether OTP verification is currently in progress. `true` or `false` */
+    isVerifying: boolean;
+};
+/**
+ * Final return type of `useAuthWithIdentifier` hook.
+ *
+ * - Includes all sign-in, sign-up, and authorization methods.
+ * - May include `verifyCode` and `isVerifying` if applicable.
+ *
+ * @template VerifyBy - Verification method used (`otp` or `password`)
+ * @template Method - Identifier method used (`emailAddress`, `phoneNumber`, `username`)
+ */
+type UseAuthWithIdentifierReturn<VerifyBy extends AuthIdentifierVerifyBy, Method extends AuthIdentifierMethod> = ConditionalUseAuthWithIdentifierReturn<VerifyBy, Method>;
+/** Return type for a hook that manages the password reset process. */
+interface UseResetPasswordReturn {
+    /**
+     * Initiates the password reset process for the given identifier.
+     *
+     * This sends a verification code (e.g., via email or SMS) to the provided identifier.
+     *
+     * @param params - Parameters required to start the password reset process.
+     * @param params.identifier - The user's identifier (email address or phone number).
+     *
+     * @returns A Promise resolving to a result object:
+     * - On success: `BaseSuccessReturn` with sign-in context via `WithSignInReturn`.
+     * - On failure: `BaseFailureReturn` with possible error information.
+     */
+    startResetPassword: (params: {
+        identifier: string;
+    }) => Promise<(BaseSuccessReturn | BaseFailureReturn) & WithSignInReturn>;
+    /**
+     * Verifies the code sent to the newly added identifier.
+     *
+     * @param params - Parameters for verification.
+     * @param params.code - The one-time code sent to the identifier.
+     *
+     * @returns A Promise resolving to a result object:
+     * - On success: `BaseSuccessReturn` with optional `user`.
+     * - On failure: `BaseFailureReturn` with optional `verifyAttempt` (email or phone resource) and `user`.
+     */
+    verifyCode: (params: {
+        code: string;
+    }) => Promise<BaseSuccessReturn | (BaseFailureReturn & {
+        verifyAttempt?: PhoneNumberResource | EmailAddressResource;
+    })>;
+    /**
+     * Completes the password reset process using the provided verification code and new password.
+     *
+     * @param params - Parameters required to reset the password.
+     * @param params.password - The new password to be set.
+     * @param params.tokenTemplate - (Optional) A token template name to use when creating the session token.
+     *
+     * @returns A Promise resolving to an `AuthorizationFinishedReturn`, which includes:
+     * - `isSuccess`: Indicates whether the password reset was successful.
+     * - `sessionToken`: A session token if authentication is completed.
+     */
+    resetPassword: (params: {
+        password: string;
+        tokenTemplate?: string;
+    }) => Promise<StartSignInReturn & {
+        sessionToken?: string;
+    }>;
+    /** Indicates whether the password reset operation is currently in progress. `true` or `false` */
+    isResetting: boolean;
+    /** Indicates whether the code for password reset is currently being sent. `true` or `false` */
+    isCodeSending: boolean;
+    /** Indicates whether a verification request is currently being processed via `verifyCode`. `true` or `false` */
+    isVerifying: boolean;
+}
+interface UseUpdatePasswordReturn {
+    /**
+     * Initiates the password reset process for the given identifier.
+     *
+     * @returns A Promise resolving to a result object:
+     * - On success: `BaseSuccessReturn` with sign-in context via `WithSignInReturn`.
+     * - On failure: `BaseFailureReturn` with possible error information.
+     */
+    updatePassword: (params: UpdateUserPasswordParams) => Promise<BaseSuccessReturn | BaseFailureReturn>;
+    /** Indicates whether the code for password reset is currently being sent. `true` or `false` */
+    isPasswordUpdating: boolean;
+}
+
+/**
+ * Hook that provides access to essential Clerk methods and objects.
+ *
+ * @returns {UseClerkResourcesReturn} Object containing Clerk resources:
+ * - `signUp` - Provides access to SignUp object: https://clerk.com/docs/references/javascript/sign-up
+ * - `signIn` - Provides access to SignIn object: https://clerk.com/docs/references/javascript/sign-in
+ * - `setActive` - A function that sets the active session
+ * - `signOut` - A function that signs out the current user
+ */
+declare const useClerkResources: () => UseClerkResourcesReturn;
+
+/**
+ * Hook that provides functionality for getting session tokens.
+ *
+ * @returns {UseGetSessionTokenReturn} Object containing:
+ * - `getSessionToken` - A function to retrieve the session token. It takes an optional tokenTemplate parameter to specify a template for the token
+ */
+declare const useGetSessionToken: () => UseGetSessionTokenReturn;
+
+/**
+ * Hook that provides functionality to handle SSO authentication flows.
+ *
+ * @returns {UseAuthWithSSOReturn} Object containing:
+ * - `startSSOFlow` - A function to initiate an SSO flow. It takes a strategy, redirectUrl, and optional tokenTemplate as parameters, starting the SSO authentication and returning session information or errors upon completion
+ * - `isLoading` - A boolean indicating whether an SSO process is currently ongoing
+ */
+declare function useAuthWithSSO(): UseAuthWithSSOReturn;
+
+/**
+ * Hook that facilitates user authentication using a ticket-based strategy (ticket is a token generated from the Backend API).
+ *
+ * @returns {UseAuthWithTicketReturn} Object containing:
+ * - `startAuthorization` - A function to initiate authentication with a ticket. It accepts an object with ticket and optional tokenTemplate parameters to kick off the authorization process and returns the session details
+ * - `isLoading` - A boolean indicating whether the ticket-based authorization process is ongoing
+ */
+declare function useAuthWithTicket(): UseAuthWithTicketReturn;
+
+/**
+ * Hook that provides functionality for managing OTP (One Time Password) verification in user authentication workflows, supporting both sign-up and sign-in processes.
+ *
+ * @returns {UseOtpVerificationReturn} Object containing:
+ * - `sendOtpCode` - Sends an OTP code to the user's identifier (email or phone number) based on the specified strategy
+ * - `verifyCode` - Verifies the OTP code provided by the user, completing the authentication process
+ * - `isVerifying` - A boolean indicating whether a verification attempt is currently in progress
+ */
+declare function useOtpVerification(): UseOtpVerificationReturn;
+
+/**
+ * Hook that provides functionality to handle user sign-up and sign-in processes using an identifier such as an email, phone number, or username. It supports both OTP (One Time Password) and password-based authentication methods.
+ *
+ * @template {AuthIdentifierVerifyBy} TVerifyBy - The verification method type
+ * @template {IdentifierMethodFor<TVerifyBy>} TMethod - The identifier method type
+ * @param {TMethod} method - Specifies the type of identifier used for authentication (e.g., 'emailAddress', 'phoneNumber', 'username')
+ * @param {TVerifyBy} verifyBy - Specifies the verification method ('otp' for one-time passwords or 'password')
+ *
+ * @returns {UseAuthWithIdentifierReturn<TVerifyBy, TMethod>} Object containing:
+ * - `startSignUp` - Initiates a new user registration using the specified identifier and verification method
+ * - `startSignIn` - Initiates authentication of an existing user using the specified identifier and verification method
+ * - `startAuthorization` - Determines whether to initiate a sign-up or sign-in based on whether the user has been registered previously
+ * - `verifyCode` - Verifies an OTP code if the verification method is 'otp' (only available for non-username methods)
+ * - `isLoading` - Indicates whether an authentication request is in progress
+ * - `isVerifying` - Indicates whether an OTP verification is in progress (only available for non-username methods)
+ */
+declare function useAuthWithIdentifier<TVerifyBy extends AuthIdentifierVerifyBy, TMethod extends IdentifierMethodFor<TVerifyBy>>(method: TMethod, verifyBy: TVerifyBy): UseAuthWithIdentifierReturn<TVerifyBy, TMethod>;
+
+/**
+ * Hook that provides functionality to add new email or phone number identifiers to a user's account and verify them using verification codes.
+ *
+ * @param {IdentifierType} type - Specifies the type of identifier (e.g., 'phone', 'email')
+ *
+ * @returns {UseAddIdentifierReturn} Object containing:
+ * - `createIdentifier` - A function to add a new email or phone number identifier to the user's account and prepare it for verification
+ * - `verifyCode` - A function to verify a code sent to the identifier, completing the verification process
+ * - `isCreating` - A boolean indicating whether an identifier is currently being added
+ * - `isVerifying` - A boolean indicating whether a verification code is currently being processed
+ */
+declare function useAddIdentifier(type: IdentifierType): UseAddIdentifierReturn;
+
+/**
+ * Hook that provides methods to handle password reset functionality through email or phone-based OTP.
+ *
+ * @param {Object} params - Parameters for the hook
+ * @param {OtpMethod} params.method - The method to use for OTP (emailAddress or phoneNumber)
+ *
+ * @returns {UseResetPasswordReturn} Object containing:
+ * - `startResetPassword` - A function to initiate the password reset process by sending a verification code to the user's email or phone number
+ * - `resetPassword` - A function to reset the user's password and setting a new password
+ * - `verifyCode` - A function to verify a code sent to the identifier, completing the verification process
+ * - `isCodeSending` - A boolean indicating if the verification code is being sent
+ * - `isResetting` - A boolean indicating if the password is being reset
+ * - `isVerifying` - A boolean indicating whether a verification code is currently being processed
+ */
+declare function useResetPassword({ method }: {
+    method: OtpMethod;
+}): UseResetPasswordReturn;
+
+/**
+ * Hook that provides functionality to update the current user's password.
+ *
+ * Requires the user to supply both the current password (for verification) and
+ * the new password. On success, the user's password is updated in Clerk; on
+ * failure, the hook returns an error without throwing.
+ *
+ * @returns {UseUpdatePasswordReturn} Object containing:
+ * - `updatePassword` — Updates the user's password using current and new password
+ * - `isPasswordUpdating` — Indicates whether a password update is currently in progress
+ */
+declare const useChangePassword: () => UseUpdatePasswordReturn;
+
+/**
+ * Hook that provides functionality to update an existing primary identifier
+ * (email address or phone number) for the current user.
+ *
+ * This hook is a higher-level abstraction built on top of `useAddIdentifier`.
+ * It reuses the identifier creation and verification flow, but extends it with
+ * additional logic that, upon successful verification, automatically:
+ *
+ * - Sets the newly verified identifier as the primary one
+ * - Removes the previously primary identifier (if different)
+ *
+ * The update process follows these stages:
+ * 1. `createIdentifier` — adds a new identifier and initiates its verification flow
+ * 2. `verifyCode` — verifies the received code and, if successful, updates the
+ *    user's primary identifier
+ *
+ * All basic method signatures and return types are inherited from `useAddIdentifier`, ensuring full compatibility
+ *
+ * @param {IdentifierType} type - Specifies the type of identifier (e.g., 'phone', 'email')
+ *
+ * @returns {UseUpdateIdentifierReturn} Object containing:
+ * - `createIdentifier` — Adds a new email or phone identifier and prepares it for verification
+ * - `verifyCode` — Verifies the code sent to the identifier and, on success,
+ *   updates the user's primary identifier
+ * - `isCreating` — Indicates whether an identifier is currently being added
+ * - `isVerifying` — Indicates whether a verification request is currently being processed
+ * - `isUpdating` — Indicates whether the primary identifier update is currently in progress
+ */
+declare function useUpdateIdentifier(type: IdentifierType): UseUpdateIdentifierReturn;
+
+export { type AuthIdentifierMethod, type AuthIdentifierVerifyBy, type AuthorizationFinishedReturn, ClerkApiError, type GetSessionTokenFn, type GetSessionTokenReturn, type IdentifierMethodFor, type IdentifierType, type OtpMethod, type OtpStrategy, type SignUpParams, type StartAuthParams, type StartAuthorizationWithIdentifierReturn, type StartAuthorizationWithTicketReturn, type StartSSOArgs, type StartSignInWithIdentifierReturn, type StartSignUpParams, type StartSignUpWithIdentifierReturn, type UseAddIdentifierReturn, type UseAuthWithIdentifierReturn, type UseAuthWithSSOReturn, type UseAuthWithTicketReturn, type UseClerkResourcesReturn, type UseGetSessionTokenReturn, type UseOtpVerificationReturn, type UseResetPasswordReturn, type UseUpdateIdentifierReturn, type UseUpdatePasswordReturn, useAddIdentifier, useAuthWithIdentifier, useAuthWithSSO, useAuthWithTicket, useChangePassword, useClerkResources, useGetSessionToken, useOtpVerification, useResetPassword, useUpdateIdentifier };