@versini/auth0-react-thin 2.19.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Auth0
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,185 @@
+![Auth0 SDK for React Single Page Applications](https://cdn.auth0.com/website/sdks/banners/auth0-react-banner.png)
+
+[![npm](https://img.shields.io/npm/v/@auth0/auth0-react.svg?style=flat)](https://www.npmjs.com/package/@auth0/auth0-react)
+[![codecov](https://img.shields.io/codecov/c/github/auth0/auth0-react/main.svg?style=flat)](https://codecov.io/gh/auth0/auth0-react)
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/auth0/auth0-react)
+![Downloads](https://img.shields.io/npm/dw/@auth0/auth0-react)
+[![License](https://img.shields.io/:license-mit-blue.svg?style=flat)](https://opensource.org/licenses/MIT)
+[![CircleCI](https://img.shields.io/circleci/build/github/auth0/auth0-react.svg?branch=main&style=flat)](https://circleci.com/gh/auth0/auth0-react)
+
+📚 [Documentation](#documentation) - 🚀 [Getting Started](#getting-started) - 💻 [API Reference](#api-reference) - 💬 [Feedback](#feedback)
+
+## Documentation
+
+- [Quickstart](https://auth0.com/docs/quickstart/spa/react) - our interactive guide for quickly adding login, logout and user information to a React app using Auth0.
+- [Sample App](https://github.com/auth0-samples/auth0-react-samples/tree/master/Sample-01) - a full-fledged React application integrated with Auth0.
+- [FAQs](https://github.com/auth0/auth0-react/blob/main/FAQ.md) - frequently asked questions about the auth0-react SDK.
+- [Examples](https://github.com/auth0/auth0-react/blob/main/EXAMPLES.md) - code samples for common React authentication scenario's.
+- [Docs site](https://www.auth0.com/docs) - explore our docs site and learn more about Auth0.
+
+## Getting started
+
+### Installation
+
+Using [npm](https://npmjs.org/)
+
+```bash
+npm install @auth0/auth0-react
+```
+
+Using [yarn](https://yarnpkg.com/)
+
+```bash
+yarn add @auth0/auth0-react
+```
+
+### Configure Auth0
+
+Create a **Single Page Application** in the [Auth0 Dashboard](https://manage.auth0.com/#/applications).
+
+> **If you're using an existing application**, verify that you have configured the following settings in your Single Page Application:
+>
+> - Click on the "Settings" tab of your application's page.
+> - Scroll down and click on the "Show Advanced Settings" link.
+> - Under "Advanced Settings", click on the "OAuth" tab.
+> - Ensure that "JsonWebToken Signature Algorithm" is set to `RS256` and that "OIDC Conformant" is enabled.
+
+Next, configure the following URLs for your application under the "Application URIs" section of the "Settings" page:
+
+- **Allowed Callback URLs**: `http://localhost:3000`
+- **Allowed Logout URLs**: `http://localhost:3000`
+- **Allowed Web Origins**: `http://localhost:3000`
+
+> These URLs should reflect the origins that your application is running on. **Allowed Callback URLs** may also include a path, depending on where you're handling the callback.
+
+Take note of the **Client ID** and **Domain** values under the "Basic Information" section. You'll need these values in the next step.
+
+### Configure the SDK
+
+Configure the SDK by wrapping your application in `Auth0Provider`:
+
+```jsx
+// src/index.js
+import React from 'react';
+import { createRoot } from 'react-dom/client';
+import { Auth0Provider } from '@auth0/auth0-react';
+import App from './App';
+
+const root = createRoot(document.getElementById('app'));
+
+root.render(
+  <Auth0Provider
+    domain="YOUR_AUTH0_DOMAIN"
+    clientId="YOUR_AUTH0_CLIENT_ID"
+    authorizationParams={{
+      redirect_uri: window.location.origin,
+    }}
+  >
+    <App />
+  </Auth0Provider>
+);
+```
+
+<details>
+<summary>Instructions for React <18</summary>
+<br>
+
+```jsx
+// src/index.js
+import React from 'react';
+import ReactDOM from 'react-dom';
+import { Auth0Provider } from '@auth0/auth0-react';
+import App from './App';
+
+ReactDOM.render(
+  <Auth0Provider
+    domain="YOUR_AUTH0_DOMAIN"
+    clientId="YOUR_AUTH0_CLIENT_ID"
+    authorizationParams={{
+      redirect_uri: window.location.origin,
+    }}
+  >
+    <App />
+  </Auth0Provider>,
+  document.getElementById('app')
+);
+```
+</details>
+
+Use the `useAuth0` hook in your components to access authentication state (`isLoading`, `isAuthenticated` and `user`) and authentication methods (`loginWithRedirect` and `logout`):
+
+```jsx
+// src/App.js
+import React from 'react';
+import { useAuth0 } from '@auth0/auth0-react';
+
+function App() {
+  const { isLoading, isAuthenticated, error, user, loginWithRedirect, logout } =
+    useAuth0();
+
+  if (isLoading) {
+    return <div>Loading...</div>;
+  }
+  if (error) {
+    return <div>Oops... {error.message}</div>;
+  }
+
+  if (isAuthenticated) {
+    return (
+      <div>
+        Hello {user.name}{' '}
+        <button onClick={() => logout({ logoutParams: { returnTo: window.location.origin } })}>
+          Log out
+        </button>
+      </div>
+    );
+  } else {
+    return <button onClick={() => loginWithRedirect()}>Log in</button>;
+  }
+}
+
+export default App;
+```
+
+For more code samples on how to integrate **auth0-react** SDK in your **React** application, have a look at our [examples](https://github.com/auth0/auth0-react/blob/main/EXAMPLES.md).
+
+## API reference
+
+Explore public API's available in auth0-react.
+
+- [Auth0Provider](https://auth0.github.io/auth0-react/functions/Auth0Provider.html)
+- [Auth0ProviderOptions](https://auth0.github.io/auth0-react/interfaces/Auth0ProviderOptions.html)
+- [useAuth0](https://auth0.github.io/auth0-react/functions/useAuth0.html)
+- [withAuth0](https://auth0.github.io/auth0-react/functions/withAuth0.html)
+- [withAuthenticationRequired](https://auth0.github.io/auth0-react/functions/withAuthenticationRequired.html)
+
+## Feedback
+
+### Contributing
+
+We appreciate feedback and contribution to this repo! Before you get started, please see the following:
+
+- [Auth0's general contribution guidelines](https://github.com/auth0/open-source-template/blob/master/GENERAL-CONTRIBUTING.md)
+- [Auth0's code of conduct guidelines](https://github.com/auth0/open-source-template/blob/master/CODE-OF-CONDUCT.md)
+- [This repo's contribution guide](https://github.com/auth0/auth0-react/blob/main/CONTRIBUTING.md)
+
+### Raise an issue
+
+To provide feedback or report a bug, please [raise an issue on our issue tracker](https://github.com/auth0/auth0-react/issues).
+
+### Vulnerability Reporting
+
+Please do not report security vulnerabilities on the public GitHub issue tracker. The [Responsible Disclosure Program](https://auth0.com/responsible-disclosure-policy) details the procedure for disclosing security issues.
+
+---
+
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: light)" srcset="https://cdn.auth0.com/website/sdks/logos/auth0_light_mode.png"   width="150">
+    <source media="(prefers-color-scheme: dark)" srcset="https://cdn.auth0.com/website/sdks/logos/auth0_dark_mode.png" width="150">
+    <img alt="Auth0 Logo" src="https://cdn.auth0.com/website/sdks/logos/auth0_light_mode.png" width="150">
+  </picture>
+</p>
+<p align="center">Auth0 is an easy to implement, adaptable authentication and authorization platform. To learn more checkout <a href="https://auth0.com/why-auth0">Why Auth0?</a></p>
+<p align="center">
+This project is licensed under the MIT license. See the <a href="https://github.com/auth0/auth0-react/blob/main/LICENSE"> LICENSE</a> file for more info.</p>

package/dist/auth-state.d.ts

@@ -0,0 +1,15 @@
+import { User } from '@auth0/auth0-spa-js';
+/**
+ * The auth state which, when combined with the auth methods, make up the return object of the `useAuth0` hook.
+ */
+export interface AuthState<TUser extends User = User> {
+    error: Error | undefined;
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    user: TUser | undefined;
+}
+/**
+ * The initial auth state.
+ */
+export declare const initialAuthState: AuthState;
+//# sourceMappingURL=auth-state.d.ts.map

package/dist/auth-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-state.d.ts","sourceRoot":"","sources":["../src/auth-state.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAE3C;;GAEG;AACH,MAAM,WAAW,SAAS,CAAC,KAAK,SAAS,IAAI,GAAG,IAAI;IAClD,KAAK,EAAE,KAAK,GAAG,SAAS,CAAC;IACzB,eAAe,EAAE,OAAO,CAAC;IACzB,SAAS,EAAE,OAAO,CAAC;IACnB,IAAI,EAAE,KAAK,GAAG,SAAS,CAAC;CACzB;AAED;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,SAK9B,CAAC"}

package/dist/auth0-context.d.ts

@@ -0,0 +1,423 @@
+import { GetTokenSilentlyOptions, GetTokenWithPopupOptions, IdToken, LogoutOptions as SPALogoutOptions, PopupLoginOptions, PopupConfigOptions, RedirectLoginResult, User, GetTokenSilentlyVerboseResponse, RedirectLoginOptions as SPARedirectLoginOptions, type Auth0Client, RedirectConnectAccountOptions, ConnectAccountRedirectResult, CustomTokenExchangeOptions, TokenEndpointResponse, type MfaApiClient, type PasskeyApiClient, type MyAccountApiClient } from '@auth0/auth0-spa-js';
+import { AuthState } from './auth-state';
+import { AppState } from './auth0-provider';
+export interface LogoutOptions extends Omit<SPALogoutOptions, 'onRedirect'> {
+}
+export interface RedirectLoginOptions<TAppState = AppState> extends Omit<SPARedirectLoginOptions<TAppState>, 'onRedirect'> {
+}
+/**
+ * Contains the authenticated state and authentication methods provided by the `useAuth0` hook.
+ */
+export interface Auth0ContextInterface<TUser extends User = User> extends AuthState<TUser> {
+    /**
+     * ```js
+     * const token = await getAccessTokenSilently(options);
+     * ```
+     *
+     * If there's a valid token stored, return it. Otherwise, opens an
+     * iframe with the `/authorize` URL using the parameters provided
+     * as arguments. Random and secure `state` and `nonce` parameters
+     * will be auto-generated. If the response is successful, results
+     * will be valid according to their expiration times.
+     *
+     * If refresh tokens are used, the token endpoint is called directly with the
+     * 'refresh_token' grant. If no refresh token is available to make this call,
+     * the SDK will only fall back to using an iframe to the '/authorize' URL if
+     * the `useRefreshTokensFallback` setting has been set to `true`. By default this
+     * setting is `false`.
+     *
+     * This method may use a web worker to perform the token call if the in-memory
+     * cache is used.
+     *
+     * If an `audience` value is given to this function, the SDK always falls
+     * back to using an iframe to make the token exchange.
+     *
+     * Note that in all cases, falling back to an iframe requires access to
+     * the `auth0` cookie.
+     */
+    getAccessTokenSilently: {
+        (options: GetTokenSilentlyOptions & {
+            detailedResponse: true;
+        }): Promise<GetTokenSilentlyVerboseResponse>;
+        (options?: GetTokenSilentlyOptions): Promise<string>;
+        (options: GetTokenSilentlyOptions): Promise<GetTokenSilentlyVerboseResponse | string>;
+    };
+    /**
+     * ```js
+     * const token = await getTokenWithPopup(options, config);
+     * ```
+     *
+     * Get an access token interactively.
+     *
+     * Opens a popup with the `/authorize` URL using the parameters
+     * provided as arguments. Random and secure `state` and `nonce`
+     * parameters will be auto-generated. If the response is successful,
+     * results will be valid according to their expiration times.
+     */
+    getAccessTokenWithPopup: (options?: GetTokenWithPopupOptions, config?: PopupConfigOptions) => Promise<string | undefined>;
+    /**
+     * ```js
+     * const claims = await getIdTokenClaims();
+     * ```
+     *
+     * Returns all claims from the id_token if available.
+     */
+    getIdTokenClaims: () => Promise<IdToken | undefined>;
+    /**
+     * ```js
+     * await loginWithCustomTokenExchange(options);
+     * ```
+     *
+     * Exchanges an external subject token for Auth0 tokens and logs the user in.
+     * This method implements the Custom Token Exchange grant as specified in RFC 8693.
+     *
+     * The exchanged tokens are automatically cached, establishing an authenticated session.
+     * After calling this method, you can use `getUser()`, `getIdTokenClaims()`, and
+     * `getTokenSilently()` to access the user's information and tokens.
+     *
+     * @param options - The options required to perform the token exchange.
+     *
+     * @returns A promise that resolves to the token endpoint response,
+     * which contains the issued Auth0 tokens (access_token, id_token, etc.).
+     *
+     * The request includes the following parameters:
+     * - `grant_type`: "urn:ietf:params:oauth:grant-type:token-exchange"
+     * - `subject_token`: The external token to exchange
+     * - `subject_token_type`: The type identifier of the external token
+     * - `scope`: Merged scopes from the request and SDK defaults
+     * - `audience`: Target audience (defaults to SDK configuration)
+     * - `organization`: Optional organization ID/name for org-scoped authentication
+     *
+     * **Example Usage:**
+     *
+     * ```js
+     * const options = {
+     *   subject_token: 'eyJhbGciOiJIUzI1NiIsInR5cCI6Ikp...',
+     *   subject_token_type: 'urn:acme:legacy-system-token',
+     *   scope: 'openid profile email',
+     *   audience: 'https://api.example.com',
+     *   organization: 'org_12345'
+     * };
+     *
+     * try {
+     *   const tokenResponse = await loginWithCustomTokenExchange(options);
+     *   console.log('Access token:', tokenResponse.access_token);
+     *
+     *   // User is now logged in - access user info
+     *   const user = await getUser();
+     *   console.log('Logged in user:', user);
+     * } catch (error) {
+     *   console.error('Token exchange failed:', error);
+     * }
+     * ```
+     */
+    loginWithCustomTokenExchange: (options: CustomTokenExchangeOptions) => Promise<TokenEndpointResponse>;
+    /**
+     * ```js
+     * const tokenResponse = await customTokenExchange({
+     *   subject_token: 'ey...',
+     *   subject_token_type: 'urn:acme:legacy-system-token',
+     *   actor_token: 'ey...',
+     *   actor_token_type: 'https://idp.example.com/token-type/agent',
+     * });
+     * ```
+     *
+     * Exchanges an external subject token for Auth0 tokens without affecting the current session.
+     *
+     * Unlike `loginWithCustomTokenExchange`, this method has no side effects — it does not cache
+     * tokens, does not update the authenticated session, and does not affect `isAuthenticated`
+     * or `user`. Use this for delegation or impersonation scenarios where you need a downstream
+     * API token without changing who the current user is.
+     *
+     * When `actor_token` is present Auth0 suppresses refresh token issuance; a missing
+     * `refresh_token` in the response is expected and will not cause an error.
+     *
+     * @param options - The options required to perform the token exchange.
+     * @returns A promise that resolves to the token endpoint response.
+     */
+    customTokenExchange: (options: CustomTokenExchangeOptions) => Promise<TokenEndpointResponse>;
+    /**
+     * @deprecated Use `loginWithCustomTokenExchange()` instead. This method will be removed in the next major version.
+     *
+     * ```js
+     * const tokenResponse = await exchangeToken({
+     *   subject_token: 'external_token_value',
+     *   subject_token_type: 'urn:acme:legacy-system-token',
+     *   scope: 'openid profile email'
+     * });
+     * ```
+     *
+     * Exchanges an external subject token for Auth0 tokens and logs the user in.
+     *
+     * This method implements the token exchange grant as specified in RFC 8693.
+     * It performs a token exchange by sending a request to the `/oauth/token` endpoint
+     * with the external token and returns Auth0 tokens (access token, ID token, etc.).
+     *
+     * **Example:**
+     * ```js
+     * // Instead of:
+     * const tokens = await exchangeToken(options);
+     *
+     * // Use:
+     * const tokens = await loginWithCustomTokenExchange(options);
+     * ```
+     *
+     * @param options - The options required to perform the token exchange
+     * @returns A promise that resolves to the token endpoint response containing Auth0 tokens
+     */
+    exchangeToken: (options: CustomTokenExchangeOptions) => Promise<TokenEndpointResponse>;
+    /**
+     * ```js
+     * await loginWithRedirect(options);
+     * ```
+     *
+     * Performs a redirect to `/authorize` using the parameters
+     * provided as arguments. Random and secure `state` and `nonce`
+     * parameters will be auto-generated.
+     */
+    loginWithRedirect: (options?: RedirectLoginOptions<AppState>) => Promise<void>;
+    /**
+     * ```js
+     * await loginWithPopup(options, config);
+     * ```
+     *
+     * Opens a popup with the `/authorize` URL using the parameters
+     * provided as arguments. Random and secure `state` and `nonce`
+     * parameters will be auto-generated. If the response is successful,
+     * results will be valid according to their expiration times.
+     *
+     * IMPORTANT: This method has to be called from an event handler
+     * that was started by the user like a button click, for example,
+     * otherwise the popup will be blocked in most browsers.
+     */
+    loginWithPopup: (options?: PopupLoginOptions, config?: PopupConfigOptions) => Promise<void>;
+    /**
+     * ```js
+     * await connectAccountWithRedirect({
+     *   connection: 'google-oauth2',
+     *   scopes: ['openid', 'profile', 'email', 'https://www.googleapis.com/auth/drive.readonly'],
+     *   authorization_params: {
+     *     // additional authorization params to forward to the authorization server
+     *   }
+     * });
+     * ```
+     *
+     * Redirects to the `/connect` URL using the parameters
+     * provided as arguments. This then redirects to the connection's login page
+     * where the user can authenticate and authorize the account to be connected.
+     *
+     * If connecting the account is successful `onRedirectCallback` will be called
+     * with the details of the connected account.
+     */
+    connectAccountWithRedirect: (options: RedirectConnectAccountOptions) => Promise<void>;
+    /**
+     * ```js
+     * auth0.logout({ logoutParams: { returnTo: window.location.origin } });
+     * ```
+     *
+     * Clears the application session and performs a redirect to `/v2/logout`, using
+     * the parameters provided as arguments, to clear the Auth0 session.
+     * If the `logoutParams.federated` option is specified, it also clears the Identity Provider session.
+     * [Read more about how Logout works at Auth0](https://auth0.com/docs/logout).
+     */
+    logout: (options?: LogoutOptions) => Promise<void>;
+    /**
+     * After the browser redirects back to the callback page,
+     * call `handleRedirectCallback` to handle success and error
+     * responses from Auth0. If the response is successful, results
+     * will be valid according to their expiration times.
+     *
+     * @param url The URL to that should be used to retrieve the `state` and `code` values. Defaults to `window.location.href` if not given.
+     */
+    handleRedirectCallback: (url?: string) => Promise<RedirectLoginResult | ConnectAccountRedirectResult>;
+    /**
+     * Returns the current DPoP nonce used for making requests to Auth0.
+     *
+     * It can return `undefined` because when starting fresh it will not
+     * be populated until after the first response from the server.
+     *
+     * It requires enabling the {@link Auth0ClientOptions.useDpop} option.
+     *
+     * @param nonce The nonce value.
+     * @param id    The identifier of a nonce: if absent, it will get the nonce
+     *              used for requests to Auth0. Otherwise, it will be used to
+     *              select a specific non-Auth0 nonce.
+     */
+    getDpopNonce: Auth0Client['getDpopNonce'];
+    /**
+     * Sets the current DPoP nonce used for making requests to Auth0.
+     *
+     * It requires enabling the {@link Auth0ClientOptions.useDpop} option.
+     *
+     * @param nonce The nonce value.
+     * @param id    The identifier of a nonce: if absent, it will set the nonce
+     *              used for requests to Auth0. Otherwise, it will be used to
+     *              select a specific non-Auth0 nonce.
+     */
+    setDpopNonce: Auth0Client['setDpopNonce'];
+    /**
+     * Returns a string to be used to demonstrate possession of the private
+     * key used to cryptographically bind access tokens with DPoP.
+     *
+     * It requires enabling the {@link Auth0ClientOptions.useDpop} option.
+     */
+    generateDpopProof: Auth0Client['generateDpopProof'];
+    /**
+     * Returns a new `Fetcher` class that will contain a `fetchWithAuth()` method.
+     * This is a drop-in replacement for the Fetch API's `fetch()` method, but will
+     * handle certain authentication logic for you, like building the proper auth
+     * headers or managing DPoP nonces and retries automatically.
+     *
+     * Check the `EXAMPLES.md` file for a deeper look into this method.
+     */
+    createFetcher: Auth0Client['createFetcher'];
+    /**
+     * ```js
+     * const config = getConfiguration();
+     * // { domain: 'tenant.auth0.com', clientId: 'abc123' }
+     * ```
+     *
+     * Returns a readonly copy of the initialization configuration
+     * containing the domain and clientId.
+     */
+    getConfiguration: Auth0Client['getConfiguration'];
+    /**
+     * ```js
+     * const { mfa } = useAuth0();
+     * const authenticators = await mfa.getAuthenticators(mfaToken);
+     * ```
+     *
+     * MFA API client for Multi-Factor Authentication operations.
+     *
+     * Provides access to all MFA-related methods:
+     * - `getAuthenticators(mfaToken)` - List enrolled authenticators
+     * - `enroll(params)` - Enroll new authenticators (OTP, SMS, Voice, Email, Push)
+     * - `challenge(params)` - Initiate MFA challenges
+     * - `verify(params)` - Verify MFA challenges and complete authentication
+     * - `getEnrollmentFactors(mfaToken)` - Get available enrollment factors
+     *
+     * @example
+     * ```js
+     * const { mfa, getAccessTokenSilently } = useAuth0();
+     *
+     * try {
+     *   await getAccessTokenSilently();
+     * } catch (error) {
+     *   if (error.error === 'mfa_required') {
+     *     // Check if enrollment is needed
+     *     const factors = await mfa.getEnrollmentFactors(error.mfa_token);
+     *
+     *     if (factors.length > 0) {
+     *       // Enroll in OTP
+     *       const enrollment = await mfa.enroll({
+     *         mfaToken: error.mfa_token,
+     *         factorType: 'otp'
+     *       });
+     *       console.log('QR Code:', enrollment.barcodeUri);
+     *     }
+     *
+     *     // Get authenticators and challenge
+     *     const authenticators = await mfa.getAuthenticators(error.mfa_token);
+     *     await mfa.challenge({
+     *       mfaToken: error.mfa_token,
+     *       challengeType: 'otp',
+     *       authenticatorId: authenticators[0].id
+     *     });
+     *
+     *     // Verify with user's code
+     *     const tokens = await mfa.verify({
+     *       mfaToken: error.mfa_token,
+     *       otp: userCode
+     *     });
+     *   }
+     * }
+     * ```
+     */
+    mfa: MfaApiClient;
+    /**
+     * ```js
+     * const { passkey } = useAuth0();
+     * const tokens = await passkey.signup({ email: 'user@example.com' });
+     * ```
+     *
+     * Passkey API client for WebAuthn-based passwordless authentication.
+     *
+     * - `signup(options)` — register a new user and create a passkey credential
+     * - `login(options?)` — authenticate an existing user via passkey assertion
+     *
+     * Both methods exchange the WebAuthn credential for Auth0 tokens and update
+     * `isAuthenticated` / `user` in the same way as `loginWithPopup`.
+     */
+    passkey: PasskeyApiClient;
+    /**
+     * ```js
+     * const { myAccount } = useAuth0();
+     * const factors = await myAccount.getFactors();
+     * ```
+     *
+     * MyAccount API client for self-service account management operations.
+     *
+     * Provides access to methods for managing the authenticated user's authentication
+     * methods and factors:
+     * - `getFactors()` - List available authentication factors
+     * - `getAuthenticationMethods(type?)` - List enrolled authentication methods, optionally filtered by type
+     * - `getAuthenticationMethod(id)` - Get a specific authentication method by ID
+     * - `updateAuthenticationMethod(id, data)` - Update an authentication method (e.g. rename)
+     * - `deleteAuthenticationMethod(id)` - Remove an enrolled authentication method
+     * - `enrollmentChallenge(options)` - Initiate a two-step enrollment challenge
+     * - `enrollmentVerify(options)` - Complete a two-step enrollment by verifying the challenge
+     *
+     * @example
+     * ```js
+     * const { myAccount } = useAuth0();
+     *
+     * // List all enrolled authentication methods
+     * const methods = await myAccount.getAuthenticationMethods();
+     *
+     * // Enroll a new passkey
+     * const challenge = await myAccount.enrollmentChallenge({ type: 'passkey' });
+     * const credential = await navigator.credentials.create({ publicKey: challenge.authn_params_public_key });
+     * await myAccount.enrollmentVerify({ type: 'passkey', auth_session: challenge.auth_session, location: challenge.location, authn_response: credential });
+     *
+     * // Remove an authentication method
+     * await myAccount.deleteAuthenticationMethod('method-id');
+     * ```
+     */
+    myAccount: MyAccountApiClient;
+}
+/**
+ * @ignore
+ */
+export declare const initialContext: {
+    buildAuthorizeUrl: () => never;
+    buildLogoutUrl: () => never;
+    getAccessTokenSilently: () => never;
+    getAccessTokenWithPopup: () => never;
+    getIdTokenClaims: () => never;
+    loginWithCustomTokenExchange: () => never;
+    customTokenExchange: () => never;
+    exchangeToken: () => never;
+    loginWithRedirect: () => never;
+    loginWithPopup: () => never;
+    connectAccountWithRedirect: () => never;
+    logout: () => never;
+    handleRedirectCallback: () => never;
+    getDpopNonce: () => never;
+    setDpopNonce: () => never;
+    generateDpopProof: () => never;
+    createFetcher: () => never;
+    getConfiguration: () => never;
+    mfa: MfaApiClient;
+    passkey: PasskeyApiClient;
+    myAccount: MyAccountApiClient;
+    error: Error | undefined;
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    user: User | undefined;
+};
+/**
+ * The Auth0 Context
+ */
+declare const Auth0Context: import("react").Context<Auth0ContextInterface<User>>;
+export default Auth0Context;
+//# sourceMappingURL=auth0-context.d.ts.map

package/dist/auth0-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth0-context.d.ts","sourceRoot":"","sources":["../src/auth0-context.tsx"],"names":[],"mappings":"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"}