> ## 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.

> Lock comprend de nombreuses options de configuration qui vous permettent de modifier le comportement, l’apparence et la connectivité du widget Lock. Cette ressource vous fournit les détails sur ces options!

# Options de configuration de Lock

export const AuthCodeBlock = ({filename, icon, language, highlight, children}) => {
  const [displayText, setDisplayText] = useState(children);
  const [copyText, setCopyText] = useState(children);
  const wrapperRef = React.useRef(null);
  useEffect(() => {
    let unsubscribe = null;
    function init() {
      if (!window.autorun || !window.rootStore) {
        return;
      }
      unsubscribe = window.autorun(() => {
        let processedChildrenForDisplay = children;
        let processedChildrenForCopy = children;
        for (const [key, value] of window.rootStore.variableStore.values.entries()) {
          const escapedKey = key.replaceAll(/[.*+?^${}()|[\]\\]/g, (String.raw)`\$&`);
          let displayValue = value;
          if (key === "{yourClientSecret}" && value !== "{yourClientSecret}") {
            displayValue = value.substring(0, 3) + "*****MASKED*****";
          }
          processedChildrenForDisplay = processedChildrenForDisplay.replaceAll(new RegExp(escapedKey, "g"), displayValue);
          processedChildrenForCopy = processedChildrenForCopy.replaceAll(new RegExp(escapedKey, "g"), value);
        }
        setDisplayText(processedChildrenForDisplay);
        setCopyText(processedChildrenForCopy);
      });
    }
    if (window.rootStore) {
      init();
    } else {
      window.addEventListener("adu:storeReady", init);
    }
    return () => {
      window.removeEventListener("adu:storeReady", init);
      unsubscribe?.();
    };
  }, [children]);
  useEffect(() => {
    if (!wrapperRef.current) return;
    const originalWriteText = navigator.clipboard.writeText.bind(navigator.clipboard);
    let isOverriding = false;
    const handleClick = e => {
      const button = e.target.closest('[data-testid="copy-code-button"]');
      if (!button || !wrapperRef.current.contains(button)) return;
      isOverriding = true;
      navigator.clipboard.writeText = text => {
        if (isOverriding) {
          isOverriding = false;
          navigator.clipboard.writeText = originalWriteText;
          return originalWriteText(copyText);
        }
        return originalWriteText(text);
      };
      setTimeout(() => {
        if (isOverriding) {
          isOverriding = false;
          navigator.clipboard.writeText = originalWriteText;
        }
      }, 100);
    };
    const wrapper = wrapperRef.current;
    wrapper.addEventListener('click', handleClick, true);
    return () => {
      wrapper.removeEventListener('click', handleClick, true);
      if (navigator.clipboard.writeText !== originalWriteText) {
        navigator.clipboard.writeText = originalWriteText;
      }
    };
  }, [copyText]);
  return <div ref={wrapperRef}>
      <CodeBlock filename={filename} icon={icon} language={language} lines highlight={highlight}>
        {displayText}
      </CodeBlock>
    </div>;
};

Lock peut être configuré au moyen du paramètre `options` transmis au constructeur. Ces options peuvent modifier le comportement du widget Lock, la façon dont il gère les connexions, les champs d’inscription supplémentaires requis pour votre projet, la langue et les chaînes de texte, les couleurs et les images du widget, et bien plus encore. Consultez l’index ci-dessous si vous savez ce que vous cherchez, ou parcourez les options pour en savoir plus.

<div id="ui">
  ## UI
</div>

| Option                                                                 | Description                                                                                                                                                                 |
| ---------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [allowAutocomplete](#allowautocomplete-boolean-)                       | Active ou désactive l’autocomplétion dans les champs de courriel ou de nom d’utilisateur                                                                                    |
| [allowPasswordAutocomplete](#allowpasswordautocomplete-boolean-)       | Active ou désactive l’autocomplétion dans le champ du mot de passe                                                                                                          |
| [allowShowPassword](#allowshowpassword-boolean-)                       | Indique si l’utilisateur peut choisir d’afficher le mot de passe pendant la saisie                                                                                          |
| [allowedConnections](#allowedconnections-array-)                       | Liste des connexions disponibles pour l’authentification                                                                                                                    |
| [autoclose](#autoclose-boolean-)                                       | Indique si Lock se ferme après l’ouverture de session                                                                                                                       |
| [autofocus](#autofocus-boolean-)                                       | Indique si le curseur est placé dans le premier champ de saisie                                                                                                             |
| [avatar](#avatar-object-)                                              | Indique si un avatar et un nom d’utilisateur doivent être affichés dans l’en-tête de Lock une fois qu’un courriel ou un nom d’utilisateur a été saisi, et comment l’obtenir |
| [closable](#closable-boolean-)                                         | Détermine si Lock peut être fermé                                                                                                                                           |
| [container](#container-string-)                                        | Élément HTML dans lequel Lock sera affiché. Cela fait apparaître Lock directement dans la page plutôt que dans une fenêtre modale                                           |
| [flashMessage](#flashmessage-object-)                                  | Affiche un message flash `error` ou `success` lorsque Lock est affiché                                                                                                      |
| [language](#language-string-)                                          | Indique la langue du widget                                                                                                                                                 |
| [languageDictionary](#languagedictionary-object-)                      | Personnalise le texte utilisé pour les éléments du widget (comme les libellés et les textes indicatifs)                                                                     |
| [popupOptions](#popupoptions-object-)                                  | Personnalise l’emplacement de la fenêtre contextuelle à l’écran                                                                                                             |
| [rememberLastLogin](#rememberlastlogin-boolean-)                       | Indique s’il faut afficher ou non un écran qui vous permet d’ouvrir rapidement une session avec le compte utilisé la dernière fois                                          |
| [scrollGlobalMessagesIntoView](#scrollglobalmessagesintoview-boolean-) | Indique si un globalMessage doit être défilé jusqu’à la zone visible de l’utilisateur                                                                                       |

<div id="theme">
  ## Thème
</div>

Les options du thème sont regroupées dans la propriété `theme` de l’objet `options`.

| Option                                               | Description                                                   |
| ---------------------------------------------------- | ------------------------------------------------------------- |
| [authButtons](#authbuttons-object-)                  | Personnaliser l’apparence des boutons de certaines connexions |
| [labeledSubmitButton](#labeledsubmitbutton-boolean-) | indique si le bouton d’envoi comporte du texte ou non         |
| [logo](#logo-string-)                                | Logo à utiliser                                               |
| [primaryColor](#primarycolor-string-)                | Couleur du bouton principal dans le widget                    |

<div id="authentication">
  ## Authentification
</div>

Les options d’authentification sont regroupées dans la propriété `auth` de l’objet `options`.

| Option                                        | Description                                                                                                                                                                                                                                                                                                     |
| --------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [audience](#audience-string-)                 | L’API qui utilisera votre <Tooltip tip="Jeton d’accès : justificatif d’autorisation, sous la forme d’une chaîne opaque ou d’un JWT, utilisé pour accéder à une API." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=Access+Token">Jeton d’accès</Tooltip>                                              |
| [autoParseHash](#autoparsehash-boolean-)      | Indique s’il faut analyser automatiquement le hash et continuer                                                                                                                                                                                                                                                 |
| [connectionScopes](#connectionscopes-object-) | Spécifiez les <Tooltip tip="Scope : mécanisme qui détermine les actions que les applications peuvent effectuer au nom d’un utilisateur avec des informations créées précédemment dans une ressource en ligne." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=scopes">scopes</Tooltip> de la connexion |
| [params](#params-object-)                     | Option permettant d’envoyer des paramètres lors de la connexion                                                                                                                                                                                                                                                 |
| [redirect](#redirect-boolean-)                | Indique s’il faut utiliser le mode de redirection                                                                                                                                                                                                                                                               |
| [redirectUrl](#redirecturl-string-)           | L’URL vers laquelle rediriger après l’authentification                                                                                                                                                                                                                                                          |
| [responseMode](#responsemode-string-)         | Option permettant d’envoyer la réponse au format POST                                                                                                                                                                                                                                                           |
| [responseType](#responsetype-string-)         | Réponse sous forme de code ou de jeton                                                                                                                                                                                                                                                                          |
| [sso](#sso-boolean-)                          | Détermine si l’authentification unique (SSO) est activée dans Lock                                                                                                                                                                                                                                              |

<div id="database">
  ## Base de données
</div>

| Option                                                          | Description                                                                              |
| --------------------------------------------------------------- | ---------------------------------------------------------------------------------------- |
| [additionalSignUpFields](#additionalsignupfields-array-)        | Champs supplémentaires recueillis à l’inscription                                        |
| [allowLogin](#allowlogin-boolean-)                              | Indique s’il faut autoriser la connexion dans le widget                                  |
| [allowForgotPassword](#allowforgotpassword-boolean-)            | Indique s’il faut autoriser l’option « mot de passe oublié » dans le widget              |
| [allowSignUp](#allowsignup-boolean-)                            | Indique s’il faut autoriser l’inscription dans le widget                                 |
| [defaultDatabaseConnection](#defaultdatabaseconnection-string-) | Connexion à la base de données affichée par défaut                                       |
| [initialScreen](#initialscreen-string-)                         | Écran à afficher à l’ouverture du widget                                                 |
| [loginAfterSignUp](#loginaftersignup-boolean-)                  | Après l’inscription, indique s’il faut connecter automatiquement l’utilisateur           |
| [forgotPasswordLink](#forgotpasswordlink-string-)               | Lien vers une page personnalisée de réinitialisation du mot de passe                     |
| [showTerms](#showterms-boolean-)                                | Indique si les conditions d’inscription doivent être affichées                           |
| [mustAcceptTerms](#mustacceptterms-boolean-)                    | Indique si les conditions doivent être acceptées (case à cocher)                         |
| [prefill](#prefill-object-)                                     | Valeurs préremplies pour les champs courriel/nom d’utilisateur                           |
| [signUpLink](#signuplink-string-)                               | Définit une URL personnalisée à ouvrir lorsqu’on clique sur « s’inscrire »               |
| [usernameStyle](#usernamestyle-string-)                         | Limite le champ nom d’utilisateur à n’accepter que des valeurs « username » ou « email » |

<div id="enterprise">
  ## Entreprise
</div>

| Option                                                              | Description                                   |
| ------------------------------------------------------------------- | --------------------------------------------- |
| [defaultEnterpriseConnection](#defaultenterpriseconnection-string-) | Spécifie une connexion s’il y en a plus d’une |

<div id="passwordless">
  ## Passwordless
</div>

| Option                                            | Description                                                                                                                                                                                                                                                                             |
| ------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [passwordlessMethod](#passwordlessmethod-string-) | Lorsque vous utilisez `Auth0LockPasswordless` avec une connexion par courriel, vous pouvez utiliser cette option pour choisir d’envoyer un [code](/fr-CA/docs/authenticate/passwordless) ou un [lien magique](/fr-CA/docs/authenticate/passwordless) afin d’authentifier l’utilisateur. |

<div id="other">
  ### Autres
</div>

| Option                                                | Description                                                                                                 |
| ----------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
| [configurationBaseUrl](#configurationbaseurl-string-) | Remplace l’URL de base de votre application                                                                 |
| [languageBaseUrl](#languagebaseurl-string-)           | Remplace l’URL de base de votre fichier de langue                                                           |
| [hashCleanup](#hashcleanup-boolean-)                  | Remplace la suppression par défaut du fragment dans l’URL                                                   |
| [connectionResolver](#connectionresolver-function-)   | Fonction de rappel facultative pour choisir une connexion en fonction des informations du nom d’utilisateur |

***

<div id="ui-options">
  ## Options de l’interface utilisateur
</div>

### allowAutocomplete {Boolean}

Détermine si les champs de courriel ou de nom d’utilisateur permettent la saisie semi-automatique (`<input autocomplete />`). La valeur par défaut est `false`.

`allowAutocomplete: true`

### allowPasswordAutocomplete {Boolean}

Détermine si le champ de mot de passe autorise ou non la saisie semi-automatique (`<input autocomplete />`). La valeur par défaut est `false`.

Définissez `allowPasswordAutocomplete` sur `true` pour prendre en charge les gestionnaires de mots de passe et éviter d’autres comportements indésirables.

`allowPasswordAutocomplete: true`

### allowShowPassword {Boolean}

Cette option détermine s’il faut ou non ajouter une case à cocher à l’interface utilisateur qui, lorsqu’elle est sélectionnée, permet à l’utilisateur d’afficher son mot de passe pendant qu’il le saisit. Par défaut, cette option est définie sur `false`.

`allowShowPassword: true`

Lock avec `allowShowPassword` défini sur `true` et activé pour afficher le mot de passe :

<Frame>
  <img src="https://mintcdn.com/translations/6GE5Z24GDCZehiJ9/docs/images/cdy7uua7fh8z/6G8LJaNjaMl5zUrwGi5UJQ/44dc951b70077b0ec6bc04d2f0413b12/lock-allowshowpassword.png?fit=max&auto=format&n=6GE5Z24GDCZehiJ9&q=85&s=135b5d9dd218a02d5dadc2a2df7c6181" alt="Option Lock : autoriser l’affichage du mot de passe" width="2070" height="1978" data-path="docs/images/cdy7uua7fh8z/6G8LJaNjaMl5zUrwGi5UJQ/44dc951b70077b0ec6bc04d2f0413b12/lock-allowshowpassword.png" />
</Frame>

### allowedConnections {Array}

Tableau des connexions utilisées pour les actions `signin|signup|reset`. Par défaut, toutes les connexions activées sont utilisées.

`allowedConnections: ['Username-Password-Authentication']`

`allowedConnections: ['twitter', 'facebook', 'linkedin']`

`allowedConnections: ['qraftlabs.com']`

Exemples de `allowedConnections` :

<Frame>
  <img src="https://mintcdn.com/translations/eVsQcTnbClN-oB7d/docs/images/cdy7uua7fh8z/1mllPDLFCCETwQ9MeGEf3W/763728971302656618ef3bd131ab83b1/lock-allowedconnections-database.png?fit=max&auto=format&n=eVsQcTnbClN-oB7d&q=85&s=28e9b9aacbbe08e3939d78e1e186daf5" alt="Option Lock : connexions autorisées - base de données" width="2070" height="1978" data-path="docs/images/cdy7uua7fh8z/1mllPDLFCCETwQ9MeGEf3W/763728971302656618ef3bd131ab83b1/lock-allowedconnections-database.png" />
</Frame>

<Frame>
  <img src="https://mintcdn.com/translations/c0RQ9V0YAcT0-8l5/docs/images/cdy7uua7fh8z/7uYN4ebrLLM8bjx1fee8j0/1e716cca3e1bae990063e9226dfe9ac2/lock-allowedconnections-social.png?fit=max&auto=format&n=c0RQ9V0YAcT0-8l5&q=85&s=cdc2e3a763eafe20f95936c2b3b7b7c5" alt="Option Lock : connexions autorisées - réseaux sociaux" width="2070" height="1978" data-path="docs/images/cdy7uua7fh8z/7uYN4ebrLLM8bjx1fee8j0/1e716cca3e1bae990063e9226dfe9ac2/lock-allowedconnections-social.png" />
</Frame>

### autoclose {Boolean}

Détermine si Lock se fermera automatiquement après une connexion réussie. La valeur par défaut est `false`. Si Lock n’est pas `closable`, il ne se fermera pas, même si cette option est définie à `true`.

`autoclose: true`

### autofocus {Boolean}

Si cette valeur est `true`, le focus est placé sur le premier champ du widget. La valeur par défaut est `false` lors du rendu sur un appareil mobile ou si une option `container` est fournie; dans tous les autres cas, la valeur par défaut est `true`.

`autofocus: false`

### avatar {Object}

Par défaut, Gravatar sert à récupérer l’avatar et le nom d’affichage de l’utilisateur, mais vous pouvez aussi les obtenir d’une autre source grâce à l’option `avatar`.

```js lines theme={null}
var options = {
  avatar: {
    url: function(email, cb) {
      // Obtenir l'URL de l'avatar pour le courriel saisi par l'utilisateur, Lock
      // préchargera l'image avant de l'afficher.
      // Notez qu'en cas d'erreur, vous appelez cb avec l'erreur dans
      // le premier argument au lieu de `null`.
      var url = obtainAvatarUrl(email);
      cb(null, url);
    },
    displayName: function(email, cb) {
      // Obtenir le nom d'affichage pour le courriel saisi par l'utilisateur.
      // Notez qu'en cas d'erreur, vous appelez cb avec l'erreur dans
      // le premier argument au lieu de `null`.
      var displayName = obtainDisplayName(email);
      cb(null, displayName);
    }
  }
};
```

Ou, si vous ne souhaitez afficher aucun avatar, passez simplement `null`.

`avatar: null`

Comportement par défaut avec Gravatar :

<Frame>
  <img src="https://mintcdn.com/translations/6GE5Z24GDCZehiJ9/docs/images/cdy7uua7fh8z/69Nz0QoQifPWpfBZwX15J0/204aad93cde406f0ed3771ce38766f56/lock-avatar.png?fit=max&auto=format&n=6GE5Z24GDCZehiJ9&q=85&s=9b4978850a31edf65e76a79f9b4b9ca9" alt="Option Lock : avatar" width="2070" height="1978" data-path="docs/images/cdy7uua7fh8z/69Nz0QoQifPWpfBZwX15J0/204aad93cde406f0ed3771ce38766f56/lock-avatar.png" />
</Frame>

### closable {Boolean}

Détermine si Lock peut être fermé. Lorsque l’option `container` est fournie, cette valeur est toujours `false`; sinon, la valeur par défaut est `true`.

`closable: false`

<Frame>
  <img src="https://mintcdn.com/translations/Dcx0M11uuptU53TX/docs/images/cdy7uua7fh8z/2qwXtPQev1nlpyOQauXKBO/f967e1157972ecbf5b030b3be3600f2e/lock-closable.png?fit=max&auto=format&n=Dcx0M11uuptU53TX&q=85&s=3a0620edd47667427831699c2e1844f8" alt="Option Lock : Closable" width="2070" height="1978" data-path="docs/images/cdy7uua7fh8z/2qwXtPQev1nlpyOQauXKBO/f967e1157972ecbf5b030b3be3600f2e/lock-closable.png" />
</Frame>

### container {String}

L’`id` de l’élément html où le widget sera affiché.

Le widget s’affiche ainsi directement dans votre `div`, plutôt que dans une fenêtre modale contextuelle.

```html lines theme={null}
<div id="hiw-login-container"></div>

<script>
  var options = {
    container: 'hiw-login-container'
  };

  // initialiser
  var lock = new Auth0Lock('xxxxxx', '<account>.auth0.com', options);

  // afficher
  lock.show();
</script>
```

<Frame>
  <img src="https://mintcdn.com/translations/MV7tE-x71x8RWRES/docs/images/cdy7uua7fh8z/5L4S47Yfset2DR9pjcqVrX/1c4d1928cf75acf40129ffd01394bf33/lock-container.png?fit=max&auto=format&n=MV7tE-x71x8RWRES&q=85&s=07b39e581ebe285a055bd63467f41043" alt="Option Lock : conteneur" width="2070" height="1978" data-path="docs/images/cdy7uua7fh8z/5L4S47Yfset2DR9pjcqVrX/1c4d1928cf75acf40129ffd01394bf33/lock-container.png" />
</Frame>

### flashMessage {Object}

Affiche un message instantané de type `error` ou `success` lorsque Lock s’affiche. Cet objet comprend les propriétés suivantes :

* type \{String}: Le type de message; les types pris en charge sont `error`, `info` et `success`
* text \{String}: Le texte à afficher.

```js lines theme={null}
var options = {
  flashMessage: {
    type: 'success',
    text: 'Welcome!'
  }
};
```

### language {String}

Indique la langue du widget. La valeur par défaut est « en ». Consultez le [répertoire d’internationalisation](https://github.com/auth0/lock/blob/master/src/i18n/) pour voir la liste à jour des langues prises en charge.

`language: 'es'`

<Frame>
  <img src="https://mintcdn.com/translations/3nS3prIggmJG9TUI/docs/images/cdy7uua7fh8z/3u3lytCUBDbcKmXFV34OUv/5cf5d7e1af9593a3b094f32815a4da11/lock-language.png?fit=max&auto=format&n=3nS3prIggmJG9TUI&q=85&s=3016e0e1ba213c6a5042bad08d7d78c6" alt="Option Lock : langue" width="2070" height="1978" data-path="docs/images/cdy7uua7fh8z/3u3lytCUBDbcKmXFV34OUv/5cf5d7e1af9593a3b094f32815a4da11/lock-language.png" />
</Frame>

### languageDictionary {Object}

Permet de personnaliser chaque texte affiché dans Lock. La valeur par défaut est {"{}"}. Consultez la [spécification anglaise du dictionnaire de langue](https://github.com/auth0/lock/blob/master/src/i18n/en.js) pour obtenir la liste complète des valeurs `languageDictionary` que cet objet permet de modifier.

```js lines theme={null}
var options = {
  languageDictionary: {
    emailInputPlaceholder: "something@youremail.com",
    title: "Log me in"
  },
};
```

<Frame>
  <img src="https://mintcdn.com/translations/MV7tE-x71x8RWRES/docs/images/cdy7uua7fh8z/5203ofwtagtIKGT4HnIPmk/8ad9cdd151a2cdb18b8a42ee47dbf679/lock-languagedictionary.png?fit=max&auto=format&n=MV7tE-x71x8RWRES&q=85&s=eaa20ab21bb6298ccb98069ad3ff280e" alt="Option Lock : dictionnaire de langue" width="2070" height="1978" data-path="docs/images/cdy7uua7fh8z/5203ofwtagtIKGT4HnIPmk/8ad9cdd151a2cdb18b8a42ee47dbf679/lock-languagedictionary.png" />
</Frame>

Consultez également la page [Personnaliser les messages d’erreur](/fr-CA/docs/customize/login-pages/classic-login/customize-lock-error-messages) ou la page [Internationalisation](/fr-CA/docs/customize/internationalization-and-localization/lock-internationalization) pour en savoir plus sur l’utilisation de l’option `languageDictionary`.

### popupOptions {Object}

Permet de personnaliser l’emplacement de la fenêtre contextuelle à l’écran. Toute option de positionnement et de taille acceptée par `window.open` est prise en charge. La valeur par défaut est {"{}"}.

Options des fonctionnalités de `window.open`. Cela s’applique uniquement si `redirect` est défini sur `false`.

```js lines theme={null}
var options = {
  auth: {
      redirect: false
  },
  popupOptions: { width: 300, height: 400, left: 200, top: 300 }
};
```

### rememberLastLogin {Boolean}

Détermine s’il faut ou non afficher un écran qui vous permet de vous connecter rapidement avec le compte utilisé la dernière fois.
Demande les données de <Tooltip tip="Single Sign-On (SSO) : service qui, après qu’un utilisateur a ouvert une session dans une application, connecte automatiquement cet utilisateur à d’autres applications." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=Single+Sign-on">Single Sign-on</Tooltip> (SSO) et active le message **La dernière fois que vous vous êtes connecté avec**. La valeur par défaut est `true`. Ces informations proviennent de la session Auth0 de l’utilisateur; cette fonctionnalité reste donc disponible aussi longtemps que sa session Auth0 est valide (ce qui peut être configuré).

`rememberLastLogin: false`

Les nouveaux locataires [ont Seamless SSO activé automatiquement](/fr-CA/docs/get-started/tenant-settings/enable-sso-for-legacy-tenants). Lorsque cette option est activée, l’option `rememberLastLogin` n’est plus pertinente, car s’il existe déjà une session, la page <Tooltip tip="Universal Login : votre application redirige vers Universal Login, hébergé sur le serveur d’autorisation d’Auth0, pour vérifier l’identité d’un utilisateur." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=Universal+Login">Universal Login</Tooltip> ne s’affichera pas du tout. L’utilisation de Seamless SSO est fortement recommandée, car elle offre une expérience d’authentification fluide : les utilisateurs se connectent une seule fois et n’ont plus à saisir de nouveau leurs identifiants lorsqu’ils passent d’une application que vous avez créée à une application tierce. Si l’utilisateur n’est pas connecté, il sera redirigé vers l’écran de connexion, comme prévu. De plus, le message **La dernière fois que vous vous êtes connecté avec** ne sera pas disponible dans les circonstances suivantes :

* Vous avez utilisé Lock dans une [page de connexion hébergée](/fr-CA/docs/authenticate/login/auth0-universal-login), avec une session établie à l’aide de l’[authentification Passwordless](/fr-CA/docs/libraries/lock/lock-configuration#passwordlessmethod-string-).
* Vous avez utilisé Lock dans un scénario de [connexion intégrée](/fr-CA/docs/authenticate/login/universal-vs-embedded-login) où `responseType: code` (indiquant le [flux de code d’autorisation](/fr-CA/docs/get-started/authentication-and-authorization-flow/authorization-code-flow), utilisé pour les applications Web traditionnelles).

### scrollGlobalMessagesIntoView {Boolean}

Indique si un `globalMessage` doit être amené dans la zone visible de l’utilisateur par défilement. La valeur par défaut est `true`.

`scrollGlobalMessagesIntoView: false`

<div id="theme-options">
  ## Options de thème
</div>

Les options de thème sont regroupées dans la propriété `theme` de l’objet `options`.

```js lines theme={null}
var options = {
  theme: {
    labeledSubmitButton: false,
    logo: "https://example.com/assets/logo.png",
    primaryColor: "green",
    authButtons: {
      connectionName: {
        displayName: "...",
        primaryColor: "...",
        foregroundColor: "...",
        icon: "https://.../logo.png"
      }
    }
  }
};
```

### authButtons {Object}

Permet de personnaliser les boutons de Lock pour des connexions OAuth2 personnalisées. Chaque connexion personnalisée dont vous souhaitez personnaliser le bouton doit être indiquée par son nom, chacune avec son propre ensemble de paramètres. Les paramètres personnalisables sont indiqués ci-dessous :

* **displayName** \{String}: Le nom à afficher à la place du nom de la connexion lors de la création du titre du bouton, par exemple `LOGIN WITH MYCONNECTION` pour la connexion).
* **primaryColor** \{String}: La couleur d’arrière-plan du bouton. La valeur par défaut est `#eb5424`.
* **foregroundColor** \{String}: La couleur du texte du bouton. La valeur par défaut est `#FFFFFF`.
* **icon** \{String}: L’URL de l’icône de cette connexion. Par exemple : `http://site.com/logo.png`.

```js lines theme={null}
var options = {
  theme: {
    authButtons: {
      "testConnection": {
        displayName: "Test Conn",
        primaryColor: "#b7b7b7",
        foregroundColor: "#000000",
        icon: "http://example.com/icon.png"
      },
      "testConnection2": {
        primaryColor: "#000000",
        foregroundColor: "#ffffff",
      }
    }
  }
};
```

### labeledSubmitButton {Boolean}

Cette option indique si le bouton d’envoi doit comporter un libellé, et sa valeur par défaut est `true`. Lorsqu’elle est définie sur `false`, une icône s’affiche à la place.

```js lines theme={null}
var options = {
  theme: {
    labeledSubmitButton: false
  }
};
```

<Frame>
  <img src="https://mintcdn.com/translations/MV7tE-x71x8RWRES/docs/images/cdy7uua7fh8z/5PNCvsbYa98pKZwWHVPS9S/39cb5ac63818ec5558c451b1e37f735f/lock-theme-labeledsubmitbutton.png?fit=max&auto=format&n=MV7tE-x71x8RWRES&q=85&s=f32504b05390f9d4fac08c28c38208d7" alt="Option Lock : bouton Envoyer avec libellé" width="2070" height="1978" data-path="docs/images/cdy7uua7fh8z/5PNCvsbYa98pKZwWHVPS9S/39cb5ac63818ec5558c451b1e37f735f/lock-theme-labeledsubmitbutton.png" />
</Frame>

Si l’option label est définie sur true, ce qui est la valeur par défaut, le texte du libellé peut être personnalisé à l’aide de l’option [languageDictionary](#languagedictionary-object-).

### logo {String}

La valeur de `logo` est l’URL d’une image qui sera placée dans l’en-tête de Lock; par défaut, le logo d’Auth0 est utilisé. Une hauteur maximale de `58px` est recommandée pour offrir une meilleure expérience utilisateur.

```js lines theme={null}
var options = {
  theme: {
    logo: 'https://example.com/logo.png'
  }
};
```

<Frame>
  <img src="https://mintcdn.com/translations/mMSz-RNYLuOm2GmQ/docs/images/cdy7uua7fh8z/FdOAKKy71rTbFjIlZEL8D/2eef96008095d85388daaa461707901d/lock-theme-logo.png?fit=max&auto=format&n=mMSz-RNYLuOm2GmQ&q=85&s=893afa574173351c9dd2553ae6b3e50a" alt="Personnalisation de l’interface utilisateur de Lock - Logo" width="2070" height="1978" data-path="docs/images/cdy7uua7fh8z/FdOAKKy71rTbFjIlZEL8D/2eef96008095d85388daaa461707901d/lock-theme-logo.png" />
</Frame>

### primaryColor {String}

La propriété `primaryColor` définit la couleur principale de Lock; toutes les couleurs utilisées dans le widget sont calculées à partir de celle-ci. Cette option est utile lorsque vous fournissez un `logo` personnalisé, afin de garantir que toutes les couleurs s’harmonisent bien avec la palette de couleurs du `logo`. La valeur par défaut est `#ea5323`.

```js lines theme={null}
var options = {
  theme: {
    logo: 'https://example.com/logo.png',
    primaryColor: '#31324F'
  }
};
```

<Frame>
  <img src="https://mintcdn.com/translations/eVsQcTnbClN-oB7d/docs/images/cdy7uua7fh8z/1qQjeTmXJyIziv400VPaOn/48dd3cb8a72a6e88b2634b4b8a8bed63/lock-theme-primarycolor.png?fit=max&auto=format&n=eVsQcTnbClN-oB7d&q=85&s=80813e2e359f17629e426cfe972af428" alt="Personnalisation de l’interface Lock - couleur principale" width="2070" height="1978" data-path="docs/images/cdy7uua7fh8z/1qQjeTmXJyIziv400VPaOn/48dd3cb8a72a6e88b2634b4b8a8bed63/lock-theme-primarycolor.png" />
</Frame>

<div id="authentication-options">
  ## Options d’authentification
</div>

Les options d’authentification sont regroupées dans la propriété `auth` de l’objet `options`.

Le scope par défaut utilisé par Lock est `openid profile email`.

```js lines theme={null}
var options = {
  auth: {
   params: {
    param1: "value1",
    scope: "openid profile email"
   },
   autoParseHash: true,
   redirect: true,
   redirectUrl: "some url",
   responseMode: "form_post",
   responseType: "token",
   sso: true,
   connectionScopes: {
    connectionName: [ 'scope1', 'scope2' ]
   }
  }
};
```

### audience {String}

L’option `audience` indique l’API qui utilisera le <Tooltip tip="Jeton d’accès : justificatif d’autorisation, sous la forme d’une chaîne opaque ou d’un JWT, utilisé pour accéder à une API." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=Access+Token">Jeton d’accès</Tooltip> reçu après l’authentification.

export const codeExample = `var options = {
  auth: {
    audience: 'https://{yourDomain}/userinfo',
  }
}`;

<AuthCodeBlock children={codeExample} language="js" />

### autoParseHash {Boolean}

Lorsque `autoParseHash` est défini à `true`, Lock analysera la chaîne `window.location.hash` lors de son initialisation. S’il est défini à `false`, vous devrez reprendre manuellement l’authentification à l’aide de la méthode [resumeAuth](/fr-CA/docs/libraries/lock/lock-api-reference).

```js lines theme={null}
var options = {
  auth: {
    autoParseHash: false
  }
};
```

### connectionScopes {Object}

Cette option vous permet de définir les scopes à envoyer à la connexion sociale OAuth2 pour l’authentification.

```js lines theme={null}
var options = {
  auth: {
    connectionScopes: {
      'facebook': ['scope1', 'scope2']
    }
  }
};
```

Une liste des scopes précis associés à vos connexions sociales peut être obtenue auprès du fournisseur concerné. Par exemple, la documentation [Facebook for Developers](https://developers.facebook.com/docs/facebook-login/permissions/) contient une liste des autorisations distinctes pouvant être demandées pour votre connexion.

### params {Object}

Vous pouvez envoyer des paramètres au moment de démarrer une connexion en les ajoutant à l’objet d’options. L’exemple ci-dessous ajoute un paramètre `state` avec une valeur égale à `foo`, ainsi qu’un paramètre `scope` (qui comprend le `scope` ainsi que les attributs demandés).

```js lines theme={null}
var options = {
  auth: {
    params: {
      state: 'foo',
      scope: 'openid email user_metadata app_metadata picture'
    }
  }
};
```

Pour en savoir davantage sur les paramètres pris en charge, consultez [Lock Authentication Parameters](/fr-CA/docs/libraries/lock/lock-authentication-parameters).

### redirect {Boolean}

La valeur par défaut est true. Lorsqu’elle est définie sur true, le mode de redirection est utilisé. Lorsqu’elle est définie sur false, le [mode popup](/fr-CA/docs/libraries/lock/lock-authentication-modes) est utilisé.

```js lines theme={null}
var options = {
  auth: {
    redirect: false
  }
};
```

### redirectUrl {String}

URL vers laquelle Auth0 redirigera l’utilisateur après l’authentification. La valeur par défaut est la chaîne vide "" (aucune URL de redirection).

```js lines theme={null}
var options = {
  auth: {
    redirectUrl: 'http://testurl.com'
  }
};
```

Lorsque `redirectUrl` est fourni (c’est-à-dire qu’il est défini sur une valeur non vide), l’option `responseType` prendra par défaut la valeur `code` si elle n’est pas définie manuellement.

### responseMode {String}

Doit être défini à `"form_post"` si vous voulez que le code ou le jeton soit transmis à `redirectUrl` au moyen d’une requête HTTP POST, plutôt que d’être inclus dans les parties requête ou fragment de l’URL.

Sinon, cette option doit être omise; par défaut, elle l’est.

```js lines theme={null}
var options = {
  auth: {
    responseMode: 'form_post'
  }
};
```

### responseType {String}

La valeur de `responseType` doit être définie sur "token" pour les applications monopages, et sur "code" dans les autres cas. La valeur par défaut est "code" lorsque redirectUrl est fourni, et "token" sinon.

```js lines theme={null}
var options = {
  auth: {
    responseType: 'token'
  }
};
```

Lorsque `responseType` est défini sur `code`, Lock n’affichera jamais le message **La dernière fois, vous vous êtes connecté avec**, et demandera toujours à l’utilisateur de saisir ses identifiants.

## sso {Boolean}

La valeur par défaut est `true`. Lorsque cette option est définie à `true`, elle active l’[authentification unique (SSO)](/fr-CA/docs/authenticate/single-sign-on) dans Lock.

```js lines theme={null}
var options = {
  auth: {
    sso: false
  }
};
```

<div id="database-options">
  ## Options de base de données
</div>

### additionalSignUpFields {Array}

Vous pouvez ajouter des champs de saisie supplémentaires à l’écran d’inscription à l’aide de l’option `additionalSignUpFields`. Chaque option ajoutée de cette façon sera ensuite ajoutée au `user_metadata` de l’utilisateur. Pour en savoir plus, consultez [Comprendre le fonctionnement des métadonnées dans les profils d’utilisateur](/fr-CA/docs/manage-users/user-accounts/metadata). Chaque champ doit avoir un `name` et un `placeholder`, et vous pouvez aussi fournir une URL pour `icon`. Vous pouvez également définir la valeur initiale avec l’option `prefill`, qui peut être une chaîne contenant la valeur ou une fonction qui l’obtient. Les autres options dépendent du type de champ, défini au moyen de l’option `type`, dont la valeur par défaut est `"text"`.

<Card title="Option additionalSignUpFields destinée uniquement aux inscriptions avec base de données">
  Les `additionalSignUpFields` sont destinés uniquement aux inscriptions avec base de données. Si vous avez aussi des inscriptions sociales, vous pouvez demander les renseignements supplémentaires après l’inscription des utilisateurs (consultez cette [page sur l’inscription personnalisée](/fr-CA/docs/libraries/custom-signup) pour en savoir plus). Vous pouvez utiliser la clé i18n `databaseAlternativeSignupInstructions` pour afficher ces instructions.
</Card>

Les nouveaux champs s’affichent sous les champs de saisie standards de l’inscription, dans l’ordre où ils sont fournis.

<div id="text-fields">
  #### Champs de texte
</div>

Les champs de texte sont le type par défaut des champs d’inscription supplémentaires. Notez qu’il est également possible de fournir une fonction `validator`.

```js lines theme={null}
var options = {
  additionalSignUpFields: [{
    name: "address",
    placeholder: "enter your address",
    // Les propriétés suivantes sont facultatives
    icon: "https://example.com/assests/address_icon.png",
    prefill: "street 123",
    validator: function(address) {
      return {
         valid: address.length >= 10,
         hint: "Must have 10 or more chars" // facultatif
      };
    }
  },
  {
    name: "full_name",
    placeholder: "Enter your full name"
  }]
}
```

Si vous ne spécifiez pas de `validator`, le champ de texte sera **obligatoire**. Si vous voulez rendre le champ de texte facultatif, utilisez un validateur qui renvoie toujours `true`, comme ceci :

```js lines theme={null}
var options = {
  additionalSignUpFields: [{
    name: "favorite_color",
    placeholder: "Enter your favorite color (optional)",
    validator: function() { 
      return true;
    }
  }]
}
```

Si vous souhaitez enregistrer la valeur de l’attribut à la racine de votre profil, utilisez `storage: 'root'`. Seul un sous-ensemble de valeurs peut être stocké de cette manière. La liste des attributs pouvant être ajoutés à la racine de votre profil se trouve [ici](https://auth0.com/docs/api/management/v2#!/Users/patch_users_by_id). Par défaut, chaque champ d’inscription supplémentaire est stocké dans l’objet user\_metadata.

```js lines theme={null}
var options = {
  additionalSignUpFields: [{
    name: "name",
    storage: "root"
  }]
};
```

<Frame>
  <img src="https://mintcdn.com/translations/Dcx0M11uuptU53TX/docs/images/cdy7uua7fh8z/2KPDGZb3caq57caJ90w53k/e092bdb4a4d93589aa006f796ff20fca/lock-additionalsignupfields.png?fit=max&auto=format&n=Dcx0M11uuptU53TX&q=85&s=9561a129706338d29cd1edb29d026d2a" alt="Option Lock : champs d’inscription supplémentaires" width="2070" height="1978" data-path="docs/images/cdy7uua7fh8z/2KPDGZb3caq57caJ90w53k/e092bdb4a4d93589aa006f796ff20fca/lock-additionalsignupfields.png" />
</Frame>

<div id="select-field">
  #### Champ de liste déroulante
</div>

Le champ d’inscription `type: "select"` vous permet d’utiliser des éléments de liste déroulante afin que l’utilisateur puisse choisir une valeur.

```js lines theme={null}
var options = {
  additionalSignUpFields: [{
    type: "select",
    name: "location",
    placeholder: "choose your location",
    options: [
      {value: "us", label: "United States"},
      {value: "fr", label: "France"},
      {value: "ar", label: "Argentina"}
    ],
    // Les propriétés suivantes sont facultatives
    icon: "https://example.com/assests/location_icon.png",
    prefill: "us"
  }]
}
```

Les éléments du tableau `options` des champs `select` doivent respecter le format suivant :
`{label: “chaîne non vide”, value: “chaîne non vide”}`, et au moins une option doit être définie.

Les valeurs `options` et `prefill` peuvent être fournies à l’aide d’une fonction :

```js lines theme={null}
var options = {
  additionalSignUpFields: [{
    type: "select",
    name: "location",
    placeholder: "choose your location",
    options: function(cb) {
      // obtenir les options, en cas d'erreur, appelez cb avec l'erreur dans le
      // premier arg au lieu de null
      cb(null, options);
    },
    icon: "https://example.com/assests/location_icon.png",
    prefill: function(cb) {
      // obtenir le préremplissage, en cas d'erreur, appelez cb avec l'erreur dans le
      // premier arg au lieu de null
      cb(null, prefill);
    }
  }]
}
```

<div id="checkbox-field">
  #### Champ de type case à cocher
</div>

Le troisième type de champ d’inscription personnalisé est `type: "checkbox"`. La valeur `prefill` permet de définir l’état par défaut de la case à cocher (`true` ou `false`) et elle est obligatoire.

```js lines theme={null}
var options = {
  additionalSignUpFields: [{
    type: "checkbox",
    name: "newsletter",
    prefill: "true",
    placeholder: "I hereby agree that I want to receive marketing emails from your company"
  }]
}
```

<div id="hidden-field">
  #### Champ masqué
</div>

Le champ d’inscription `type: "hidden"` vous permet d’utiliser un champ masqué avec une valeur fixe.

```js lines theme={null}
var options = {
  additionalSignUpFields: [{
    type: "hidden",
    name: "signup_code",
    value: "abc123"
  }]
}
```

Dans certains cas d’utilisation, il peut être possible d’utiliser les données `additionalSignUpFields` dans des modèles de courriel, par exemple pour une option de préférence linguistique, dont la valeur pourrait ensuite servir à définir la langue des communications par courriel générées à partir de ces modèles.

### allowLogin {Boolean}

Lorsque cette option est définie sur `false`, le widget n’affiche pas l’écran de connexion. Cela est utile si vous voulez utiliser le widget uniquement pour l’inscription (les onglets de connexion et d’inscription de l’écran d’inscription seront masqués) ou pour réinitialiser des mots de passe (le bouton de retour de l’écran de mot de passe oublié sera masqué). Dans ces cas, vous devrez peut-être aussi préciser les options `initialScreen`, `allowForgotPassword` et `allowSignUp`. La valeur par défaut est `true`.

`allowLogin: false`

<Frame>
  <img src="https://mintcdn.com/translations/6GE5Z24GDCZehiJ9/docs/images/cdy7uua7fh8z/6gI4aSLHXLzhcHiR9aWMET/d05c2a08a3895278b01150ecf894cb5f/lock-allowlogin.png?fit=max&auto=format&n=6GE5Z24GDCZehiJ9&q=85&s=77270007c6a6e5cc0c4204b4c1c2d7da" alt="Option Lock : autoriser la connexion" width="2070" height="1978" data-path="docs/images/cdy7uua7fh8z/6gI4aSLHXLzhcHiR9aWMET/d05c2a08a3895278b01150ecf894cb5f/lock-allowlogin.png" />
</Frame>

### allowForgotPassword {Boolean}

Lorsque cette option est définie sur false, `allowForgotPassword` masque le lien « Vous avez oublié votre mot de passe ? » dans l’écran de connexion, ce qui rend l’écran Mot de passe oublié inaccessible. La valeur par défaut est true. Si vous utilisez une connexion de base de données avec une base de données personnalisée qui ne dispose pas de script de changement de mot de passe, l’écran Mot de passe oublié ne sera pas disponible.

`allowForgotPassword: false`

<Frame>
  <img src="https://mintcdn.com/translations/eVsQcTnbClN-oB7d/docs/images/cdy7uua7fh8z/1L6wJS3UnWK1VGKYMFhAB9/2ddcf2d462255e78a8b78958c2503809/lock-allowforgotpassword.png?fit=max&auto=format&n=eVsQcTnbClN-oB7d&q=85&s=abce0ba19791d22cb0db9be9a0e1fec3" alt="Option Lock : autoriser l’oubli du mot de passe" width="2070" height="1978" data-path="docs/images/cdy7uua7fh8z/1L6wJS3UnWK1VGKYMFhAB9/2ddcf2d462255e78a8b78958c2503809/lock-allowforgotpassword.png" />
</Frame>

### allowSignUp {Boolean}

Lorsqu’elle est définie sur `false`, cette option masque les onglets de connexion et d’inscription dans l’écran de connexion, ce qui rend l’écran d’inscription inaccessible. La valeur par défaut est `true`. Gardez à l’esprit que si l’inscription est désactivée pour la connexion de base de données, ou si vous utilisez une base de données personnalisée sans script de création, l’écran d’inscription ne sera pas disponible.

Gardez également à l’esprit que cette option contrôle **uniquement** l’apparence côté client et n’empêche pas complètement de nouvelles inscriptions par des visiteurs anonymes suffisamment déterminés. Si vous voulez empêcher complètement les nouveaux utilisateurs de s’inscrire, vous devez utiliser l’option **Disable Sign Ups** dans le tableau de bord, dans les paramètres de la connexion.

`allowSignUp: false`

<Frame>
  <img src="https://mintcdn.com/translations/Dcx0M11uuptU53TX/docs/images/cdy7uua7fh8z/2BNlYe99EFlRmIlhoLZiEB/f280d865cb16fa5fecda952271cb18bf/lock-allowsignup.png?fit=max&auto=format&n=Dcx0M11uuptU53TX&q=85&s=01568ae3eb1d69874c6bea838edf25ea" alt="Option Lock : autoriser l’inscription" width="2070" height="1978" data-path="docs/images/cdy7uua7fh8z/2BNlYe99EFlRmIlhoLZiEB/f280d865cb16fa5fecda952271cb18bf/lock-allowsignup.png" />
</Frame>

### defaultDatabaseConnection {String}

Indique la connexion de base de données à utiliser lorsqu’il y en a plusieurs.

`defaultDatabaseConnection: 'test-database'`

### initialScreen {String}

Le nom de l’écran qui s’affiche à l’ouverture du widget. Les valeurs valides sont `login`, `signUp` et `forgotPassword`. Si cette option n’est pas précisée, le widget affichera par défaut le premier écran disponible dans cette liste.

`initialScreen: 'forgotPassword'`

### loginAfterSignUp {Boolean}

Détermine si l’utilisateur se connectera automatiquement après une inscription réussie. La valeur par défaut est `true`.

`loginAfterSignUp: false`

### forgotPasswordLink {String}

Définissez l’URL d’une page permettant à l’utilisateur de réinitialiser son mot de passe. Lorsqu’une chaîne non vide est définie, l’utilisateur est redirigé vers l’URL fournie lorsqu’il clique sur le lien « Vous avez oublié votre mot de passe ? » dans l’écran de connexion.

`forgotPasswordLink: 'https://yoursite.com/reset-password'`

### showTerms {Boolean}

Lorsqu’elle est définie à `true`, cette option affiche la chaîne `languageDictionary.signUpTerms`. La valeur par défaut est `true`.

`showTerms: false`

### mustAcceptTerms {Boolean}

Lorsqu’elle est définie sur `true`, une case à cocher s’affiche à côté des modalités et conditions; elle doit être cochée avant l’inscription. Les modalités et conditions peuvent être définies à l’aide de l’option `languageDictionary`. Cette option ne prend effet que pour les utilisateurs qui s’inscrivent avec des connexions de base de données. La valeur par défaut est `false`.

`mustAcceptTerms: true`

### prefill {Object}

Permet de définir la valeur initiale des champs de saisie du courriel et/ou du nom d’utilisateur. S’il est omis, aucune valeur initiale n’est fournie.

```js lines theme={null}
var options = {
  prefill: {
    email: "someone@auth0.com",
    username: "someone",
    phoneNumber: "+1234567890"
  }
};
```

### signUpLink {String}

Définissez l’URL à utiliser lorsque vous cliquez sur le bouton d’inscription. Lorsqu’elle est définie avec une chaîne non vide, cette option force `allowSignUp` à `true`.

`signUpLink: 'https://yoursite.com/signup'`

### usernameStyle {String}

Détermine ce qui sera utilisé pour identifier l’utilisateur dans une connexion de base de données dont l’indicateur `requires_username` est activé (s’il ne l’est pas, l’option `usernameStyle` sera ignorée). Les valeurs possibles sont `"username"` et `"email"`. Par défaut, `username` et `email` sont tous deux autorisés; la définition de cette option limitera les connexions à l’un ou à l’autre.

`usernameStyle: 'username'`

<div id="enterprise-options">
  ## Options d'entreprise
</div>

### defaultEnterpriseConnection {String}

Spécifie la connexion d’entreprise qui permet de se connecter à l’aide d’un nom d’utilisateur et d’un mot de passe. Elle sera utilisée s’il y en a plus d’une de disponible ou s’il existe une connexion de base de données. Si un `defaultDatabaseConnection` est fourni, la connexion de base de données sera utilisée et cette option sera ignorée.

`defaultEnterpriseConnection: 'test-database'`

### defaultADUsernameFromEmailPrefix {Boolean}

Détermine le nom d’utilisateur AD de remplacement à partir du préfixe du courriel. La valeur par défaut est `true`.

`defaultADUsernameFromEmailPrefix: false`

<div id="passwordless-options">
  ## Options de Passwordless
</div>

### passwordlessMethod {String}

Lorsque vous utilisez `Auth0LockPasswordless` avec une connexion par courriel, vous pouvez utiliser cette option pour choisir entre l’envoi d’un [code](/fr-CA/docs/authenticate/passwordless) ou d’un [lien magique](/fr-CA/docs/authenticate/passwordless) afin d’authentifier l’utilisateur. Les valeurs disponibles pour les connexions par courriel sont `code` et `link`. La valeur par défaut est `code`. Les connexions SMS <Tooltip tip="Passwordless : forme d’authentification qui ne repose pas sur un mot de passe comme premier facteur." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=passwordless">Passwordless</Tooltip> utilisent toujours `code`.

`passwordlessMethod: code`

<div id="other-options">
  ## Autres options
</div>

### configurationBaseUrl {String}

Remplace l’URL de base de la configuration de l’application. Par défaut, le domaine fourni est utilisé. Cette option n’est nécessaire que si votre cas d’utilisation exige que votre application ne suive pas le comportement par défaut.

`configurationBaseUrl: "https://www.example.com"`

### languageBaseUrl {String}

Remplace l’URL source des traductions de langue fournies par Auth0. Par défaut, cette option utilise l’URL du CDN d’Auth0 `https://cdn.auth0.com`, car c’est là que sont stockées toutes les traductions fournies. En spécifiant une autre valeur, vous pouvez utiliser une autre source pour les traductions de langue, au besoin.

`languageBaseUrl: "https://www.example.com"`

### hashCleanup {Boolean}

Lorsque l’option `hashCleanup` est activée, elle supprime la partie de hachage de l’URL de rappel après l’authentification de l’utilisateur. Par défaut, sa valeur est `true`.

`hashCleanup: false`

### connectionResolver {Function}

Lorsqu’elle est utilisée, cette fonction fournit un point d’extension qui permet de choisir la connexion à utiliser en fonction des informations du nom d’utilisateur.

Prend `username`, `context` et `callback` comme paramètres. La fonction de rappel attend un objet comme celui-ci : `{type: 'database', name: 'connection name'}`. **Cela fonctionne uniquement pour les connexions de base de données.** Gardez à l’esprit que cette fonction de résolution s’exécute lors de l’événement `onSubmit` du formulaire; gardez-la donc simple et rapide.

Il s’agit d’une fonctionnalité bêta. Si vous trouvez un bogue, veuillez ouvrir une [issue](https://github.com/auth0/lock/issues/new) sur GitHub.

### leeway {Integer}

L’option `leeway` peut être définie comme un entier — une valeur en secondes — pour tenir compte d’un décalage d’horloge dans l’expiration des <Tooltip tip="ID Token : jeton destiné à l’application elle-même plutôt qu’à l’accès à une ressource." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=ID+Token">ID Token</Tooltip>. En règle générale, cette valeur ne dépasse pas une ou deux minutes.

`leeway: 30`