> ## Documentation Index
> Fetch the complete documentation index at: https://translations.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Créer une méthode d’authentification

> Démarrer l’inscription d’une méthode d’authentification prise en charge.

export const Scopes = ({scopes = []}) => {
  return <div>
      <div class="api-section-heading flex flex-col gap-y-4 w-full">
        <div class="flex items-baseline border-b pb-2.5 border-gray-100 dark:border-gray-800 w-full">
          <h4 class="api-section-heading-title flex-1 mb-0">Scopes</h4>
          <div class="flex items-center"></div>
        </div>
      </div>
      <div class="mt-4">
        <div class="space-y-4 whitespace-normal prose prose-sm prose-gray dark:prose-invert overflow-wrap-anywhere [&_*]:overflow-wrap-anywhere">
          <p class="whitespace-pre-line text-xs">
            {"Les scopes définissent les autorisations et les niveaux d’accès des requêtes d’API et des jetons d’authentification."}
          </p>
        </div>
      </div>
      <div class="flex font-mono text-sm group/param-head param-head break-all relative mt-6" id="scopes-scopes">
        <div class="flex-1 flex flex-col content-start py-0.5 mr-5">
          <div class="flex items-center flex-wrap gap-2">
            <div class="absolute -top-1.5">
              <a href="#scopes-scopes" class="-ml-10 flex items-center opacity-0 border-0 group-hover/param-head:opacity-100 focus:opacity-100 focus:outline-0 py-2 [.expandable-content_&]:-ml-[2.1rem] group/link" aria-label="Accéder à l’en-tête">
                ​
                <div class="w-6 h-6 rounded-md flex items-center justify-center shadow-sm text-gray-400 dark:text-white/50 dark:bg-background-dark dark:brightness-[1.35] dark:ring-1 dark:hover:brightness-150 bg-white ring-1 ring-gray-400/30 dark:ring-gray-700/25 hover:ring-gray-400/60 dark:hover:ring-white/20 group-focus/link:border-2 group-focus/link:border-primary dark:group-focus/link:border-primary-light">
                  <svg xmlns="http://www.w3.org/2000/svg" fill="gray" height="12px" viewBox="0 0 576 512">
                    <path d="M0 256C0 167.6 71.6 96 160 96h72c13.3 0 24 10.7 24 24s-10.7 24-24 24H160C98.1 144 48 194.1 48 256s50.1 112 112 112h72c13.3 0 24 10.7 24 24s-10.7 24-24 24H160C71.6 416 0 344.4 0 256zm576 0c0 88.4-71.6 160-160 160H344c-13.3 0-24-10.7-24-24s10.7-24 24-24h72c61.9 0 112-50.1 112-112s-50.1-112-112-112H344c-13.3 0-24-10.7-24-24s10.7-24 24-24h72c88.4 0 160 71.6 160 160zM184 232H392c13.3 0 24 10.7 24 24s-10.7 24-24 24H184c-13.3 0-24-10.7-24-24s10.7-24 24-24z"></path>
                  </svg>
                </div>
              </a>
            </div>
            {scopes.map((scope, index) => {
    return <span class="flex items-center px-2 py-0.5 rounded-md bg-gray-100/50 dark:bg-white/5 text-gray-600 dark:text-gray-200 font-medium break-all" style={{
      lineHeight: "1rem",
      fontSize: "0.75rem",
      fontFamily: 'var(--font-jetbrains-mono), ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace'
    }} data-component-part="field-info-pill" key={index}>
                  {scope}
                </span>;
  })}
          </div>
        </div>
      </div>
    </div>;
};

export const ApiReleaseLifecycle = ({releaseLifecycle = "GA"}) => {
  const lifecycleMap = {
    ea: "Accès anticipé",
    ga: "Généralement disponible",
    deprecated: "Obsolète",
    planned: "Planifié",
    beta: "Bêta"
  };
  const LIFECYCLE_THEMES = {
    info: {
      light: {
        bg: "lab(91.896% .077188 -6.94053)",
        text: "lab(36.091% 25.9241 -68.0384)"
      },
      dark: {
        bg: "lab(16.0426% 6.71726 -27.2409)",
        text: "lab(72.6029% 4.08953 -41.9669)"
      }
    },
    secondary: {
      light: {
        bg: "lab(90.8548% 11.3355 8.01476)",
        text: "lab(47.5286% 56.4238 43.4706)"
      },
      dark: {
        bg: "lab(16.3609% 37.191 25.6346)",
        text: "lab(71.881% 41.5 29.4839)"
      }
    },
    danger: {
      light: {
        bg: "lab(94.7916% -.0000298023 0)",
        text: "lab(54.3656% 0 -.0000119209)"
      },
      dark: {
        bg: "lab(13.232% 0 0)",
        text: "lab(51.6164% 0 0)"
      }
    }
  };
  const LIFECYCLE_THEME_MAP = {
    ea: "info",
    ga: "info",
    beta: "info",
    deprecated: "secondary",
    planned: "danger"
  };
  const lifecycle = releaseLifecycle.toLocaleLowerCase();
  const lifecycleText = lifecycleMap[lifecycle];
  if (!lifecycleText) {
    return null;
  }
  const theme = LIFECYCLE_THEMES[LIFECYCLE_THEME_MAP[lifecycle]];
  return <div>
      <div className="api-section-heading flex flex-col gap-y-4 w-full">
        <div className="flex items-baseline border-b pb-2.5 border-gray-100 dark:border-gray-800 w-full">
          <h4 className="api-section-heading-title flex-1 mb-0">Cycle de vie de la version</h4>
        </div>
      </div>
      <div className="flex font-mono text-sm group/param-head param-head break-all relative mt-2.5" id="releaselifecycle-lifecycle">
        <div className="flex-1 flex flex-col content-start py-0.5 mr-5">
          <div className="flex items-center flex-wrap gap-2">
            <div className="absolute -top-1.5">
              <a href="#releaselifecycle-lifecycle" className="-ml-10 flex items-center opacity-0 border-0 group-hover/param-head:opacity-100 focus:opacity-100 focus:outline-0 py-2 [.expandable-content_&]:-ml-[2.1rem] group/link" aria-label="Accéder à l'en-tête">
                <div className="w-6 h-6 rounded-md flex items-center justify-center shadow-sm text-gray-400 dark:text-white/50 dark:bg-background-dark dark:brightness-[1.35] dark:ring-1 dark:hover:brightness-150 bg-white ring-1 ring-gray-400/30 dark:ring-gray-700/25 hover:ring-gray-400/60 dark:hover:ring-white/20 group-focus/link:border-2 group-focus/link:border-primary dark:group-focus/link:border-primary-light">
                  <svg xmlns="http://www.w3.org/2000/svg" fill="gray" height="12px" viewBox="0 0 576 512">
                    <path d="M0 256C0 167.6 71.6 96 160 96h72c13.3 0 24 10.7 24 24s-10.7 24-24 24H160C98.1 144 48 194.1 48 256s50.1 112 112 112h72c13.3 0 24 10.7 24 24s-10.7 24-24 24H160C71.6 416 0 344.4 0 256zm576 0c0 88.4-71.6 160-160 160H344c-13.3 0-24-10.7-24-24s10.7-24 24-24h72c61.9 0 112-50.1 112-112s-50.1-112-112-112H344c-13.3 0-24-10.7-24-24s10.7-24 24-24h72c88.4 0 160 71.6 160 160zM184 232H392c13.3 0 24 10.7 24 24s-10.7 24-24 24H184c-13.3 0-24-10.7-24-24s10.7-24 24-24z"></path>
                  </svg>
                </div>
              </a>
            </div>
            <span className="inline-flex items-center w-fit font-medium gap-1 py-0.5 px-2 rounded-md" style={{
    lineHeight: "1rem",
    fontSize: "0.75rem",
    fontFamily: 'var(--font-jetbrains-mono), ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace',
    backgroundColor: `light-dark(${theme.light.bg}, ${theme.dark.bg})`,
    color: `light-dark(${theme.light.text}, ${theme.dark.text})`,
    borderColor: `light-dark(color-mix(in oklab, ${theme.light.text} 25%, transparent), color-mix(in oklab, ${theme.dark.text} 25%, transparent))`
  }}>
              {lifecycleText}
            </span>
          </div>
        </div>
      </div>
    </div>;
};

<ApiReleaseLifecycle releaseLifecycle="GA" />

<Scopes scopes={["create:me:authentication_methods"]} />


## OpenAPI

````yaml fr-CA/docs/oas/myaccount/myaccount-api-oas.json POST /authentication-methods
openapi: 3.1.0
info:
  description: >-
    L’API My Account d’Auth0 fournit un ensemble dédié de points de terminaison
    permettant aux utilisateurs de gérer les renseignements de leur propre
    compte. Les clients peuvent utiliser ces API pour créer des expériences
    libre-service dans leurs applications ou ajouter progressivement des
    renseignements à un compte utilisateur.


    L’API My Account fonctionne dans le contexte de l’utilisateur actuellement
    connecté et peut être utilisée directement dans les applications destinées
    aux utilisateurs.


    :::tip Utilisation du domaine Auth0 ou d’un domaine personnalisé


    L’API My Account prend en charge l’utilisation de votre domaine Auth0
    canonique ou de votre domaine personnalisé, mais vous devez utiliser le même
    tout au long du processus, y compris pour les opérations suivantes :


    - Obtenir un jeton d’accès

    - Définir la valeur d’audience

    - Appeler le point de terminaison de l’API My Account


    Pour en savoir plus, consultez [Domaines
    personnalisés](https://auth0.com/docs/customize/custom-domains).


    :::


    ## Activer l’API My Account


    Vous pouvez activer l’API My Account pour votre locataire dans le Auth0
    Dashboard :


    1. Accédez à Authentification > API.

    2. Repérez la bannière MyAccount API.

    3. Sélectionnez Activate.


    ![](https://images.ctfassets.net/cdy7uua7fh8z/DGkDQNIHcegN8vtQyEvF3/a2e98b06867701a66fa1f1b3df1c996b/My_Account_API_-_Activate.png)


    Par défaut, l’API My Account est créée avec les stratégies d’accès des
    applications aux API suivantes :


    `require_client_grant` pour les flux utilisateur


    `deny_all` pour les flux d’application (machine à machine)


    Pour qu’une application puisse accéder à l’API My Account au nom de
    l’utilisateur, vous devez créer explicitement une autorisation d’application
    pour cette application, ce qui vous permet de définir les scopes maximums
    que l’application peut demander. Vous pouvez aussi modifier la stratégie des
    flux d’accès utilisateur afin d’utiliser allow_all, ce qui permet à toute
    application de votre locataire de demander n’importe quel scope à l’API My
    Account.


    Comme l’API My Account expose des renseignements et des opérations
    sensibles, Auth0 ne recommande pas d’utiliser allow_all pour les flux
    d’accès utilisateur. Vous devriez appliquer le principe du privilège minimal
    avec l’API My Account afin de vous assurer que les applications n’obtiennent
    que l’accès dont elles ont réellement besoin, ce qui réduit les risques
    potentiels pour la sécurité.


    Les permissions finales accordées à l’application seront déterminées par
    l’intersection des scopes autorisés par la stratégie d’accès des
    applications aux API, des permissions de Contrôle d’accès basé sur les rôles
    (RBAC) attribuées à l’utilisateur final et de tout consentement accordé par
    l’utilisateur (le cas échéant).


    :::info Flux pris en charge


    Vous ne pouvez pas mettre à jour la stratégie d’accès des applications à
    l’API My Account pour les flux client, ce qui signifie que vous ne pouvez
    pas accéder à l’API My Account à l’aide du flux d’identification du client.


    :::


    Pour en savoir plus sur la gestion des stratégies d’accès des applications
    aux API et des autorisations d’application associées, consultez [Accès des
    applications aux API : autorisations
    d’application](https://auth0.com/docs/get-started/applications/application-access-to-apis-client-grants).


    ## Obtenir un jeton d’accès


    Vous pouvez obtenir un jeton d’accès pour l’API My Account de la même
    manière que pour l’une de vos propres API.


    :::info &nbsp

    Si vous comptez autoriser l’API My Account à effectuer des opérations
    sensibles (comme l’inscription d’une méthode d’authentification), nous vous
    recommandons fortement d’utiliser l’[authentification
    renforcée](https://auth0.com/docs/secure/multi-factor-authentication/step-up-authentication)
    afin d’appliquer des stratégies de sécurité supplémentaires au moyen de
    l’[authentification multifacteur
    (MFA)](https://auth0.com/docs/secure/multi-factor-authentication).

    :::


    Si vous utilisez Universal Login, consultez les articles suivants :


    - [Appeler votre API à l’aide du flux de code
    d’autorisation](https://auth0.com/docs/get-started/authentication-and-authorization-flow/authorization-code-flow/call-your-api-using-the-authorization-code-flow)

    - [Appeler votre API à l’aide du flux de code d’autorisation avec
    PKCE](https://auth0.com/docs/get-started/authentication-and-authorization-flow/authorization-code-flow-with-pkce/call-your-api-using-the-authorization-code-flow-with-pkce)


    Si vous utilisez la connexion intégrée, consultez les articles suivants :


    - [Appeler votre API à l’aide du flux de mot de passe du propriétaire de la
    ressource](https://auth0.com/docs/get-started/authentication-and-authorization-flow/resource-owner-password-flow/call-your-api-using-resource-owner-password-flow)

    - [Flux de connexion avec l’API de clés d’accès
    natives](https://auth0.com/docs/native-passkeys-api#login-flow)


    ## Exemples


    ### Universal Login avec flux de code d’autorisation


    **Étape 1 : Demander un code d’autorisation**


    ```

    curl --request GET \
      --url 'https://{yourDomain}/authorize?response_type=code&client_id={yourClientId}&redirect_uri=%7ByourRedirectUri%7D&scope=create%3Ame%3Aauthentication_methods&offline_access=&audience=https%3A%2F%2F{yourDomain}%2Fme%2F'
    ```


    **Étape 2 : Échanger le code contre un jeton d’accès**


    ```

    curl --request POST \
      --url 'https://{yourDomain}/oauth/token' \
      --header 'content-type: application/json' \
      --data '{"grant_type": "authorization_code","client_id": "{yourClientId}","client_secret": "{yourClientSecret}","code": "{yourAuthorizationCode}","redirect_uri": "{yourRedirectUri}","audience": "{yourAudience}","scope": "create:me:authentication_methods","offline_access": ""}'
    ```


    ### Connexion intégrée avec clés d’accès natives


    **Étape 1 : Demander un défi de connexion**


    ```

    curl --request POST \
      --url 'https://{yourDomain}/passkey/challenge' \
      --header 'content-type: application/json' \
      --data '{"client_id": "{yourClientId}"}'
    ```


    **Étape 2 : Authentifier un utilisateur existant**


    ```

    curl --request POST \
      --url 'https://{yourDomain}/oauth/token' \
      --header 'content-type: application/json' \
      --data '{  "grant_type": "urn:okta:params:oauth:grant-type:webauthn",  "client_id": "{yourClientId}",  "scope": "create:me:authentication_methods offline_access",  "audience": "https://{yourDomain}/me/",  "auth_session": "{sessionIdFromTheFirstRequest}",  "authn_response": "{authenticatorResponse}"}'
    ```
  title: My Account
  version: '1.0'
servers:
  - url: https://{host}/me/v1
    variables:
      host:
        default: auth0.auth0.com
        description: Nom d’hôte personnalisé ou nom d’hôte canonique
security: []
tags:
  - description: Facteurs
    name: factors
    x-displayName: Factors
  - description: Connected Accounts
    name: connected-accounts
    x-displayName: Connected Accounts
  - description: Méthodes d’authentification
    name: authentication-methods
    x-displayName: Authentication Methods
  - description: Consentements
    name: consents
    x-displayName: Consents
paths:
  /authentication-methods:
    post:
      tags:
        - authentication-methods
      summary: >-
        Commencer l’inscription d’une méthode d’authentification prise en
        charge.
      description: Démarrer l’inscription d’une méthode d’authentification prise en charge.
      operationId: createAuthenticationMethod
      requestBody:
        content:
          application/json:
            examples:
              email:
                summary: Inscrire une adresse de courriel pour l’OTP
                value:
                  email: user@example.com
                  type: email
              passkey:
                summary: Inscrire une clé d’accès
                value:
                  type: passkey
              password:
                summary: Inscrire des informations d’identification par mot de passe
                value:
                  type: password
              phone:
                summary: Inscrire un numéro de téléphone pour l’OTP par SMS/appel vocal
                value:
                  phone_number: '+15551234567'
                  preferred_authentication_method: sms
                  type: phone
              push-notification:
                summary: Inscrire un authentificateur par notification push
                value:
                  type: push-notification
              recovery-code:
                summary: Générer un code de récupération
                value:
                  type: recovery-code
              totp:
                summary: Inscrire une application d’authentification TOTP
                value:
                  type: totp
            schema:
              $ref: '#/components/schemas/CreateAuthenticationMethodRequestContent'
      responses:
        '202':
          content:
            application/json:
              examples:
                email:
                  summary: Inscription du courriel démarrée
                  value:
                    auth_session: Fe26.2**05c400ed...
                    id: email|dev_XXXXXXXXXXXXXXXX
                passkey:
                  summary: >-
                    Inscription de la clé d’accès démarrée — comprend les
                    options de création WebAuthn
                  value:
                    auth_session: Fe26.2**05c400ed...
                    authn_params_public_key:
                      authenticatorSelection:
                        residentKey: required
                        userVerification: preferred
                      challenge: dGVzdC1jaGFsbGVuZ2U
                      pubKeyCredParams:
                        - alg: -7
                          type: public-key
                        - alg: -257
                          type: public-key
                      rp:
                        id: example.auth0.com
                        name: My Application
                      timeout: 60000
                      user:
                        displayName: User
                        id: YXV0aDB8NTA3ZjFmNzdiY2Y4NmNkNzk5NDM5MDEx
                        name: user@example.com
                password:
                  summary: >-
                    Inscription par mot de passe démarrée — comprend la
                    stratégie de mot de passe
                  value:
                    auth_session: Fe26.2**05c400ed...
                    id: password|new
                    policy:
                      complexity:
                        character_type_rule: three_of_four
                        character_types:
                          - lowercase
                          - uppercase
                          - number
                          - special
                        identical_characters: block
                        max_length_exceeded: truncate
                        min_length: 8
                        sequential_characters: block
                      dictionary:
                        active: true
                        default: en_10k
                      history:
                        active: true
                        size: 5
                      profile_data:
                        active: true
                        blocked_fields:
                          - name
                          - email
                phone:
                  summary: Inscription du téléphone démarrée
                  value:
                    auth_session: Fe26.2**05c400ed...
                    id: phone|dev_XXXXXXXXXXXXXXXX
                push-notification:
                  summary: >-
                    Inscription par notification push démarrée — comprend les
                    données du code QR
                  value:
                    auth_session: Fe26.2**05c400ed...
                    barcode_uri: >-
                      otpauth://totp/my-tenant:auth0%7C507f1f77bcf86cd799439011?secret=JBSWY3DPEHPK3PXP&issuer=my-tenant&algorithm=SHA1&digits=6&period=30
                    id: push-notification|dev_XXXXXXXXXXXXXXXX
                recovery-code:
                  summary: Code de récupération généré
                  value:
                    auth_session: Fe26.2**05c400ed...
                    id: recovery-code|dev_XXXXXXXXXXXXXXXX
                    recovery_code: ABCDEFGHIJKLMNOPQRSTUVWX
                totp:
                  summary: Inscription TOTP démarrée — comprend les données du code QR
                  value:
                    auth_session: Fe26.2**05c400ed...
                    barcode_uri: >-
                      otpauth://totp/my-tenant:auth0%7C507f1f77bcf86cd799439011?secret=JBSWY3DPEHPK3PXP&issuer=my-tenant&algorithm=SHA1&digits=6&period=30
                    id: totp|dev_XXXXXXXXXXXXXXXX
                    manual_input_code: JBSWY3DPEHPK3PXP
              schema:
                $ref: '#/components/schemas/CreateAuthenticationMethodResponseContent'
          description: Inscription lancée
          headers:
            Location:
              $ref: '#/components/headers/LocationHeader'
            x-ratelimit-limit:
              $ref: '#/components/headers/XRateLimitLimitHeader'
            x-ratelimit-remaining:
              $ref: '#/components/headers/XRateLimitRemainingHeader'
            x-ratelimit-reset:
              $ref: '#/components/headers/XRateLimitResetHeader'
        '400':
          $ref: '#/components/responses/BadRequest'
        '401':
          $ref: '#/components/responses/Unauthorized'
        '403':
          $ref: '#/components/responses/Forbidden'
        '415':
          $ref: '#/components/responses/UnsupportedMediaType'
        '429':
          $ref: '#/components/responses/TooManyRequests'
      security:
        - Bearer-DPoP:
            - create:me:authentication_methods
      x-codeSamples: []
components:
  schemas:
    CreateAuthenticationMethodRequestContent:
      description: Corps de la requête pour créer une méthode d’authentification
      discriminator:
        mapping:
          email:
            $ref: '#/components/schemas/CreateEmailAuthenticationMethod'
          passkey:
            $ref: '#/components/schemas/CreatePasskeyAuthenticationMethod'
          password:
            $ref: '#/components/schemas/CreatePasswordAuthenticationMethod'
          phone:
            $ref: '#/components/schemas/CreatePhoneAuthenticationMethod'
          push-notification:
            $ref: '#/components/schemas/CreatePushNotificationAuthenticationMethod'
          recovery-code:
            $ref: '#/components/schemas/CreateRecoveryCodeAuthenticationMethod'
          totp:
            $ref: '#/components/schemas/CreateTotpAuthenticationMethod'
        propertyName: type
        x-openapi-typescript-ignore: true
      oneOf:
        - $ref: '#/components/schemas/CreatePasskeyAuthenticationMethod'
          title: passkey
        - $ref: '#/components/schemas/CreateTotpAuthenticationMethod'
          title: totp
        - $ref: '#/components/schemas/CreatePushNotificationAuthenticationMethod'
          title: push-notification
        - $ref: '#/components/schemas/CreateRecoveryCodeAuthenticationMethod'
          title: recovery-code
        - $ref: '#/components/schemas/CreateEmailAuthenticationMethod'
          title: email
        - $ref: '#/components/schemas/CreatePhoneAuthenticationMethod'
          title: phone
        - $ref: '#/components/schemas/CreatePasswordAuthenticationMethod'
          title: password
      type: object
    CreateAuthenticationMethodResponseContent:
      anyOf:
        - $ref: '#/components/schemas/PasskeyCreationResponse'
        - $ref: '#/components/schemas/WebAuthnCreationResponse'
        - $ref: '#/components/schemas/MfaBaseCreationResponse'
          title: Email/Phone enrollment information
        - $ref: '#/components/schemas/QrCodeCreationResponse'
        - $ref: '#/components/schemas/RecoveryCodeCreationResponse'
        - $ref: '#/components/schemas/PasswordCreationResponse'
    CreateEmailAuthenticationMethod:
      additionalProperties: false
      properties:
        email:
          description: >-
            L’adresse de courriel à utiliser pour envoyer des codes à usage
            unique.
          type: string
        type:
          const: email
          default: email
          description: Type de méthode d’authentification (facteur)
          type: string
      required:
        - type
        - email
      title: Email enrollment payload
      type: object
    CreatePasskeyAuthenticationMethod:
      allOf:
        - $ref: '#/components/schemas/IdentityAuthenticationMethodBase'
        - properties:
            type:
              const: passkey
              default: passkey
              description: Type de méthode d’authentification (facteur)
              type: string
          required:
            - type
          type: object
      title: Passkey enrollment payload
    CreatePasswordAuthenticationMethod:
      allOf:
        - $ref: '#/components/schemas/IdentityAuthenticationMethodBase'
        - additionalProperties: false
          properties:
            connection: true
            identity_user_id: true
            type:
              const: password
              default: password
              description: Type de méthode d’authentification (facteur)
              type: string
          required:
            - type
          type: object
      title: Password authentication method creation payload
    CreatePhoneAuthenticationMethod:
      additionalProperties: false
      properties:
        phone_number:
          description: >-
            Le numéro de téléphone de destination utilisé pour envoyer des codes
            de vérification par texto et par appel vocal.
          type: string
        preferred_authentication_method:
          $ref: '#/components/schemas/PhoneAuthenticationMethodEnum'
          description: La méthode de communication privilégiée.
        type:
          const: phone
          default: phone
          description: Type de méthode d’authentification (facteur)
          type: string
      required:
        - type
        - phone_number
      title: Phone enrollment payload
      type: object
    CreatePushNotificationAuthenticationMethod:
      additionalProperties: false
      properties:
        type:
          const: push-notification
          default: push-notification
          description: Type de méthode d’authentification (facteur)
          type: string
      required:
        - type
      title: Push Notification enrollment payload
      type: object
    CreateRecoveryCodeAuthenticationMethod:
      additionalProperties: false
      properties:
        type:
          const: recovery-code
          default: recovery-code
          description: Type de méthode d’authentification (facteur)
          type: string
      required:
        - type
      title: Recovery Code enrollment payload
      type: object
    CreateTotpAuthenticationMethod:
      additionalProperties: false
      properties:
        type:
          const: totp
          default: totp
          description: Type de méthode d’authentification (facteur)
          type: string
      required:
        - type
      title: TOTP enrollment payload
      type: object
    PasskeyCreationResponse:
      properties:
        auth_session:
          description: L’identifiant de session unique pour l’inscription.
          type: string
        authn_params_public_key:
          $ref: '#/components/schemas/PublicKeyCredentialCreationOptions'
      required:
        - auth_session
        - authn_params_public_key
      title: Passkey enrollment information
      type: object
    WebAuthnCreationResponse:
      allOf:
        - $ref: '#/components/schemas/MfaBaseCreationResponse'
        - properties:
            authn_params_public_key:
              $ref: '#/components/schemas/PublicKeyCredentialCreationOptions'
          required:
            - authn_params_public_key
          title: WebAuthn enrollment information
          type: object
    MfaBaseCreationResponse:
      properties:
        auth_session:
          description: L’identifiant de session unique de l’inscription.
          type: string
        id:
          description: L’identifiant unique de la méthode d’authentification.
          type: string
      required:
        - id
        - auth_session
      type: object
    QrCodeCreationResponse:
      allOf:
        - $ref: '#/components/schemas/MfaBaseCreationResponse'
        - properties:
            barcode_uri:
              description: L’URI du code QR à balayer avec l’authentificateur.
              type: string
            manual_input_code:
              description: >-
                Le code de saisie manuelle de l’authentificateur si les codes QR
                ne peuvent pas être utilisés.
              type: string
          required:
            - barcode_uri
          title: TOTP/Push enrollment information
          type: object
    RecoveryCodeCreationResponse:
      allOf:
        - $ref: '#/components/schemas/MfaBaseCreationResponse'
        - properties:
            recovery_code:
              description: La valeur du code de récupération.
              type: string
          required:
            - recovery_code
          title: Recovery Code enrollment information
          type: object
    PasswordCreationResponse:
      properties:
        auth_session:
          description: >-
            L’identifiant de session unique de l’opération de changement de mot
            de passe.
          type: string
        id:
          description: >-
            L’identifiant unique de la méthode d’authentification par mot de
            passe.
          type: string
        policy:
          $ref: '#/components/schemas/PasswordAuthenticationMethodPolicy'
      required:
        - id
        - policy
        - auth_session
      title: Password enrollment information
      type: object
    ErrorResponse:
      additionalProperties: false
      properties:
        detail:
          type: string
        status:
          type: number
        title:
          type: string
        type:
          type: string
        validation_errors:
          items:
            $ref: '#/components/schemas/ValidationError'
          type: array
      required:
        - type
        - status
        - title
        - detail
      type: object
    IdentityAuthenticationMethodBase:
      properties:
        connection:
          $ref: '#/components/schemas/Connection'
        identity_user_id:
          $ref: '#/components/schemas/IdentityUserId'
      type: object
    PhoneAuthenticationMethodEnum:
      description: >-
        Méthode d’authentification privilégiée pour l’authentification par
        téléphone
      enum:
        - sms
        - voice
      type: string
    PublicKeyCredentialCreationOptions:
      properties:
        authenticatorSelection:
          $ref: '#/components/schemas/AuthenticatorSelection'
        challenge:
          type: string
        pubKeyCredParams:
          example:
            - alg: -8
              type: public-key
            - alg: -7
              type: public-key
            - alg: -257
              type: public-key
          items:
            $ref: '#/components/schemas/PublicKeyCredentialParameter'
          type: array
        rp:
          $ref: '#/components/schemas/RelyingParty'
        timeout:
          example: 60000
          type: number
        user:
          $ref: '#/components/schemas/User'
      required:
        - challenge
        - pubKeyCredParams
        - rp
        - user
      type: object
    PasswordAuthenticationMethodPolicy:
      additionalProperties: false
      description: >-
        La configuration de la stratégie de mot de passe pour la connexion au
        format flexible.
      properties:
        complexity:
          $ref: '#/components/schemas/PasswordComplexityPolicy'
        dictionary:
          $ref: '#/components/schemas/PasswordDictionaryPolicy'
        history:
          $ref: '#/components/schemas/PasswordHistoryPolicy'
        profile_data:
          $ref: '#/components/schemas/PasswordProfileDataPolicy'
      required:
        - complexity
        - profile_data
        - history
        - dictionary
      type: object
    ValidationError:
      additionalProperties: false
      properties:
        detail:
          type: string
        field:
          type: string
        pointer:
          type: string
        source:
          type: string
      required:
        - detail
      type: object
    Connection:
      description: Nom de la connexion de base de données
      maxLength: 128
      minLength: 1
      pattern: ^[a-zA-Z0-9-]+$
      type: string
    IdentityUserId:
      description: ID utilisateur du fournisseur d’identité
      maxLength: 255
      minLength: 1
      pattern: ^\S+$
      type: string
    AuthenticatorSelection:
      additionalProperties: false
      properties:
        residentKey:
          $ref: '#/components/schemas/ResidentKeyEnum'
        userVerification:
          $ref: '#/components/schemas/UserVerificationEnum'
      type: object
    PublicKeyCredentialParameter:
      additionalProperties: false
      properties:
        alg:
          type: number
        type:
          $ref: '#/components/schemas/PublicKeyTypeEnum'
      required:
        - alg
        - type
      type: object
    RelyingParty:
      additionalProperties: false
      properties:
        id:
          type: string
        name:
          type: string
      required:
        - name
      type: object
    User:
      additionalProperties: false
      properties:
        displayName:
          type: string
        id:
          type: string
        name:
          type: string
      required:
        - id
        - name
        - displayName
      type: object
    PasswordComplexityPolicy:
      additionalProperties: false
      description: Exigences de complexité du mot de passe
      properties:
        character_type_rule:
          $ref: '#/components/schemas/PasswordCharacterTypeRuleEnum'
        character_types:
          description: Types de caractères requis
          items:
            $ref: '#/components/schemas/PasswordCharacterTypeEnum'
          type: array
        identical_characters:
          $ref: '#/components/schemas/PasswordIdenticalCharactersEnum'
        max_length_exceeded:
          $ref: '#/components/schemas/PasswordMaxLengthExceededEnum'
        min_length:
          description: Longueur minimale du mot de passe
          type: integer
        sequential_characters:
          $ref: '#/components/schemas/PasswordSequentialCharactersEnum'
      required:
        - min_length
        - character_types
        - character_type_rule
        - identical_characters
        - sequential_characters
        - max_length_exceeded
      type: object
    PasswordDictionaryPolicy:
      additionalProperties: false
      description: >-
        Paramètres de vérification du dictionnaire pour bloquer les mots de
        passe faibles ou interdits
      properties:
        active:
          description: Indique si la vérification du dictionnaire est activée
          type: boolean
        default:
          $ref: '#/components/schemas/PasswordDictionaryDefaultEnum'
      required:
        - active
        - default
      type: object
    PasswordHistoryPolicy:
      additionalProperties: false
      description: Paramètres d’application de l’historique des mots de passe
      properties:
        active:
          description: Indique si l’historique des mots de passe est appliqué
          type: boolean
        size:
          description: >-
            Nombre de mots de passe précédents à mémoriser pour empêcher leur
            réutilisation
          type: integer
      required:
        - active
        - size
      type: object
    PasswordProfileDataPolicy:
      additionalProperties: false
      description: >-
        Paramètres de blocage des renseignements personnels dans les mots de
        passe
      properties:
        active:
          description: >-
            Indique s’il faut bloquer les renseignements personnels (nom,
            courriel, etc.) dans les mots de passe
          type: boolean
        blocked_fields:
          description: >-
            Champs du profil utilisateur à bloquer dans les mots de passe (p.
            ex., 'name', 'email', 'user_metadata.first')
          items:
            type: string
          type: array
      required:
        - active
        - blocked_fields
      type: object
    ResidentKeyEnum:
      description: L’exigence relative à la clé résidente
      enum:
        - required
      type: string
    UserVerificationEnum:
      description: L’exigence relative à la vérification de l’utilisateur
      enum:
        - required
        - preferred
        - discouraged
      type: string
    PublicKeyTypeEnum:
      description: Le type d’information d’identification par clé publique
      enum:
        - public-key
      type: string
    PasswordCharacterTypeRuleEnum:
      description: >-
        Mode d’application des types de caractères dans la complexité du mot de
        passe
      enum:
        - all
        - three_of_four
      type: string
    PasswordCharacterTypeEnum:
      description: Type de caractères pour les exigences de complexité du mot de passe
      enum:
        - uppercase
        - lowercase
        - number
        - special
      type: string
    PasswordIdenticalCharactersEnum:
      description: Indique s’il faut autoriser 3 caractères identiques consécutifs ou plus
      enum:
        - allow
        - block
      type: string
    PasswordMaxLengthExceededEnum:
      description: Comportement lorsque le mot de passe dépasse la longueur maximale
      enum:
        - truncate
        - error
      type: string
    PasswordSequentialCharactersEnum:
      description: Indique s’il faut autoriser les caractères séquentiels
      enum:
        - allow
        - block
      type: string
    PasswordDictionaryDefaultEnum:
      description: >-
        Dictionnaire par défaut à utiliser pour vérifier les mots de passe
        faibles
      enum:
        - en_10k
        - en_100k
      type: string
  headers:
    LocationHeader:
      description: URL de la ressource de méthode d’authentification.
      examples:
        create:
          summary: >-
            URL Location d’une méthode d’authentification par clé d’accès
            nouvellement créée, mais non vérifiée
          value: https://auth0.auth0.com/me/v1/authentication-methods/passkey%7Cnew
        verify:
          summary: >-
            URL Location d’une méthode d’authentification par clé d’accès
            nouvellement vérifiée
          value: >-
            https://auth0.auth0.com/me/v1/authentication-methods/passkey%7Cdev_XXXXXXXXXXXXXXXX
      required: true
      schema:
        format: uri
        type: string
    XRateLimitLimitHeader:
      description: >-
        Le nombre maximal de requêtes autorisées pendant la fenêtre de
        limitation
      required: true
      schema:
        type: number
    XRateLimitRemainingHeader:
      description: >-
        Le nombre de requêtes restantes dans la fenêtre actuelle avant qu’elles
        ne soient rejetées
      required: true
      schema:
        type: number
    XRateLimitResetHeader:
      description: >-
        L’heure prévue (sous forme d’horodatage UNIX, en secondes) à laquelle le
        réservoir sera réapprovisionné
      required: true
      schema:
        type: number
    RetryAfterHeader:
      description: >-
        Le nombre de secondes que le client doit attendre avant d’effectuer une
        nouvelle requête
      required: true
      schema:
        type: number
    XAuth0ErrorKindHeader:
      description: >-
        Indique si la limite de débit dépassée est une limite globale (par
        locataire).
      schema:
        const: global-rate-limit
        type: string
  responses:
    BadRequest:
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
      description: Entrée non conforme au schéma.
    Unauthorized:
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
      description: Non autorisé.
    Forbidden:
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
      description: Interdit.
    UnsupportedMediaType:
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
      description: Type de média non pris en charge.
    TooManyRequests:
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
      description: Trop de requêtes.
      headers:
        retry-after:
          $ref: '#/components/headers/RetryAfterHeader'
        x-auth0-error-kind:
          $ref: '#/components/headers/XAuth0ErrorKindHeader'
        x-ratelimit-limit:
          $ref: '#/components/headers/XRateLimitLimitHeader'
        x-ratelimit-remaining:
          $ref: '#/components/headers/XRateLimitRemainingHeader'
        x-ratelimit-reset:
          $ref: '#/components/headers/XRateLimitResetHeader'
  securitySchemes:
    Bearer-DPoP:
      description: >-
        Les jetons Bearer et DPoP sont pris en charge selon la configuration de
        l’API
      scheme: bearer
      type: http

````