MfaWebAuthnPlatformChallengeMembers

export interface MfaWebAuthnPlatformChallengeMembers extends BaseMembers {
  /**
   * Propriétés et données propres à l'écran, incluant les options de défi WebAuthn et la préférence de mémorisation de l'appareil.
   * @type {ScreenMembersOnMfaWebAuthnPlatformChallenge}
   */
  screen: ScreenMembersOnMfaWebAuthnPlatformChallenge;

  /**
   * Lance le défi de plateforme WebAuthn de l'authentificateur.
   * Cette méthode appelle en interne `navigator.credentials.get()` en utilisant les options de défi
   * fournies dans `screen.publicKey`.
   * En cas de succès, elle soumet les informations d'identification résultantes à Auth0 avec `action: "default"`.
   *
   * Si `navigator.credentials.get()` échoue (p. ex., annulation par l'utilisateur, délai d'attente ou autres erreurs de l'API WebAuthn),
   * il est recommandé d'appeler `reportBrowserError` avec les détails de l'erreur.
   *
   * @param {VerifyPlatformAuthenticatorOptions} [options] - Paramètres facultatifs pour le processus de vérification,
   * tels que `rememberDevice` (si `screen.showRememberDevice` est vrai) et d'autres options personnalisées.
   * @returns {Promise<void>} Une promesse qui se résout lorsque la tentative de vérification est soumise.
   *                          Une opération réussie entraîne généralement une redirection.
   * @throws {Error} Génère une erreur si `screen.publicKey` est manquant,
   *                 si `navigator.credentials.get()` échoue avec une erreur inattendue non gérée par `getPasskeyCredentials`,
   *                 ou si la soumission du formulaire à Auth0 échoue.
   *
   * @example
   * ```typescript
   * // En supposant que 'sdk' est une instance de MfaWebAuthnPlatformChallenge
   * try {
   *   const remember = sdk.screen.showRememberDevice && userCheckedRememberDeviceBox;
   *   await sdk.verify({ rememberDevice: remember });
   *   // En cas de succès, Auth0 gère la redirection.
   * } catch (error) {
   *   console.error("Échec de la vérification de l'authentificateur de plateforme :", error);
   *   // S'il s'agit d'une erreur de l'API WebAuthn, la signaler
   *   if (error.name && error.message) { // Vérification de base pour une erreur de type DOMException
   *     await sdk.reportBrowserError({ error: { name: error.name, message: error.message } });
   *   }
   *   // Vérifier sdk.transaction.errors pour les messages de validation côté serveur si la page se recharge.
   * }
   * ```
   */
  verify(options?: VerifyPlatformAuthenticatorOptions): Promise<void>;

  /**
   * Signale une erreur spécifique de l'API WebAuthn (provenant de `navigator.credentials.get()`) à Auth0.
   * Cette méthode doit être utilisée lorsque `verify()` (ou un appel manuel à `navigator.credentials.get()`) échoue en raison
   * d'un problème WebAuthn côté navigateur (p. ex., annulation par l'utilisateur `NotAllowedError`, délai d'attente).
   * Elle soumet les détails de l'erreur avec `action: "showError::{errorDetailsJsonString}"` et une `response` vide.
   *
   * @param {ReportBrowserErrorOptions} options - Contient l'objet `error` (avec `name` et `message`
   * provenant de la DOMException de l'API WebAuthn) et toute autre option personnalisée.
   * @returns {Promise<void>} Une promesse qui se résout lorsque le rapport d'erreur est soumis.
   * @throws {Error} Génère une erreur si la soumission du formulaire échoue (p. ex., erreur réseau, état invalide).
   *
   * @example
   * ```typescript
   * // En supposant que 'sdk' est une instance de MfaWebAuthnPlatformChallenge
   * // Et que webAuthnDomException est un objet d'erreur provenant d'un appel échoué à navigator.credentials.get().
   * try {
   *   await sdk.reportBrowserError({
   *     error: { name: webAuthnDomException.name, message: webAuthnDomException.message }
   *   });
   *   // Auth0 traitera cette erreur et pourra réafficher la page ou effectuer une redirection.
   * } catch (submitError) {
   *   console.error("Échec du signalement de l'erreur du navigateur WebAuthn :", submitError);
   * }
   * ```
   */
  reportBrowserError(options: ReportBrowserErrorOptions): Promise<void>;

  /**
   * Permet à l'utilisateur de se désinscrire du défi de plateforme WebAuthn et de sélectionner une autre méthode d'AMF.
   * Cette action soumet `action: "pick-authenticator"` à Auth0, ce qui devrait diriger
   * l'utilisateur vers un écran de sélection de facteur d'AMF.
   *
   * @param {TryAnotherMethodOptions} [options] - Paramètres personnalisés facultatifs à envoyer avec la requête.
   * @returns {Promise<void>} Une promesse qui se résout lorsque l'action 'pick-authenticator' est soumise.
   * @throws {Error} Génère une erreur si la soumission du formulaire échoue.
   *
   * @example
   * ```typescript
   * // En supposant que 'sdk' est une instance de MfaWebAuthnPlatformChallenge
   * try {
   *   await sdk.tryAnotherMethod();
   *   // En cas de succès, Auth0 gère la redirection vers la sélection d'AMF.
   * } catch (error) {
   *   console.error("Échec du changement de méthode d'AMF :", error);
   * }
   * ```
   */
  tryAnotherMethod(options?: TryAnotherMethodOptions): Promise<void>;
}