+
+
+## Vue d'ensemble
+
+L'API de Twenty permet aux développeurs d'interagir de manière programmée avec la plateforme CRM de Twenty. En utilisant l'API, vous pouvez intégrer Twenty avec d'autres systèmes, automatiser la synchronisation des données, et construire des solutions personnalisées autour de vos données clients. L'API fournit des points d'accès pour **créer, lire, mettre à jour et supprimer** des objets CRM principaux (comme les personnes et les entreprises) ainsi que pour accéder à la configuration des métadonnées.
+
+**API Playground :** Vous pouvez désormais accéder à l'API Playground dans les paramètres de l'application. Pour essayer les appels API en temps réel, connectez-vous à votre espace de travail Twenty et naviguez vers **Paramètres → APIs & Webhooks**. Cela ouvre le API Playground intégré et les paramètres pour les clés API.
+**[Accédez aux paramètres de l'API](https://app.twenty.com/settings)**
+
+## Authentification
+
+L'API de Twenty utilise des clés API pour l'authentification. Chaque requête vers des points d'accès protégés doit inclure une clé API dans l'en-tête.
+
+- **Clés API :** Vous pouvez générer une nouvelle clé API depuis la page de **paramètres de l'API** de votre application Twenty. Chaque clé API est un jeton secret qui accorde l'accès à vos données CRM, alors gardez-le en sécurité. Si une clé est compromise, révoquez-la dans les paramètres et générez-en une nouvelle.
+- **En-tête Auth :** Une fois que vous avez une clé API, incluez-la dans l'en-tête `Authorization` de vos requêtes HTTP. Utilisez le schéma de jeton Bearer. Par exemple :
+
+ ```
+ Authorization: Bearer YOUR_API_KEY
+ ```
+
+ Remplacez `VOTRE_CLÉ_API` par la clé que vous avez obtenue. Cet en-tête doit être présent sur **toutes les requêtes API**. Si le jeton est manquant ou invalide, l'API répondra avec une erreur d'authentification (HTTP 401 Non autorisé).
+
+## Points d'accès API
+
+Toutes les ressources peuvent être consultées via REST ou GraphQL.
+
+- **Cloud :** `https://api.twenty.com/` ou votre domaine / sous-domaine personnalisé
+- **Instances auto-hébergées :** Si vous exécutez Twenty sur votre propre serveur, utilisez votre propre domaine à la place de `api.twenty.com` (par exemple, `https://
+
+
+## Vue d'ensemble
+
+Les Webhooks dans Twenty complètent l'API en permettant des **notifications en temps réel** à vos propres applications lors de certains événements dans votre CRM. Au lieu de sonder continuellement l'API pour les changements, vous pouvez configurer des webhooks pour que Twenty **pousse** des données vers votre système chaque fois que des événements spécifiques se produisent (par exemple, lorsqu'un nouvel enregistrement est créé ou qu'un enregistrement existant est mis à jour). Cela aide à synchroniser instantanément et efficacement les systèmes externes avec Twenty.
+
+Avec les webhooks, Twenty enverra une requête HTTP POST à une URL que vous spécifiez, contenant des détails sur l'événement. Vous pouvez ensuite traiter ces données dans votre application (par exemple, pour mettre à jour votre base de données externe, déclencher des flux de travail ou envoyer des alertes).
+
+## Configuration d'un Webhook
+
+Pour créer un webhook dans Twenty, utilisez les paramètres **APIs & Webhooks** dans votre application Twenty :
+
+1. **Naviguer vers les Paramètres :** Dans votre application Twenty, allez dans **Paramètres → APIs & Webhooks**.
+2. **Créer un Webhook :** Dans **Webhooks**, cliquez sur **+ Créer un webhook**.
+3. **Entrez l'URL :** Fournissez l'URL de l'endpoint sur votre serveur où vous souhaitez que Twenty envoie les requêtes webhook. Cela doit être une URL publiquement accessible qui peut gérer les requêtes POST.
+4. **Enregistrer :** Cliquez sur **Enregistrer** pour créer le webhook. Le nouveau webhook sera actif immédiatement.
+
+Vous pouvez créer plusieurs webhooks si vous avez besoin d'envoyer différents événements vers différents endpoints. Chaque webhook est essentiellement un abonnement pour tous les événements pertinents (actuellement, Twenty envoie tous types d'événements à l'URL donnée ; filtrer des types d'événements spécifiques peut être configurable dans l'interface utilisateur). Si vous devez supprimer un webhook, vous pouvez le supprimer de la même page des paramètres (sélectionnez le webhook et choisissez supprimer).
+
+## Événements et Charges utiles
+
+Une fois qu'un webhook est configuré, Twenty enverra une requête HTTP POST à l'URL que vous avez spécifiée chaque fois qu'un événement déclencheur se produit dans vos données CRM. Les événements communs qui déclenchent les webhooks incluent :
+
+- **Enregistrement Créé :** par exemple, une nouvelle personne est ajoutée (`person.created`), une nouvelle entreprise est créée (`company.created`), une note est créée (`note.created`), etc.
+- **Enregistrement Mis à Jour :** par exemple, les informations d'une personne existante sont mises à jour (`person.updated`), un enregistrement d'entreprise est édité (`company.updated`), etc.
+- **Enregistrement Supprimé :** par exemple, une personne ou une entreprise est supprimée (`person.deleted`, `company.deleted`).
+- **Autres Événements :** Si applicable, d'autres événements d'objet ou déclencheurs personnalisés (par exemple, si des tâches ou d'autres objets sont mis à jour, des types d'événements similaires seraient utilisés comme `task.created`, `note.updated`, etc.).
+
+La requête POST du webhook contient une charge utile JSON dans son corps. La charge utile comprendra généralement au moins deux choses : le type d'événement et les données relatives à cet événement (souvent l'enregistrement qui a été créé/mise à jour). Par exemple, un webhook pour une nouvelle personne créée pourrait envoyer une charge utile comme :
+
+```
+{
+ "event": "person.created",
+ "data": {
+ "id": "abc12345",
+ "firstName": "Alice",
+ "lastName": "Doe",
+ "email": "alice@example.com",
+ "createdAt": "2025-02-10T15:30:45Z",
+ "createdBy": "user_123"
+ },
+ "timestamp": "2025-02-10T15:30:50Z"
+}
+```
+
+Dans cet exemple :
+
+- `"event"` spécifie ce qui s'est passé (`person.created`).
+- `"data"` contient les détails du nouvel enregistrement (les mêmes informations que vous obtiendriez si vous demandiez cette personne via l'API).
+- `"timestamp"` est le moment où l'événement s'est produit (en UTC).
+
+Votre endpoint devrait être prêt à recevoir de telles données JSON via POST. En général, vous allez analyser le JSON, regarder le type d'événement `"event"` pour comprendre ce qui s'est passé, et ensuite utiliser les `"data"` en conséquence (par exemple, créer un nouveau contact dans votre système ou mettre à jour un contact existant).
+
+**Remarque :** Il est important de répondre avec un **statut HTTP 2xx** depuis votre endpoint webhook pour accuser réception avec succès. Si l'expéditeur du webhook de Twenty ne reçoit pas une réponse 2xx, il peut considérer que la livraison a échoué. (À l'avenir, une logique de réessai pourrait tenter de renvoyer les webhooks échoués, donc essayez toujours de retourner un 200 OK aussi rapidement que possible après le traitement des données.)
+
+## Validation des Webhooks
+
+Pour garantir la sécurité de vos endpoints webhook, Twenty inclut une signature dans l'en-tête `X-Twenty-Webhook-Signature`.
+
+Cette signature est un hachage HMAC SHA256 de la charge utile de la requête, calculé en utilisant votre clé secrète.
+
+Pour valider la signature, vous devrez :
+
+1. Concaténer le timestamp (de l'en-tête `X-Twenty-Webhook-Timestamp`), un deux-points, et la chaîne JSON de la charge utile
+2. Calculer le hachage HMAC SHA256 en utilisant votre clé secrète comme clé ()
+3. Comparer le résultat de la somme de contrôle hexadécimale avec l'en-tête de signature
+
+Voici un exemple en Node.js :
+
+```javascript
+const crypto = require("crypto");
+const timestamp = "1735066639761";
+const payload = JSON.stringify({...});
+const secret = "your-secret";
+const stringToSign = `${timestamp}:${JSON.stringify(payload)}`;
+const signature = crypto.createHmac("sha256", secret)
+ .update(stringToSign)
+ .digest("hex");
+```
\ No newline at end of file
diff --git a/packages/twenty-docs/fr/developers/backend-development/best-practices-server.mdx b/packages/twenty-docs/fr/developers/backend-development/best-practices-server.mdx
new file mode 100644
index 0000000000..ca2bb27b92
--- /dev/null
+++ b/packages/twenty-docs/fr/developers/backend-development/best-practices-server.mdx
@@ -0,0 +1,27 @@
+---
+title: Meilleures pratiques
+image: /images/user-guide/tips/light-bulb.png
+---
+
+
+ 
+
+
+Ce document décrit les meilleures pratiques à suivre lors de travaux sur le backend.
+
+## Suivez une approche modulaire
+
+Le backend suit une approche modulaire, qui est un principe fondamental lors de l'utilisation de NestJS. Assurez-vous de décomposer votre code en modules réutilisables pour maintenir une base de code propre et organisée.
+Chaque module doit encapsuler une fonctionnalité particulière et avoir un périmètre bien défini. Cette approche modulaire permet une séparation claire des préoccupations et supprime les complexités inutiles.
+
+## Exposez des services à utiliser dans les modules
+
+Créez toujours des services avec une responsabilité claire et unique, ce qui améliore la lisibilité et la maintenabilité du code. Nommez les services de manière descriptive et cohérente.
+
+Vous devez également exposer les services que vous souhaitez utiliser dans d'autres modules. Exposer des services à d'autres modules est possible grâce au puissant système d'injection de dépendance de NestJS, et favorise un couplage lâche entre les composants.
+
+## Évitez d'utiliser le type `any`
+
+Lorsque vous déclarez une variable comme `any`, le vérificateur de type de TypeScript ne procède à aucune vérification, rendant possible l'assignation de n'importe quel type de valeur à la variable. TypeScript utilise l'inférence de type pour déterminer le type d'une variable en fonction de sa valeur. En le déclarant comme `any`, TypeScript ne peut plus deviner le type. Cela rend difficile la détection des erreurs liées aux types pendant le développement, conduisant à des erreurs d'exécution et rendant le code moins maintenable, moins fiable et plus difficile à comprendre pour d'autres.
+
+C'est pourquoi tout devrait avoir un type. Donc si vous créez un nouvel objet avec un prénom et un nom, vous devriez créer une interface ou un type contenant un prénom et un nom qui définit la forme de l'objet que vous manipulez.
diff --git a/packages/twenty-docs/fr/developers/backend-development/custom-objects.mdx b/packages/twenty-docs/fr/developers/backend-development/custom-objects.mdx
new file mode 100644
index 0000000000..dd8273a50a
--- /dev/null
+++ b/packages/twenty-docs/fr/developers/backend-development/custom-objects.mdx
@@ -0,0 +1,45 @@
+---
+title: Objets personnalisés
+image: /images/user-guide/objects/objects.png
+---
+
+
+ 
+
+
+Les objets sont des structures qui vous permettent de stocker des données (enregistrements, attributs et valeurs) spécifiques à une organisation. Twenty fournit à la fois des objets standard et personnalisés.
+
+Les objets standard sont des objets intégrés avec un ensemble d'attributs disponibles pour tous les utilisateurs. Les exemples d'objets standard dans Twenty incluent Société et Personne. Les objets standard ont des champs standard également disponibles pour tous les utilisateurs de Twenty, comme Company.displayName.
+
+Les objets personnalisés sont des objets que vous pouvez créer pour stocker des informations uniques à votre organisation. Ils ne sont pas intégrés ; les membres de votre espace de travail peuvent créer et personnaliser des objets personnalisés pour contenir des informations que les objets standard ne conviennent pas.
+
+## Schéma de haut niveau
+
+
+ 
+
+
+
++ +## Comment cela fonctionne + +Les objets personnalisés proviennent de tables de métadonnées qui déterminent la forme, le nom et le type des objets. Toutes ces informations sont présentes dans la base de données des schémas de métadonnées, composée de tables : + +- **DataSource** : Détaille où les données sont présentes. +- **Objet** : Décrit l'objet et lie à une DataSource. +- **Champ** : Décrit les champs d'un objet et se connecte à l'objet. + +Pour ajouter un objet personnalisé, le workspaceMember interrogera l'API /metadata. Cela met à jour les métadonnées en conséquence et calcule un schéma GraphQL basé sur les métadonnées, en le stockant dans un cache GQL pour une utilisation ultérieure. + +
+ 
+
+
+
++ +Pour obtenir des données, le processus implique de faire des requêtes via le point de terminaison /graphql et de les transmettre via le Query Resolver. + +
+
+
+
diff --git a/packages/twenty-docs/fr/developers/backend-development/feature-flags.mdx b/packages/twenty-docs/fr/developers/backend-development/feature-flags.mdx
new file mode 100644
index 0000000000..d45eb62fa2
--- /dev/null
+++ b/packages/twenty-docs/fr/developers/backend-development/feature-flags.mdx
@@ -0,0 +1,51 @@
+---
+title: Drapeaux de fonctionnalité
+image: /images/user-guide/table-views/table.png
+---
+
+
+
+
+
+
+Les drapeaux de fonctionnalité sont utilisés pour masquer les fonctionnalités expérimentales. Pour Twenty, ils sont définis au niveau de l'espace de travail et non au niveau de l'utilisateur.
+
+## Ajout d'un nouveau drapeau de fonctionnalité
+
+Dans `FeatureFlagKey.ts` ajoutez l'indicateur de fonctionnalité :
+
+```ts
+type FeatureFlagKey =
+ | 'IS_FEATURENAME_ENABLED'
+ | ...;
+```
+
+Ajoutez-le également à l'énumération dans `feature-flag.entity.ts` :
+
+```ts
+enum FeatureFlagKeys {
+ IsFeatureNameEnabled = 'IS_FEATURENAME_ENABLED',
+ ...
+}
+```
+
+Pour appliquer un drapeau de fonctionnalité sur une fonctionnalité de **backend**, utilisez :
+
+```ts
+@Gate({
+ featureFlag: 'IS_FEATURENAME_ENABLED',
+})
+```
+
+Pour appliquer un drapeau de fonctionnalité sur une fonctionnalité de **frontend**, utilisez :
+
+```ts
+const isFeatureNameEnabled = useIsFeatureEnabled('IS_FEATURENAME_ENABLED');
+```
+
+## Configurer les drapeaux de fonctionnalité pour le déploiement
+
+Modifiez l'enregistrement correspondant dans la Table `core.featureFlag` :
+
+| iD | clé | workspaceId | valeur |
+| --------- | ------------------------ | ----------- | ------ |
+| Aléatoire | `IS_FEATURENAME_ENABLED` | WorkspaceID | `vrai` |
diff --git a/packages/twenty-docs/fr/developers/backend-development/folder-architecture-server.mdx b/packages/twenty-docs/fr/developers/backend-development/folder-architecture-server.mdx
new file mode 100644
index 0000000000..498a5a5727
--- /dev/null
+++ b/packages/twenty-docs/fr/developers/backend-development/folder-architecture-server.mdx
@@ -0,0 +1,130 @@
+---
+title: Architecture des Dossiers
+info: Un regard détaillé sur l'architecture des dossiers de notre serveur
+image: /images/user-guide/fields/field.png
+---
+
+
+ 
+
+
+La structure du répertoire backend est la suivante :
+
+```
+server
+ └───ability
+ └───constants
+ └───core
+ └───database
+ └───decorators
+ └───filters
+ └───guards
+ └───health
+ └───integrations
+ └───metadata
+ └───workspace
+ └───utils
+```
+
+## Capacité
+
+Définit les permissions et inclut des gestionnaires pour chaque entité.
+
+## Décorateurs
+
+Définit des décorateurs personnalisés dans NestJS pour des fonctionnalités supplémentaires.
+
+Voir [décorateurs personnalisés](https://docs.nestjs.com/custom-decorators) pour plus de détails.
+
+## Filtres
+
+Inclut des filtres d'exception pour gérer les exceptions qui pourraient se produire dans les points de terminaison GraphQL.
+
+## Gardes
+
+Voir [gardiens](https://docs.nestjs.com/guards) pour plus de détails.
+
+## Santé
+
+Inclut une API REST disponible publiquement (healthz) qui renvoie un JSON pour confirmer si la base de données fonctionne comme prévu.
+
+## Métadonnées
+
+Définit des objets personnalisés et met une API GraphQL à disposition (graphql/metadata).
+
+## Espace de travail
+
+Génère et sert un schéma GraphQL personnalisé basé sur les métadonnées.
+
+### Structure du répertoire de l'espace de travail
+
+```
+workspace
+
+ └───workspace-schema-builder
+ └───factories
+ └───graphql-types
+ └───database
+ └───interfaces
+ └───object-definitions
+ └───services
+ └───storage
+ └───utils
+ └───workspace-resolver-builder
+ └───factories
+ └───interfaces
+ └───workspace-query-builder
+ └───factories
+ └───interfaces
+ └───workspace-query-runner
+ └───interfaces
+ └───utils
+ └───workspace-datasource
+ └───workspace-manager
+ └───workspace-migration-runner
+ └───utils
+ └───workspace.module.ts
+ └───workspace.factory.spec.ts
+ └───workspace.factory.ts
+```
+
+La racine du répertoire de l'espace de travail inclut le fichier `workspace.factory.ts`, qui contient la fonction `createGraphQLSchema`. Cette fonction génère un schéma spécifique à l'espace de travail en utilisant les métadonnées pour adapter un schéma pour chaque espace de travail. En séparant la construction du schéma et du résolveur, nous utilisons la fonction `makeExecutableSchema`, qui combine ces éléments distincts.
+
+Cette stratégie n'est pas seulement une question d'organisation, mais aide également à l'optimisation, comme la mise en cache des définitions de type générées pour améliorer les performances et la scalabilité.
+
+### Constructeur de schéma d'espace de travail
+
+Génère le schéma GraphQL, et inclut :
+
+#### Usines :
+
+Constructeurs spécialisés pour générer des constructions liées à GraphQL.
+
+- La type.factory traduit les métadonnées de champs en types GraphQL en utilisant le `TypeMapperService`.
+- La type-definition.factory crée des objets d'entrée ou de sortie GraphQL dérivés de `objectMetadata`.
+
+#### Types GraphQL
+
+Inclut des énumérations, des entrées, des objets et des scalaires, et sert de blocs de construction pour la construction du schéma.
+
+#### Interfaces et définitions d'objets
+
+Contient les plans pour les entités GraphQL, et inclut à la fois des types prédéfinis et personnalisés comme `MONEY` ou `URL`.
+
+#### Services
+
+Contient le service responsable de l'association du FieldMetadataType avec son type scalaire ou modificateur de requête GraphQL approprié.
+
+#### Stockage
+
+Inclut la classe `TypeDefinitionsStorage` qui contient des définitions de type réutilisables, empêchant la duplication des types GraphQL.
+
+### Constructeur de résolveur d'espace de travail
+
+Crée des fonctions de résolveur pour interroger et modifier le schéma GraphQL.
+
+Chaque usine de ce répertoire est responsable de la production d'un type de résolveur distinct, comme le `FindManyResolverFactory`, conçu pour une application adaptable à plusieurs tables.
+
+### Exécuteur de requêtes d'espace de travail
+
+Exécute les requêtes générées sur la base de données et analyse le résultat.
diff --git a/packages/twenty-docs/fr/developers/backend-development/server-commands.mdx b/packages/twenty-docs/fr/developers/backend-development/server-commands.mdx
new file mode 100644
index 0000000000..d11bb4016d
--- /dev/null
+++ b/packages/twenty-docs/fr/developers/backend-development/server-commands.mdx
@@ -0,0 +1,108 @@
+---
+title: Commandes Backend
+image: /images/user-guide/kanban-views/kanban.png
+---
+
+
+ 
+
+
+## Commandes utiles
+
+Ces commandes doivent être exécutées depuis le dossier packages/twenty-server.
+Depuis n'importe quel autre dossier, vous pouvez exécuter `npx nx 
+
+
+Synchronisez facilement Twenty avec plus de 3000 applications à l'aide de [Zapier](https://zapier.com/). Automatisez les tâches, boostez la productivité et dynamisez vos relations client !
+
+## À propos de Zapier
+
+Zapier est un outil qui vous permet d'automatiser des flux de travail en connectant les applications que votre équipe utilise quotidiennement. Le concept fondamental de Zapier est l'automatisation des flux de travail, appelés Zaps, et inclut des déclencheurs et des actions.
+
+Vous pouvez en savoir plus sur le fonctionnement de Zapier [ici](https://zapier.com/how-it-works).
+
+## Installation
+
+### Étape 1 : Installez les packages Zapier
+
+```bash
+cd packages/twenty-zapier
+
+yarn
+```
+
+### Étape 2 : Connectez-vous avec le CLI
+
+Utilisez vos identifiants Zapier pour vous connecter en utilisant le CLI :
+
+```bash
+zapier login
+```
+
+### Étape 3 : Configurer les variables d'environnement
+
+Depuis le dossier `packages/twenty-zapier`, exécutez :
+
+```bash
+cp .env.example .env
+```
+
+Exécutez l'application localement, rendez-vous sur [http://localhost:3000/settings/api-webhooks](http://localhost:3000/settings/api-webhooks) et générez une clé API.
+
+Remplacez la valeur **YOUR_API_KEY** dans le fichier `.env` par la clé API que vous venez de générer.
+
+## Développement
+
+
+
+
+## Signaler des bogues
+
+Pour signaler un bogue, veuillez [créer un problème sur GitHub](https://github.com/twentyhq/twenty/issues/new).
+
+Vous pouvez également demander de l'aide sur [Discord](https://discord.gg/cx5n4Jzs57).
+
+## Demandes de fonctionnalités
+
+Si vous n'êtes pas sûr qu'il s'agisse d'un bogue, et que vous pensez que cela ressemble plus à une demande de fonctionnalité, alors vous devriez probablement [ouvrir une discussion à la place](https://github.com/twentyhq/twenty/discussions/new).
diff --git a/packages/twenty-docs/fr/developers/frontend-development/best-practices-front.mdx b/packages/twenty-docs/fr/developers/frontend-development/best-practices-front.mdx
new file mode 100644
index 0000000000..36ab74a2ce
--- /dev/null
+++ b/packages/twenty-docs/fr/developers/frontend-development/best-practices-front.mdx
@@ -0,0 +1,333 @@
+---
+title: Meilleures pratiques
+image: /images/user-guide/tips/light-bulb.png
+---
+
+
+
+
+
+Ce document décrit les meilleures pratiques à suivre lors de votre travail sur l'interface frontend.
+
+## Gestion de l'état
+
+React et Recoil gèrent la gestion de l'état dans la base de code.
+
+### Utilisez `useRecoilState` pour stocker l'état
+
+C'est une bonne pratique de créer autant d'atomes que nécessaire pour stocker votre état.
+
+
+ setMyAtom(e.target.value)}
+ />
+
+ );
+}
+```
+
+### Ne pas utiliser `useRef` pour stocker l'état
+
+Évitez d'utiliser `useRef` pour stocker l'état.
+
+Si vous souhaitez stocker un état, vous devez utiliser `useState` ou `useRecoilState`.
+
+Consultez [comment gérer les re-rendus](#managing-re-renders) si vous avez l'impression d'avoir besoin de `useRef` pour empêcher certains re-rendus.
+
+## Gestion des re-rendus
+
+Les re-rendus peuvent être difficiles à gérer dans React.
+
+Voici quelques règles à suivre pour éviter les re-rendus inutiles.
+
+Gardez à l'esprit que vous pouvez **toujours** éviter les re-rendus en comprenant leur cause.
+
+### Travaillez au niveau racine
+
+Éviter les re-rendus dans les nouvelles fonctionnalités est désormais facile en les éliminant au niveau racine.
+
+Le composant secondaire `PageChangeEffect` contient seulement un `useEffect` qui retient toute la logique à exécuter lors d'un changement de page.
+
+De cette manière, vous savez qu'il n'y a qu'un seul endroit qui peut déclencher un re-rendu.
+
+### Toujours réfléchir à deux fois avant d'ajouter `useEffect` dans votre code.
+
+Les re-rendus sont souvent causés par des `useEffect` inutiles.
+
+Vous devriez réfléchir si vous avez besoin de `useEffect`, ou si vous pouvez déplacer la logique dans une fonction de gestion d'événements.
+
+Vous trouverez généralement facile de déplacer la logique dans une fonction `handleClick` ou `handleChange`.
+
+Vous pouvez également les trouver dans des bibliothèques comme Apollo : `onCompleted`, `onError`, etc.
+
+### Utilisez un composant frère pour extraire `useEffect` ou la logique de récupération des données
+
+Si vous pensez devoir ajouter un `useEffect` dans votre composant racine, vous devriez envisager de l'extraire dans un composant secondaire.
+
+Vous pouvez appliquer la même chose à la logique de récupération de données, avec les hooks Apollo.
+
+```tsx
+// ❌ Bad, will cause re-renders even if data is not changing,
+// because useEffect needs to be re-evaluated
+export const PageComponent = () => {
+ const [data, setData] = useRecoilState(dataState);
+ const [someDependency] = useRecoilState(someDependencyState);
+
+ useEffect(() => {
+ if(someDependency !== data) {
+ setData(someDependency);
+ }
+ }, [someDependency]);
+
+ return {data}
;
+};
+
+export const App = () => (
+ {data}
;
+};
+
+export const PageData = () => {
+ const [data, setData] = useRecoilState(dataState);
+ const [someDependency] = useRecoilState(someDependencyState);
+
+ useEffect(() => {
+ if(someDependency !== data) {
+ setData(someDependency);
+ }
+ }, [someDependency]);
+
+ return <>;
+};
+
+export const App = () => (
+
+
+
+ )
+};
+```
+
+Pour que React comprenne qu'un composant est un composant, vous devez utiliser PascalCase, pour l'instancier plus tard avec `
+
+
+Dans ce guide, vous explorerez les détails de la structure du répertoire de projet et comment elle contribue à l'organisation et à la maintenabilité de Twenty.
+
+En suivant cette convention d'architecture de dossiers, il est plus facile de trouver les fichiers liés à des fonctionnalités spécifiques et de s'assurer que l'application est évolutive et maintenable.
+
+```
+front
+└───modules
+│ └───module1
+│ │ └───submodule1
+│ └───module2
+│ └───ui
+│ │ └───display
+│ │ └───inputs
+│ │ │ └───buttons
+│ │ └───...
+└───pages
+└───...
+```
+
+## Pages
+
+Comprend les composants de haut niveau définis par les routes de l'application. Ils importent des composants plus bas niveau du dossier des modules (plus de détails ci-dessous).
+
+## Modules
+
+Chaque module représente une fonctionnalité ou un groupe de fonctionnalités, comprenant ses composants spécifiques, ses états, et sa logique opérationnelle.
+Ils doivent tous suivre la structure ci-dessous. Vous pouvez imbriquer des modules dans des modules (appelés sous-modules) et les mêmes règles s'appliqueront.
+
+```
+module1
+ └───components
+ │ └───component1
+ │ └───component2
+ └───constants
+ └───contexts
+ └───graphql
+ │ └───fragments
+ │ └───queries
+ │ └───mutations
+ └───hooks
+ │ └───internal
+ └───states
+ │ └───selectors
+ └───types
+ └───utils
+```
+
+### Contextes
+
+Un contexte est un moyen de transmettre des données à travers l'arborescence de composants sans avoir à transmettre les propriétés manuellement à chaque niveau.
+
+Voir [React Context](https://react.dev/reference/react#context-hooks) pour plus de détails.
+
+### GraphQL
+
+Comprend des fragments, des requêtes et des mutations.
+
+Voir [GraphQL](https://graphql.org/learn/) pour plus de détails.
+
+- Fragments
+
+Un fragment est une partie réutilisable d'une requête, que vous pouvez utiliser dans différents endroits. En utilisant des fragments, il est plus facile d'éviter de dupliquer du code.
+
+Voir [GraphQL Fragments](https://graphql.org/learn/queries/#fragments) pour plus de détails.
+
+- Requêtes
+
+Voir [GraphQL Queries](https://graphql.org/learn/queries/) pour plus de détails.
+
+- Mutations
+
+Voir [GraphQL Mutations](https://graphql.org/learn/queries/#mutations) pour plus de détails.
+
+### Hooks
+
+Voir [Hooks](https://react.dev/learn/reusing-logic-with-custom-hooks) pour plus de détails.
+
+### États
+
+Contient la logique de gestion des états. [RecoilJS](https://recoiljs.org) gère cela.
+
+- Sélecteurs : Voir [RecoilJS Selectors](https://recoiljs.org/docs/basic-tutorial/selectors) pour plus de détails.
+
+La gestion de l'état intégrée de React gère toujours l'état au sein d'un composant.
+
+### Utilitaires
+
+Devrait juste contenir des fonctions pures réutilisables. Autrement, créez des hooks personnalisés dans le dossier `hooks`.
+
+## UI
+
+Contient tous les composants d'interface utilisateur réutilisables utilisés dans l'application.
+
+Ce dossier peut contenir des sous-dossiers, comme `data`, `display`, `feedback`, et `input` pour des types de composants spécifiques. Chaque composant doit être autonome et réutilisable, de sorte que vous puissiez l'utiliser dans différentes parties de l'application.
+
+En séparant les composants UI des autres composants dans le dossier `modules`, il est plus facile de maintenir un design cohérent et d'effectuer des changements de l'interface utilisateur sans affecter d'autres parties (logique métier) de la base de code.
+
+## Interface et dépendances
+
+Vous pouvez importer le code d'autres modules depuis n'importe quel module, sauf pour le dossier `ui`. Cela permettra de garder son code facile à tester.
+
+### Interne
+
+Chaque partie (hooks, états, ...) d'un module peut avoir un dossier `interne`, qui contient des parties utilisées uniquement au sein du module.
diff --git a/packages/twenty-docs/fr/developers/frontend-development/frontend-commands.mdx b/packages/twenty-docs/fr/developers/frontend-development/frontend-commands.mdx
new file mode 100644
index 0000000000..18d872b09c
--- /dev/null
+++ b/packages/twenty-docs/fr/developers/frontend-development/frontend-commands.mdx
@@ -0,0 +1,96 @@
+---
+title: Commandes Frontend
+image: /images/user-guide/create-workspace/workspace-cover.png
+---
+
+
+ 
+
+
+## Commandes utiles
+
+### Lancement de l'application
+
+```bash
+npx nx start twenty-front
+```
+
+### Régénérer le schéma GraphQL basé sur le schéma API GraphQL
+
+```bash
+npx nx run twenty-front:graphql:generate --configuration=metadata
+```
+
+OU
+
+```bash
+npx nx run twenty-front:graphql:generate
+```
+
+### Analyse
+
+```bash
+npx nx run twenty-front:lint # pass --fix to fix lint errors
+```
+
+## Traductions
+
+```bash
+npx nx run twenty-front:lingui:extract
+npx nx run twenty-front:lingui:compile
+```
+
+### Test
+
+```bash
+npx nx run twenty-front:test # run jest tests
+npx nx run twenty-front:storybook:serve:dev # run storybook
+npx nx run twenty-front:storybook:test # run tests # (needs yarn storybook:serve:dev to be running)
+npx nx run twenty-front:storybook:coverage # (needs yarn storybook:serve:dev to be running)
+```
+
+## Écosystème Tech
+
+Le projet a une stack simple et propre, avec un code boilerplate minimal.
+
+**Application**
+
+- [React](https://react.dev/)
+- [Apollo](https://www.apollographql.com/docs/)
+- [GraphQL Codegen](https://the-guild.dev/graphql/codegen)
+- [Recoil](https://recoiljs.org/docs/introduction/core-concepts)
+- [TypeScript](https://www.typescriptlang.org/)
+
+**Tests**
+
+- [Jest](https://jestjs.io/)
+- [Storybook](https://storybook.js.org/)
+
+**Outils**
+
+- [Yarn](https://yarnpkg.com/)
+- [Craco](https://craco.js.org/docs/)
+- [ESLint](https://eslint.org/)
+
+## Architecture
+
+### Routage
+
+[React Router](https://reactrouter.com/) gère le routage.
+
+Pour éviter les [re-renders](/developers/frontend-development/best-practices-front#managing-re-renders) inutiles, toute la logique de routage est dans un `useEffect` dans `PageChangeEffect`.
+
+### Gestion de l'État
+
+[Recoil](https://recoiljs.org/docs/introduction/core-concepts) gère la gestion de l'état.
+
+Voir [les meilleures pratiques](/developers/frontend-development/best-practices-front#state-management) pour plus d'informations sur la gestion de l'état.
+
+## Tests
+
+[Jest](https://jestjs.io/) sert de guide pour les tests unitaires tandis que [Storybook](https://storybook.js.org/) est utilisé pour les tests de composants.
+
+Jest est principalement utilisé pour tester les fonctions utilitaires, et non les composants eux-mêmes.
+
+Storybook est utilisé pour tester le comportement des composants isolés, ainsi que pour afficher le système de design.
+
diff --git a/packages/twenty-docs/fr/developers/frontend-development/hotkeys.mdx b/packages/twenty-docs/fr/developers/frontend-development/hotkeys.mdx
new file mode 100644
index 0000000000..ce67f565ad
--- /dev/null
+++ b/packages/twenty-docs/fr/developers/frontend-development/hotkeys.mdx
@@ -0,0 +1,183 @@
+---
+title: Raccourcis clavier
+image: /images/user-guide/table-views/table.png
+---
+
+
+
+
+
+## Introduction
+
+Lorsque vous devez écouter une touche de raccourci, vous utilisez normalement l'événement `onKeyDown`.
+
+Cependant, dans `twenty-front`, vous pourriez avoir des conflits entre les mêmes raccourcis utilisés dans différents composants, montés en même temps.
+
+Par exemple, si vous avez une page qui écoute la touche Entrée, et une fenêtre modale qui écoute aussi la touche Entrée, avec un composant Select à l'intérieur de cette fenêtre qui écoute également la touche Entrée, vous risquez d'avoir un conflit lorsque tous sont montés en même temps.
+
+## Le hook `useScopedHotkeys`
+
+Pour résoudre ce problème, nous avons un hook personnalisé qui permet d'écouter les raccourcis sans aucun conflit.
+
+Vous l'insérez dans un composant et il écoutera les raccourcis uniquement lorsque le composant est monté ET lorsque le **périmètre du raccourci** spécifié est actif.
+
+## Comment écouter les raccourcis en pratique ?
+
+Deux étapes sont nécessaires pour configurer l'écoute des raccourcis :
+
+1. Définir le [périmètre du raccourci](#what-is-a-hotkey-scope-) qui écoutera les raccourcis
+2. Utiliser le hook `useScopedHotkeys` pour écouter les raccourcis
+
+La configuration des périmètres de raccourcis est nécessaire même sur des pages simples, car d'autres éléments de l'interface utilisateur comme le menu de gauche ou le menu de commandes pourraient également écouter les raccourcis.
+
+## Cas d'utilisation des raccourcis
+
+En général, vous aurez deux cas d'utilisation nécessitant des raccourcis :
+
+1. Dans une page ou un composant monté dans une page
+2. Dans un composant de type modal qui prend le focus à la suite d'une action utilisateur
+
+Le deuxième cas d'utilisation peut se produire de manière récursive : un menu déroulant dans une fenêtre modale par exemple.
+
+### Écouter les raccourcis dans une page
+
+Exemple :
+
+```tsx
+const PageListeningEnter = () => {
+ const {
+ setHotkeyScopeAndMemorizePreviousScope,
+ goBackToPreviousHotkeyScope,
+ } = usePreviousHotkeyScope();
+
+ // 1. Set the hotkey scope in a useEffect
+ useEffect(() => {
+ setHotkeyScopeAndMemorizePreviousScope(
+ ExampleHotkeyScopes.ExampleEnterPage,
+ );
+
+ // Revert to the previous hotkey scope when the component is unmounted
+ return () => {
+ goBackToPreviousHotkeyScope();
+ };
+ }, [goBackToPreviousHotkeyScope, setHotkeyScopeAndMemorizePreviousScope]);
+
+ // 2. Use the useScopedHotkeys hook
+ useScopedHotkeys(
+ Key.Enter,
+ () => {
+ // Some logic executed on this page when the user presses Enter
+ // ...
+ },
+ ExampleHotkeyScopes.ExampleEnterPage,
+ );
+
+ return My page that listens for Enter
;
+};
+```
+
+### Écouter les raccourcis dans un composant de type modal
+
+Pour cet exemple, nous allons utiliser un composant modal qui écoute la touche Échap pour informer son parent de le fermer.
+
+Ici, l'interaction utilisateur change le périmètre.
+
+```tsx
+const ExamplePageWithModal = () => {
+ const [showModal, setShowModal] = useState(false);
+
+ const {
+ setHotkeyScopeAndMemorizePreviousScope,
+ goBackToPreviousHotkeyScope,
+ } = usePreviousHotkeyScope();
+
+ const handleOpenModalClick = () => {
+ // 1. Set the hotkey scope when user opens the modal
+ setShowModal(true);
+ setHotkeyScopeAndMemorizePreviousScope(
+ ExampleHotkeyScopes.ExampleModal,
+ );
+ };
+
+ const handleModalClose = () => {
+ // 1. Revert to the previous hotkey scope when the modal is closed
+ setShowModal(false);
+ goBackToPreviousHotkeyScope();
+ };
+
+ return
+
;
+};
+```
+
+Ensuite, dans le composant modal :
+
+```tsx
+const MyDropdownComponent = ({ onClose }: { onClose: () => void }) => {
+ // 2. Use the useScopedHotkeys hook to listen for Escape.
+ // Note that escape is a common hotkey that could be used by many other components
+ // So it's important to use a hotkey scope to avoid conflicts
+ useScopedHotkeys(
+ Key.Escape,
+ () => {
+ onClose()
+ },
+ ExampleHotkeyScopes.ExampleModal,
+ );
+
+ return My page with a modal
+ + {showModal &&My modal component
;
+};
+```
+
+Il est important d'utiliser ce schéma lorsque vous n'êtes pas sûr que l'utilisation simple d'un useEffect avec montage/démontage suffira à éviter les conflits.
+
+Ces conflits peuvent être difficiles à déboguer et peuvent survenir plus souvent qu'on ne le croit avec les useEffects.
+
+## Qu'est-ce qu'un périmètre de raccourci ?
+
+Un périmètre de raccourci est une chaîne de caractères qui représente un contexte dans lequel les raccourcis sont actifs. Il est généralement encodé sous forme d'enum.
+
+Lorsque vous modifiez le périmètre de raccourci, les raccourcis qui écoutent ce périmètre seront activés et ceux qui écoutent d'autres périmètres seront désactivés.
+
+Vous ne pouvez définir qu'un seul périmètre à la fois.
+
+Par exemple, les périmètres de raccourcis pour chaque page sont définis dans l'`enum PageHotkeyScope` :
+
+```tsx
+export enum PageHotkeyScope {
+ Settings = 'settings',
+ CreateWorkspace = 'create-workspace',
+ SignInUp = 'sign-in-up',
+ CreateProfile = 'create-profile',
+ PlanRequired = 'plan-required',
+ ShowPage = 'show-page',
+ PersonShowPage = 'person-show-page',
+ CompanyShowPage = 'company-show-page',
+ CompaniesPage = 'companies-page',
+ PeoplePage = 'people-page',
+ OpportunitiesPage = 'opportunities-page',
+ ProfilePage = 'profile-page',
+ WorkspaceMemberPage = 'workspace-member-page',
+ TaskPage = 'task-page',
+}
+```
+
+En interne, le périmètre sélectionné est stocké dans un état Recoil qui est partagé dans toute l'application :
+
+```tsx
+export const currentHotkeyScopeState = createState
+
+
+Ce document inclut les règles à suivre lors de l'écriture de code.
+
+L'objectif ici est d'avoir une base de code cohérente, facile à lire et à maintenir.
+
+Pour cela, il vaut mieux être un peu plus verbeux que trop concis.
+
+Gardez toujours à l'esprit que les gens lisent le code plus souvent qu'ils ne l'écrivent, surtout dans un projet open source où tout le monde peut contribuer.
+
+Il existe de nombreuses règles qui ne sont pas définies ici, mais qui sont vérifiées automatiquement par des linters.
+
+## React
+
+### Utilisez des composants fonctionnels
+
+Utilisez toujours des composants fonctionnels TSX.
+
+N'utilisez pas `import` par défaut avec `const`, car c'est plus difficile à lire et plus difficile à importer avec l'autocomplétion du code.
+
+```tsx
+// ❌ Bad, harder to read, harder to import with code completion
+const MyComponent = () => {
+ return Hello World
;
+};
+
+export default MyComponent;
+
+// ✅ Good, easy to read, easy to import with code completion
+export function MyComponent() {
+ return Hello World
;
+};
+```
+
+### Propriétés
+
+Créez le type des props et nommez-le `(NomDuComposant)Props` s'il n'est pas nécessaire de l'exporter.
+
+Utilisez la déstructuration des props.
+
+```tsx
+// ❌ Bad, no type
+export const MyComponent = (props) => Hello {props.name}
;
+
+// ✅ Good, type
+type MyComponentProps = {
+ name: string;
+};
+
+export const MyComponent = ({ name }: MyComponentProps) => Hello {name}
;
+```
+
+#### Évitez d'utiliser `React.FC` ou `React.FunctionComponent` pour définir les types de props.
+
+```tsx
+/* ❌ - Bad, defines the component type annotations with `FC`
+ * - With `React.FC`, the component implicitly accepts a `children` prop
+ * even if it's not defined in the prop type. This might not always be
+ * desirable, especially if the component doesn't intend to render
+ * children.
+ */
+const EmailField: React.FC<{
+ value: string;
+}> = ({ value }) => Hello World
+```
+
+```tsx
+// ✅ Good
+const StyledTitle = styled.div`
+ color: red;
+`;
+```
+
+Préfixez les composants stylisés avec "Styled" pour les différencier des composants "réels".
+
+```tsx
+// ❌ Bad
+const Title = styled.div`
+ color: red;
+`;
+```
+
+```tsx
+// ✅ Good
+const StyledTitle = styled.div`
+ color: red;
+`;
+```
+
+### Thematisation
+
+Utiliser le thème pour la majorité du stylisme des composants est l'approche préférée.
+
+#### Unités de mesure
+
+Évitez d'utiliser des valeurs `px` ou `rem` directement dans les composants stylisés. Les valeurs nécessaires sont généralement déjà définies dans le thème, il est donc recommandé d'utiliser le thème à ces fins.
+
+#### Couleurs
+
+Évitez d'introduire de nouvelles couleurs ; utilisez plutôt la palette existante du thème. Si la palette ne correspond pas, veuillez laisser un commentaire pour que l'équipe puisse rectifier cela.
+
+```tsx
+// ❌ Bad, directly specifies style values without utilizing the theme
+const StyledButton = styled.button`
+ color: #333333;
+ font-size: 1rem;
+ font-weight: 400;
+ margin-left: 4px;
+ border-radius: 50px;
+`;
+```
+
+```tsx
+// ✅ Good, utilizes the theme
+const StyledButton = styled.button`
+ color: ${({ theme }) => theme.font.color.primary};
+ font-size: ${({ theme }) => theme.font.size.md};
+ font-weight: ${({ theme }) => theme.font.weight.regular};
+ margin-left: ${({ theme }) => theme.spacing(1)};
+ border-radius: ${({ theme }) => theme.border.rounded};
+`;
+```
+
+## Application d'interdiction d'importations de type
+
+Évitez les importations de type. Pour appliquer cette norme, une règle ESLint vérifie et signale toutes les importations de type. Cela aide à maintenir la cohérence et la lisibilité dans le code TypeScript.
+
+```tsx
+// ❌ Bad
+import { type Meta, type StoryObj } from '@storybook/react';
+
+// ❌ Bad
+import type { Meta, StoryObj } from '@storybook/react';
+
+// ✅ Good
+import { Meta, StoryObj } from '@storybook/react';
+```
+
+### Pourquoi éviter les importations de type
+
+- **Cohérence** : En évitant les importations de type et en utilisant une seule approche pour les importations de type et de valeur, la base de code reste cohérente dans son style d'importation de module.
+
+- **Lisibilité** : Les importations sans type améliorent la lisibilité du code en clarifiant quand vous importez des valeurs ou des types. Cela réduit l'ambiguïté et facilite la compréhension de l'objectif des symboles importés.
+
+- **Maintenabilité** : Cela améliore la maintenabilité de la base de code car les développeurs peuvent identifier et localiser les importations uniquement de type lors de la révision ou de la modification du code.
+
+### Règle ESLint
+
+Une règle ESLint, `@typescript-eslint/consistent-type-imports`, applique la norme d'importation sans type. Cette règle génère des erreurs ou des avertissements pour toutes les violations d'importations de type.
+
+Veillez à ce que cette règle aborde spécifiquement les rares cas particuliers où se produisent des importations de type involontaires. TypeScript lui-même déconseille cette pratique, comme mentionné dans les [notes de version de TypeScript 3.8](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-8.html). Dans la majorité des situations, vous ne devriez pas avoir besoin d'utiliser des importations uniquement de type.
+
+Pour garantir la conformité de votre code avec cette règle, assurez-vous d'exécuter ESLint dans le cadre de votre flux de travail de développement.
diff --git a/packages/twenty-docs/fr/developers/frontend-development/work-with-figma.mdx b/packages/twenty-docs/fr/developers/frontend-development/work-with-figma.mdx
new file mode 100644
index 0000000000..ccc8e3995f
--- /dev/null
+++ b/packages/twenty-docs/fr/developers/frontend-development/work-with-figma.mdx
@@ -0,0 +1,66 @@
+---
+title: Travailler avec Figma
+info: Apprenez comment vous pouvez collaborer avec le Figma de Twenty
+image: /images/user-guide/objects/objects.png
+---
+
+
+
+
+
+Figma est un outil de conception d'interface collaboratif qui aide à surmonter la barrière de communication entre designers et développeurs.
+Ce guide explique comment vous pouvez collaborer avec Figma.
+
+## Accès
+
+1. **Accédez au lien partagé :** Vous pouvez accéder au fichier Figma du projet [ici](https://www.figma.com/file/xt8O9mFeLl46C5InWwoMrN/Twenty).
+2. **Se connecter :** Si vous n'êtes pas déjà connecté, Figma vous invitera à le faire.
+ Les fonctionnalités clés ne sont disponibles que pour les utilisateurs connectés, telles que le mode développeur et la possibilité de sélectionner un cadre dédié.
+
+
+
+
+
+
+
+
+
+
+## Consignes générales
+
+**Assurez-vous toujours de sauvegarder votre base de données avant de commencer le processus de mise à niveau** en exécutant `docker exec -it 
+
+
+**Remarque** : Pour connecter vos comptes e-mail et configurer les paramètres de synchronisation, rendez-vous sur [Configuration des e-mails et calendriers](/user-guide/settings/email-calendar-setup).
+
+## Comment fonctionne l'intégration des emails
+
+Twenty lie automatiquement les emails de vos boîtes aux lettres connectées aux enregistrements CRM pertinents, gardant tout l'historique de communication en un seul endroit.
+
+### Où trouver les emails
+
+Les conversations par email apparaissent dans trois objets principaux :
+
+- **Personnes** : Afficher tous les emails échangés avec un contact spécifique
+- **Entreprises** : Voir tous les emails relatifs à une entreprise et à ses employés
+- **Opportunités** : Accéder aux discussions email relatives à l'entreprise liée à cette opportunité. Les discussions par email des individus de l'opportunité ne sont pas encore affichées.
+
+### Consulter les discussions email
+
+1. **Naviguer jusqu'à un enregistrement** : Allez sur n'importe quel enregistrement de Personne, Entreprise ou Opportunité
+2. **Sélectionner l'onglet Emails** : Cliquez sur l'onglet `Emails` pour voir les e-mails synchronisés
+3. **Ouvrir une discussion email** : Cliquez sur n'importe quel email pour ouvrir et lire la conversation complète
+4. **Parcourir l'historique** : Faites défiler tout l'historique email avec ce contact
+
+
+
+## Ce que vous verrez
+
+### Vue de la discussion email
+
+Lorsque vous ouvrez une discussion par email, vous pouvez :
+
+- **Lire les Conversations Complètes** : Voir l'échange email complet
+- **Voir les Participants** : Voir toutes les personnes impliquées dans la discussion par email
+- **Vérifier les Horodatages** : Savoir exactement quand chaque email a été envoyé
+- **Accéder au Contexte** : Comprendre l'historique complet de la communication
+
+### Visibilité des emails
+
+En fonction de vos paramètres de boîte aux lettres, vous pourriez voir :
+
+- **Contenu Complet** : Texte et détails email complets
+- **Sujet + Métadonnées** : Ligne d'objet, expéditeur, destinataire et horodatage
+- **Métadonnées Seulement** : Informations de base sans contenu email
+
+## Comportement de synchronisation des emails
+
+### Ce qui est synchronisé
+
+- **Emails Externes** : Tous les e-mails avec des contacts en dehors de votre organisation
+- **Lien Automatique** : Les emails connectent aux enregistrements existants de Personnes et d'Entreprises
+- **Adresses Multiples** : Les emails de n'importe quelle adresse se lient au même enregistrement de contact
+- **Mises à jour** : Les nouveaux e-mails apparaissent dans les 5 minutes
+
+### Ce qui n'est pas synchronisé
+
+- **Emails Internes** : Les e-mails entre collègues (même domaine) restent privés
+- **Emails de Groupe** : Les listes de distribution et les e-mails de groupe sont exclus
+- **Dossiers Exclus** : Les dossiers que vous avez choisi de ne pas synchroniser (configurés sous Paramètres → Comptes → Email)
+
+### Synchronisation Sélective des Dossiers (Fonction de Laboratoire)
+
+Contrôlez quels dossiers e-mail sont synchronisés avec Twenty :
+
+1. Activez `Message Folder` dans Paramètres → Versions → Laboratoire
+2. Configurez les dossiers sous Paramètres → Comptes → Email
+3. Choisissez des dossiers spécifiques à inclure ou exclure (Boîte de réception, Envoyés, Archive, dossiers personnalisés)
+
+## Dépannage de la synchronisation des e-mails
+
+### Problèmes Courants de Synchronisation
+
+- **Retards de Synchronisation** : Les emails apparaissent dans les 5 minutes, mais les importations initiales prennent plus de temps
+- **Emails Manquants** : Vérifiez si :
+ - Les dossiers sont exclus dans les paramètres de Message Folder
+ - La création automatique de contacts est désactivée (les e-mails nécessitent des enregistrements existants dans Twenty)
+ - L'e-mail provient des collègues (même domaine) ou des listes de groupe
+ - La boîte aux lettres termine toujours la synchronisation initiale
+
+### Limitations des e-mails
+
+- **Dossiers Systèmes** : Certains dossiers d'e-mail peuvent ne pas être disponibles pour la synchronisation
+- **Alias** : Seules les véritables boîtes aux lettres peuvent être connectées (non pas des alias d'email)
+
+## Intégration du Calendrier
+
+### Onglet Calendrier
+
+À côté de l'onglet Emails, vous trouverez un onglet `Calendrier` contenant l'historique des réunions prévues avec l'enregistrement.
+
+**Disponible pour :**
+
+- **Personnes** : Voir toutes les réunions prévues avec un contact spécifique
+- **Entreprises** : Voir toutes les réunions liées à une entreprise et à ses employés
+- **Opportunités** : Accéder à l'historique des réunions liées à l'entreprise associée à cette opportunité
+
+**Paramètres de Visibilité** : Les données de calendrier suivent les mêmes paramètres de visibilité que les e-mails, assurant des contrôles de confidentialité cohérents.
+
+### Consulter l'Historique des Réunions
+
+1. **Naviguer jusqu'à un enregistrement** : Allez sur n'importe quel enregistrement de Personne, Entreprise ou Opportunité
+2. **Sélectionner l'onglet Calendrier** : Cliquez sur l'onglet `Calendrier` à côté de l'onglet Emails
+3. **Parcourir l'Historique des Réunions** : Voir toutes les réunions prévues et leurs détails
+4. **Accéder au Contexte des Réunions** : Voir les participants aux réunions, les horaires et les informations connexes
+
+
diff --git a/packages/twenty-docs/fr/user-guide/collaboration/notes.mdx b/packages/twenty-docs/fr/user-guide/collaboration/notes.mdx
new file mode 100644
index 0000000000..5f8269a354
--- /dev/null
+++ b/packages/twenty-docs/fr/user-guide/collaboration/notes.mdx
@@ -0,0 +1,114 @@
+---
+title: Notes
+info: Explorez comment gérer efficacement les notes dans les pages d'enregistrement dans Twenty.
+image: /images/user-guide/notes/notes_header.png
+sectionInfo: Découvrez comment tirer parti des Notes et Tâches pour mieux collaborer avec votre équipe.
+---
+
+
+
+
+
+Gérez vos notes liées aux enregistrements efficacement en utilisant la fonctionnalité puissante **Notes**. Ce guide explique comment créer, formater, commenter et supprimer des notes de façon transparente au sein des pages d'enregistrement.
+
+## Cas d'utilisation courants
+
+### Documentation de réunion
+
+- **Compte rendu de réunion** : Consignez les points de discussion clés, les décisions et les éléments d'action des appels clients
+- **Sommaires d'appel** : Enregistrez les détails importants des conversations de vente ou des appels de support
+- **Notes de suivi** : Documentez les prochaines étapes et engagements pris durant les réunions
+
+### Interactions avec les clients
+
+- **Historique de support** : Suivez les problèmes des clients, les solutions fournies et le statut de résolution
+- **Contexte des ventes** : Enregistrez les préférences des clients, leurs points faibles et les signaux d'achat.
+- **Renforcement des relations** : Notez les détails personnels sur les contacts pour renforcer les relations
+
+### Gestion de projet
+
+- **Mises à jour de statut** : Documentez les progrès du projet et les réalisations des jalons
+- **Suivi des problèmes** : Consignez les problèmes rencontrés et les solutions mises en œuvre
+- **Transferts d'équipe** : Partagez le contexte lors du transfert des comptes entre les membres de l'équipe
+
+### Création automatique de notes
+
+Utilisez [Workflows](/user-guide/workflows/getting-started-workflows) pour créer automatiquement des notes :
+
+- **Intégration d'enregistreur d'appel** : Générez automatiquement des résumés de réunions à partir d'appels enregistrés
+- **Notes de transfert d'opportunité** : Créez automatiquement des résumés de cycle de vente lors du transfert de nouveaux clients aux équipes de mise en œuvre
+
+## Fonctionnalités des notes
+
+### Champ de relations
+
+Les notes incluent un champ **Relations** qui vous permet de joindre une note unique à plusieurs enregistrements sur différents objets. Par exemple, vous pouvez lier une note de réunion à :
+
+- La personne que vous avez rencontrée
+- La société qu'elle représente
+- L'opportunité discutée
+- Toutes les tâches ou autres enregistrements pertinents
+
+Cette relation morphable garantit que les informations importantes sont accessibles depuis toutes les pages d'enregistrement pertinentes.
+
+### Marquage utilisateur
+
+**Note** : Le marquage utilisateur dans les notes n'est actuellement pas disponible. Cette fonctionnalité est prévue pour 2026 et vous permettra de mentionner des membres de l'équipe et de déclencher des notifications.
+
+## Création de notes
+
+Créer des notes dans le système est intuitif et dynamique. Vous pouvez soit :
+
+- Naviguer vers la vue des notes et créer un nouvel enregistrement.
+- Allez sur une `page d'enregistrement` et sélectionnez l'onglet Notes puis appuyez sur le bouton `Nouvelle note`.
+
+
+
+### Ajout de contenu
+
+Commencez à taper directement ou appuyez sur « / » pour ajouter instantanément des éléments comme des titres, des fichiers ou des images.
+
+### Formatage du contenu
+
+Vous pouvez formater vos notes directement depuis l'éditeur. Utilisez la syntaxe Markdown, appuyez sur la touche `/` ou cliquez sur l'icône `+` de l'éditeur pour voir les différentes options de bloc, telles que les titres, les tableaux et les listes. Vous pouvez également joindre des images à votre note.
+
+Sélectionnez le texte pour voir plus d'options de formatage telles que le gras, l'italique et les options d'alignement.
+
+Vous pouvez également changer la couleur de fond et la couleur du texte de chaque bloc pour mettre en évidence des éléments importants dans votre note. Pour ce faire, passez la souris sur le bloc que vous souhaitez formater et cliquez sur l'icône `⋮` à côté de l'icône `+`. Cliquez sur `Couleurs` pour ouvrir toutes les options de couleur pour le texte et l'arrière-plan.
+
+
+
+
+
+
+## Visualisation des notes
+
+Le système affiche toutes vos notes liées à un enregistrement spécifique sous la section Notes sur la `page d'enregistrement` correspondante.
+
+## Enregistrement et suppression
+
+Toutes les modifications et ajouts à la note sont automatiquement sauvegardés.
+
+Pour supprimer une note :
+
+1. Ouvrez la note que vous souhaitez supprimer en cliquant dessus depuis la `page d'enregistrement`.
+2. Sélectionnez la note que vous souhaitez supprimer dans l'onglet des notes.
+3. Utilisez le bouton `Option` dans le coin inférieur droit pour accéder à des actions supplémentaires, y compris la suppression.
+4. Complétez votre suppression lorsqu'elle est demandée par la fenêtre de confirmation.
+
+Une autre façon de supprimer une note est à travers la vue des notes comme vous le feriez avec un enregistrement normal. Veuillez noter que supprimer une note est permanent et ne peut pas être annulé.
+
diff --git a/packages/twenty-docs/fr/user-guide/collaboration/tasks.mdx b/packages/twenty-docs/fr/user-guide/collaboration/tasks.mdx
new file mode 100644
index 0000000000..e9784041ab
--- /dev/null
+++ b/packages/twenty-docs/fr/user-guide/collaboration/tasks.mdx
@@ -0,0 +1,167 @@
+---
+title: Tâches
+info: Comprenez comment gérer efficacement les tâches dans Twenty.
+image: /images/user-guide/tasks/tasks_header.png
+sectionInfo: Découvrez comment tirer parti des Notes et Tâches pour mieux collaborer avec votre équipe.
+---
+
+
+ 
+
+
+Gérez toutes les tâches dans votre espace de travail à l'aide de la fonctionnalité **Tâches**. Ce guide vous montrera comment créer et gérer des tâches, passer des tâches à venir à celles terminées, modifier les détails des tâches, et bien plus encore.
+
+## Cas d'utilisation courants
+
+### Suivis des ventes
+
+- **Prochaines étapes de la réunion** : Créez des tâches pour les actions discutées lors des appels clients
+- **Suivis de propositions** : Configurez des rappels pour suivre les propositions en attente
+- **Relectures de contrat** : Planifiez des tâches pour les négociations et approbations de contrats
+
+### Réussite client
+
+- **Tâches d'intégration** : Créez automatiquement des listes de contrôle d'intégration lors de la clôture des dossiers
+- **Rappels de vérification** : Planifiez des appels de vérification réguliers de l'état de santé des clients
+- **Préparation au renouvellement** : Définir des tâches pour préparer les renouvellements de contrat 90 jours à l'avance
+
+### Gestion de projet interne
+
+Au-delà des ventes et de la réussite client, les tâches répondent à des besoins organisationnels plus larges :
+
+- **Développement de Produits** : Suivre les sorties de fonctionnalités, corrections de bugs et jalons de développement
+- **Campagnes marketing** : Gérez les lancements de campagnes, la création de contenu, et les activités promotionnelles
+- **Operations RH** : Gérez les processus de recrutement, l'intégration des employés, et les évaluations de performances
+- **Tâches Financières** : Planifier les révisions budgétaires, le traitement des factures et la déclaration financière
+- **Opérations** : Coordonnez la gestion des installations, les relations avec les fournisseurs, et les améliorations de processus
+
+### Création automatisée de tâches
+
+Utilisez [Workflows](/user-guide/workflows/getting-started-workflows) pour créer automatiquement des tâches :
+
+- **Déclencheurs de succès** : Créez automatiquement des tâches d'intégration assignées à l'équipe CS lors de la clôture des opportunités
+- **Rappels par email** : Configurez des rappels par email hebdomadaires pour les tâches à terminer cette semaine (envoyés tous les lundis)
+- **Automatisation du pipeline** : Créez des tâches de suivi lorsque les affaires stagnent dans des étapes spécifiques
+- **Intégration de réunions** : Générez automatiquement des tâches à partir des enregistrements de réunions ou d'événements de calendrier
+
+## Fonctionnalités de Tâche
+
+### Champ de relations
+
+Les tâches incluent un champ `Relations` qui vous permet de joindre une seule tâche à plusieurs enregistrements à travers différents objets. Par exemple, vous pouvez lier une tâche de suivi à :
+
+- La personne que vous devez contacter
+- La société qu'elle représente
+- L'opportunité en cours
+- Toutes les notes pertinentes ou autres enregistrements
+
+Cette relation polymorphe garantit que les tâches sont accessibles depuis toutes les pages d'enregistrement pertinentes, offrant un contexte complet.
+
+### Marquage utilisateur
+
+**Remarque** : Le marquage des utilisateurs dans les tâches n'est actuellement pas disponible. Cette fonctionnalité est prévue pour 2026, ce qui permettra de mentionner les membres de l'équipe et de déclencher des notifications lors de l'attribution ou de la mise à jour des tâches.
+
+## Créer des tâches
+
+Créer des tâches dans Twenty est sans effort. Vous pouvez soit :
+
+- Accédez à l'onglet `Tâches` et appuyez sur le bouton `+` en haut à droite de la page.
+- Utilisez la fonction de recherche en appuyant sur `cmd/ctrl + k`, puis sélectionnez 'Créer une tâche' dans la liste des actions rapides.
+- Accédez à une `page d'enregistrement` et appuyez sur le `+` en haut à droite de la page, ou allez dans l'onglet Tâche et appuyez sur le bouton `Ajouter une tâche`.
+
+
+
+
+
+
+### Ajouter du contenu aux tâches
+
+Une fois que vous avez créé une tâche, vous pouvez l'enrichir avec du contenu riche, tel que des titres, des puces ou même des images. Pour ce faire, appuyez sur `/` et entrez la commande souhaitée.
+
+## Visualiser les Tâches
+
+La page **Tâches** affiche toutes vos tâches dans votre espace de travail. Vous pouvez ici :
+
+- Filtrer les tâches assignées à un utilisateur spécifique en cliquant sur le bouton avec votre nom en haut à droite de l'écran.
+- Basculez entre les tâches à venir (`À faire`) et celles complétées (`Terminé`) pour voir ce qui nécessite une attention et ce que vous avez accompli.
+
+Vous pouvez également voir les tâches pour un enregistrement donné sur sa `page d'enregistrement`.
+
+
+
+
+
+
+## Modifier les tâches
+
+Pour modifier une tâche, vous devez cliquer sur sa carte. Cela ouvrira un panneau latéral offrant les fonctionnalités suivantes :
+
+- **Assignee et date d'échéance** : Mettez à jour l'assigné ou modifiez la date d'échéance.
+- **Commentaires** : Collaborez avec vos membres d'équipe en ajoutant des commentaires sur les tâches pour fournir des mises à jour ou des retours.
+- **Automatisations** : Grâce à l'API et aux Webhooks, vous pouvez également automatiser la création de tâches déclenchée par des activités spécifiques dans votre espace de travail.
+
+## Marquer les tâches comme complètes
+
+Pour marquer une tâche comme complète :
+
+1. Localisez la tâche sur votre page `Tâches` ou dans une `page d'enregistrement`.
+2. Cliquez sur le cercle à gauche de la carte de tâche, il changera pour signifier l'achèvement.
+3. Le statut de la tâche se mettra automatiquement à jour en `Terminé`.
+
+Cette procédure aidera à garder un enregistrement à jour de vos réalisations.
+
+
+
+
+
+
+## Supprimer une tâche
+
+Pour supprimer définitivement une tâche :
+
+1. Ouvrez la tâche que vous souhaitez supprimer en cliquant sur sa carte, soit depuis la page `Tâches` ou au sein d'une `page d'enregistrement`.
+2. Cliquez sur l'icône de la corbeille située dans le coin supérieur droit du panneau de détails de la tâche.
+
+Veuillez noter que la suppression d'une tâche est permanente et ne peut pas être annulée. Considérez la possibilité de marquer les tâches comme `Terminées` s'il y a une chance que vous ayez besoin de vous référer à elles à nouveau.
diff --git a/packages/twenty-docs/fr/user-guide/crm-essentials/contact-and-account-management.mdx b/packages/twenty-docs/fr/user-guide/crm-essentials/contact-and-account-management.mdx
new file mode 100644
index 0000000000..2578d3627f
--- /dev/null
+++ b/packages/twenty-docs/fr/user-guide/crm-essentials/contact-and-account-management.mdx
@@ -0,0 +1,95 @@
+---
+title: Gestion des contacts et des comptes
+info: "Créez et gérez les dossiers de personnes et d'entreprises pour constituer votre base de données clients."
+image: /images/user-guide/home/contact-and-account-management.png
+sectionInfo: "Fonctionnalités essentielles du CRM pour gérer les prospects, les ventes et les clients"
+---
+
+
+ 
+
+
+## Importer des données dans votre CRM
+
+Lorsque vous commencez à utiliser Twenty, vous devez intégrer vos contacts et entreprises dans le système. Il existe plusieurs manières de remplir votre CRM en fonction de votre flux de travail et de vos sources de données.
+
+### Saisie manuelle
+
+La méthode la plus simple consiste à ajouter des enregistrements directement via l'interface de Twenty. Allez dans la section `Personnes` et cliquez sur le bouton `+` pour ajouter un nouveau contact. Remplissez leur nom, email, téléphone, et liez-les à leur entreprise. Pour les entreprises, allez dans la section `Entreprises` et ajoutez les détails de l'organisation : nom de l'entreprise, domaine, secteur d'activité et taille.
+
+Le champ de domaine est particulièrement important pour l'identification de l'entreprise, et le champ de l'e-mail est essentiel pour l'identification des personnes.
+
+### Importations CSV
+
+Lorsque vous disposez de données existantes provenant de feuilles de calcul ou d'autres systèmes, l'importation CSV est votre option la plus rapide. Vous pouvez préparer vos données dans Excel ou Google Sheets, puis les télécharger en une seule fois. Cela est particulièrement utile lors de la migration depuis un autre CRM ou lorsque quelqu'un a suivi les contacts dans des feuilles de calcul. Notre guide [Importer/Exporter des données](/user-guide/getting-started/import-export-data) vous accompagne dans le processus.
+
+### Capture de données automatisée
+
+Pour une génération continue de prospects, vous pouvez configurer des flux de travail automatisés qui intègrent directement les données dans Twenty :
+
+**Formulaires de site Web** : Lorsque quelqu'un remplit un formulaire sur votre site, vous pouvez le configurer pour envoyer automatiquement les informations à Twenty. La soumission du formulaire déclenche un webhook qui active un flux de travail dans Twenty, créant le nouvel enregistrement de contact sans aucune intervention manuelle.
+
+**Intégration avec d'autres systèmes** : Si vous utilisez d'autres outils professionnels, vous pouvez les connecter à Twenty via des appels API et des flux de travail. Cela vous permet de synchroniser automatiquement les données entre les systèmes : par exemple, faire entrer de nouveaux clients depuis votre système de facturation ou des prospects depuis votre plateforme marketing.
+
+Pour en savoir plus sur la configuration de ces flux de données automatisés, consultez notre section [Workflows](/user-guide/workflows/getting-started-workflows).
+
+### Synchronisation des e-mails et du calendrier
+
+Lorsque vous connectez votre boîte aux lettres et votre calendrier à Twenty, le système peut automatiquement créer des enregistrements de personnes et d'entreprises pour les personnes que vous envoyez un e-mail ou rencontrez. Si vous envoyez un e-mail à une personne qui n'est pas déjà dans votre CRM, Twenty peut créer un nouvel enregistrement pour elle. Il en est de même lorsque vous planifiez des réunions avec de nouveaux contacts via votre calendrier.
+
+C'est particulièrement utile pour les équipes commerciales et de développement des affaires qui rencontrent constamment de nouvelles personnes. Au lieu d'ajouter manuellement chaque nouveau contact, Twenty les capture automatiquement au fur et à mesure que vous communiquez. Découvrez comment configurer cela dans notre guide [E-mails et Calendriers](/user-guide/collaboration/emails-and-calendars).
+
+### Réduire le travail manuel
+
+Même lorsque vous ajoutez des données manuellement, vous pouvez utiliser des flux de travail pour simplifier le processus. Par exemple, vous pouvez configurer une automatisation qui assigne de nouveaux contacts aux membres de l'équipe en fonction de leur localisation, ou qui crée automatiquement des tâches de suivi lorsque certains types de contacts sont ajoutés.
+
+## Organiser vos contacts
+
+### Conserver les données uniques et propres
+
+Twenty applique automatiquement l'unicité pour organiser vos données. L'adresse e-mail de chaque personne sert d'identifiant unique : vous ne pouvez pas avoir deux personnes avec la même adresse e-mail. De même, les domaines des entreprises sont uniques, donc vous ne créerez pas accidentellement des entreprises en double.
+
+Si votre entreprise a besoin que d'autres champs soient uniques (comme les numéros de téléphone, ou les codes de référence), vous pouvez le configurer dans votre modèle de données. Consultez notre section [Modèle de données](/user-guide/data-model/customize-your-data-model) pour apprendre comment configurer des contraintes d'unicité supplémentaires selon vos besoins spécifiques.
+
+### Gestion des doublons
+
+Parfois, vous vous retrouverez avec des enregistrements en double. Twenty dispose d'une fonction de fusion pour les personnes et les entreprises : vous pouvez combiner des enregistrements en double pour garder votre base de données propre sans perdre d'informations.
+
+Pour fusionner des enregistrements, sélectionnez 2 enregistrements, ouvrez le menu de commande `Cmd+K` sur Mac, `Ctrl+K` sur Windows et cliquez sur `Fusionner les enregistrements`.
+
+### Création de hiérarchies d'entreprises
+
+Si vous travaillez avec de grandes organisations qui ont des filiales ou plusieurs divisions, vous pouvez créer des relations entre les entreprises. Configurez des champs de relation entre les enregistrements d'entreprise pour cartographier ces connexions. Cela vous aide à comprendre la structure organisationnelle complète avec laquelle vous travaillez.
+
+### Personnaliser vos vues
+
+Différents membres de l'équipe peuvent avoir besoin de voir différentes informations. Vous pouvez créer des vues personnalisées qui montrent différentes colonnes pour différents objectifs : peut-être que votre équipe de vente doit voir les étapes des offres tandis que votre équipe de support se concentre sur les détails de contact. En savoir plus à ce sujet dans notre article [Gestion des vues](/user-guide/crm-essentials/view-management).
+
+## Travailler avec des enregistrements
+
+### Ce que vous trouverez dans chaque enregistrement
+
+Lorsque vous ouvrez un enregistrement de personne ou d'entreprise, vous voyez toutes leurs informations organisées en onglets :
+
+- **Champs** : Les informations de base telles que le nom, l'email, le téléphone et tous les champs personnalisés que vous avez ajoutés
+- **Relations** : Montre les connexions entre cet enregistrement et des enregistrements d'autres objets
+- **Chronologie** : Une vue chronologique de toutes les interactions et mises à jour de cet enregistrement
+- **Tâches** : Toutes les tâches de suivi liées à ce contact
+- **Notes** : Notes d'équipe et observations sur cette personne ou entreprise
+- **Fichiers** : Documents et pièces jointes liés à cet enregistrement
+- **E-mails** : Fils de discussion par e-mail avec ce contact (lorsque votre équipe a connecté ses boîtes aux lettres)
+- **Calendrier** : Réunions et rendez-vous avec ce contact
+
+Les onglets Email et Calendrier sont particulièrement puissants : ils affichent automatiquement tous les échanges par email et les réunions que quiconque dans votre équipe a eus avec ce contact, tant qu'ils ont connecté leur boîte mail à Twenty. Vous pouvez en savoir plus sur la mise en place de ceci dans notre guide [Emails et Calendriers](/user-guide/collaboration/emails-and-calendars).
+
+### Ajouter les champs dont vous avez besoin
+
+Les champs standards pourraient ne pas capturer tout ce qui est important pour votre entreprise. Si vous avez besoin d'informations supplémentaires, telles que des segments de clientèle, des sources de recommandations, ou des données spécifiques au secteur, vous pouvez ajouter des champs personnalisés ou modifier ceux existants. Rendez-vous dans notre section [Modèle de données](/user-guide/data-model/customize-your-data-model) pour apprendre comment personnaliser votre configuration.
+
+## Gérer les enregistrements supprimés
+
+Lorsque vous supprimez un enregistrement dans Twenty, il n'est pas perdu pour toujours. Les enregistrements sont "soft deletions", ce qui signifie qu'ils sont cachés mais peuvent être restaurés si nécessaire.
+
+Pour accéder aux enregistrements supprimés, ouvrez le menu de commande `Cmd+K` sur Mac, `Ctrl+K` sur Windows, puis cliquez sur `Voir les enregistrements supprimés`. De là, vous pouvez soit restaurer les enregistrements, soit les supprimer définitivement si vous êtes sûr de ne pas en avoir besoin.
+
+Ce filet de sécurité signifie que vous pouvez nettoyer votre base de données sans vous soucier de perdre par accident des informations importantes.
diff --git a/packages/twenty-docs/fr/user-guide/crm-essentials/pipeline.mdx b/packages/twenty-docs/fr/user-guide/crm-essentials/pipeline.mdx
new file mode 100644
index 0000000000..dfdfb90e25
--- /dev/null
+++ b/packages/twenty-docs/fr/user-guide/crm-essentials/pipeline.mdx
@@ -0,0 +1,105 @@
+---
+title: Pipeline
+info: "Suivez et gérez vos opportunités de vente à travers des étapes de pipeline personnalisables."
+image: /images/user-guide/kanban-views/kanban.png
+sectionInfo: "Fonctionnalités essentielles du CRM pour gérer les prospects, les ventes et les clients"
+---
+
+
+
+
+
+## Comprendre les Pipelines
+
+Un pipeline de vente suit les opportunités depuis le contact initial jusqu'à la conclusion de l'affaire. Chaque étape représente une étape dans votre processus de vente, et les opportunités passent par ces étapes à mesure qu'elles progressent vers la clôture.
+
+Twenty inclut des étapes de vente standard telles que Prospection, Qualification, Proposition, Négociation, Fermeture. Vous pouvez personnaliser ces étapes pour correspondre à votre processus de vente spécifique.
+
+## Travailler avec les Vues Kanban
+
+Les vues Kanban cartographient visuellement votre pipeline, où chaque colonne représente une étape et chaque carte représente une opportunité. Chaque carte montre des informations clés comme la valeur de l'affaire, la date de clôture et le propriétaire assigné, d'un seul coup d'œil. Pour des détails complets : y compris notes, tâches, réunions, et historique des emails, cliquez sur n'importe quelle carte pour ouvrir le dossier complet de l'opportunité.
+
+### Déplacement des opportunités à travers votre pipeline
+
+Vous pouvez déplacer chaque opportunité entre les étapes à mesure qu'elle progresse dans votre processus de vente en la glissant-déposant. Maintenez le clic sur une carte et déplacez-la à l'étape suivante.
+
+
+
+
+
+
+### Personnaliser vos étapes de pipeline
+
+Vous pouvez adapter votre pipeline pour convenir à votre processus de vente spécifique. Les étapes représentent des valeurs dans un champ de sélection, vous pouvez donc les ajouter, les supprimer ou les renommer au besoin.
+
+#### Ajouter des étapes
+
+Pour ajouter une étape, accédez aux Paramètres du Champ de Sélection en naviguant vers Paramètres → Modèle de Données, sélectionnez votre objet, puis le champ dont dépend votre tableau Kanban.
+
+
+
+
+
+
+#### Supprimer des étapes
+
+Pour supprimer une étape, survolez le nom de l'étape ou l'icône `⋮`, cliquez sur `Modifier depuis les réglages` dans les paramètres du champ de sélection, puis cliquez sur `Supprimer` à côté de l'étape concernée.
+
+
+
+### Personnalisation des cartes
+
+Vous pouvez configurer votre tableau Kanban pour afficher certains champs et en masquer d'autres. Pour masquer un champ, cliquez sur `Options` en haut à droite, puis sur `Champs` pour faire apparaître la liste des options. Survolez le champ que vous souhaitez masquer pour faire apparaître le bouton `-`. Cliquez dessus pour masquer le champ.
+
+Vous pouvez également réorganiser l'ordre des champs en maintenant le nom du champ et en le glissant à l'endroit souhaité.
+
+
+
+### Vue compacte
+
+Vous pouvez également masquer tous les champs et obtenir une vue d'ensemble de toutes les opportunités en un coup d'œil. Pour ce faire, cliquez sur `Options` en haut à droite et activez le bascule pour la `Vue compacte` après avoir sélectionné la mise en page en vue kanban.
+
+
+
+## Gestion avancée du pipeline
+
+### Automatisation avec les flux de travail
+
+Utilisez [Flux de travail](/user-guide/workflows/getting-started-workflows) pour automatiser votre pipeline :
+
+- **Progression automatique des étapes** : Passez les affaires basées sur les activités.
+- **Notifications** : Alertez les membres de l'équipe des changements d'étapes.
+- **Création de tâches** : Générer des tâches de suivi pour chaque étape.
+
+### Multiples pipelines
+
+Vous pouvez créer différents pipelines pour diverses lignes de métier, segments de marché ou équipes de vente spécialisées en créant de nouvelles vues. Chaque vue peut afficher différentes opportunités avec des filtres et étapes spécifiques adaptés à vos besoins. Découvrez comment créer ces vues dans notre guide de [Gestion des Vues](/user-guide/crm-essentials/view-management).
+
diff --git a/packages/twenty-docs/fr/user-guide/crm-essentials/view-management.mdx b/packages/twenty-docs/fr/user-guide/crm-essentials/view-management.mdx
new file mode 100644
index 0000000000..637296d2b5
--- /dev/null
+++ b/packages/twenty-docs/fr/user-guide/crm-essentials/view-management.mdx
@@ -0,0 +1,204 @@
+---
+title: Gestion de l'affichage
+info: "Créez et personnalisez des vues pour organiser vos données avec des filtres, des tris et différents agencements."
+image: /images/user-guide/table-views/table.png
+sectionInfo: "Fonctionnalités essentielles du CRM pour gérer les prospects, les ventes et les clients"
+---
+
+
+
+
+
+## Options de mise en page
+
+Vous pouvez afficher vos données dans trois mises en page différentes, chacune adaptée à des fins différentes. Des mises en page personnalisées pour personnaliser l'apparence de la page pour chaque type d'enregistrement seront disponibles en décembre 2025.
+
+### Vue par défaut
+
+Chaque objet est doté d'une vue non filtrée, non triée et non supprimable connue sous le nom de vue par défaut. Elle est nommée d'après le nom pluriel de l'objet, tel que `Toutes les entreprises`, `Toutes les personnes`, `Toutes les opportunités`.
+
+
+### Disposition en liste
+
+Le format de table standard qui affiche les enregistrements en lignes et en colonnes. Parfait pour voir des informations détaillées en un coup d'œil et comparer des enregistrements côte à côte.
+
+### Agencement de Liste par Groupes
+
+Organise vos enregistrements en les regroupant en fonction d'un champ sélectionné. Par exemple, vous pouvez regrouper les opportunités par étape, les entreprises par emplacement ou tout autre champ sélectionné. Cela vous aide à voir les tendances et à organiser les enregistrements connexes ensemble.
+
+### Disposition Kanban
+
+Un tableau visuel où chaque colonne représente une étape et chaque enregistrement apparaît comme une carte. Cet agencement est idéal pour gérer les pipelines et les flux de travail où les enregistrements passent par différentes étapes. Pour plus de détails sur l'utilisation des vues Kanban pour la gestion des pipelines, consultez notre article [Pipeline](/user-guide/crm-essentials/pipeline).
+
+
+
+
+
+
+## Créer de nouvelles vues
+
+Il y a trois façons de créer une nouvelle vue :
+
+### Utilisation du menu de commande
+
+Utilisez `Cmd+K` sur Mac (ou `Ctrl+K` sur Windows) pour ouvrir le menu de commandes, puis cliquez sur `Créer une nouvelle vue`.
+
+### Utilisation du menu déroulant de la vue
+
+Cliquez sur le menu déroulant de la vue (en haut à gauche), puis cliquez sur `Ajouter une vue` en bas. À partir de ce menu, vous pouvez :
+
+- Choisir une icône et un nom pour votre vue
+- Sélectionner le type de mise en page (Liste ou Kanban)
+
+
+
+
+
+
+### Créer des vues à partir de filtres existants
+
+Lorsque vous modifiez le tri et le filtrage d'une vue existante, un bouton `Enregistrer sous une nouvelle vue` apparaît. Cela vous permet de créer une nouvelle vue basée sur vos personnalisations actuelles.
+
+
+
+
+
+
+## Rendre les vues exploitables
+
+Les conseils ci-dessous vous montrent comment personnaliser les colonnes de vos vues. Nous ne recommandons pas de conserver toutes les colonnes : ces vues peuvent être simplifiées et rendues exploitables en ajoutant des conditions de tri et en affichant uniquement certaines colonnes qui sont pertinentes à votre cas d'utilisation spécifique.
+
+## Personnalisation de vos vues
+
+Toutes les mises en page prennent en charge les mêmes options de personnalisation : tri, filtrage et sélection des champs. Vous pouvez effectuer des modifications rapides et uniques en cliquant directement sur le nom de la colonne, ou utiliser le `Menu d'options` pour une édition plus complète.
+
+### Actions rapides contre Menu d'options
+
+**Pour des modifications uniques** : Cliquez directement sur les en-têtes de colonne pour trier, ou utilisez les boutons `Déplacer à gauche`, `Déplacer à droite`.
+
+**Pour des modifications multiples** : Utilisez le `Menu d'options` (coin supérieur droit) lorsque vous souhaitez effectuer plusieurs changements d'affilée. Ce menu vous donne accès à :
+
+- **Sélection de la mise en page** (Liste, Liste Groupée par, Kanban)
+- **Options de regroupement** (pour la mise en page Liste Groupée par)
+- **Gestion des champs** (afficher/masquer et réorganiser les colonnes)
+
+### Filtrage de vos données
+
+Vous pouvez appliquer des filtres pour montrer uniquement les enregistrements qui correspondent à vos critères. Cliquez sur `Filtrer` dans la barre d'outils, sélectionnez un champ, choisissez votre condition et définissez la valeur. Vous pouvez ajouter plusieurs filtres pour un filtrage avancé basé sur plusieurs conditions.
+
+
+
+
+
+
+### Tri de vos enregistrements
+
+Contrôlez l'ordre de vos enregistrements en cliquant sur n'importe quel en-tête de colonne pour trier par ce champ. Cliquez à nouveau pour inverser l'ordre de tri. Vous pouvez appliquer plusieurs tris pour une organisation complexe.
+
+
+
+
+
+
+### Gestion des champs et des colonnes
+
+Vous pouvez choisir quels champs afficher et les réorganiser. Pour des modifications rapides, cliquez directement sur un nom de colonne. Pour des modifications multiples, utilisez `Menu d'options → Champs` où vous pouvez :
+
+- Afficher ou masquer les champs à l'aide de l'icône œil
+- Réorganiser les champs par glisser-déposer
+- Effectuer plusieurs changements efficacement en un seul endroit
+
+## Gestion de vos vues
+
+### Fonctionnalités du menu déroulant des vues
+
+Le menu déroulant de la vue (en haut à gauche) est votre hub central pour la gestion des vues. À partir d'ici, vous pouvez :
+
+- **Modifier les noms et les icônes des vues** : Cliquez sur les trois points à côté de n'importe quelle vue
+- **Réorganiser les vues** : Glisser-déposer les vues pour les organiser par priorité
+- **Enregistrer les vues comme favoris** : Les favoris apparaissent juste sous Paramètres pour un accès rapide
+
+### Édition et suppression de vues
+
+Pour modifier ou supprimer des vues, ouvrez le menu déroulant des vues et survolez la vue que vous souhaitez modifier. Cliquez sur les trois points qui apparaissent pour accéder aux options de modification et de suppression.
+
+### Favoris et organisation
+
+Les vues enregistrées comme favoris apparaissent juste sous Paramètres dans votre navigation, vous donnant un accès instantané à vos vues les plus importantes. Utilisez le menu déroulant des vues pour organiser vos vues en les faisant glisser dans l'ordre qui convient le mieux à votre flux de travail.
+
+Pour une organisation des données plus avancée, consultez notre section [Modèle de données](/user-guide/data-model/customize-your-data-model) pour en savoir plus sur la personnalisation des champs et des objets.
diff --git a/packages/twenty-docs/fr/user-guide/data-model/creating-records.mdx b/packages/twenty-docs/fr/user-guide/data-model/creating-records.mdx
new file mode 100644
index 0000000000..aaebd245e1
--- /dev/null
+++ b/packages/twenty-docs/fr/user-guide/data-model/creating-records.mdx
@@ -0,0 +1,72 @@
+---
+title: Vues de Tableau
+info: "Apprenez à personnaliser et à naviguer dans les vues de tableau."
+image: /images/user-guide/table-views/table.png
+sectionInfo: Découvrez comment utiliser des objets standards et personnalisés dans votre espace de travail.
+---
+
+
+
+
+
+## À propos des Vues de Tableau
+
+Les vues de tableau sont des représentations visuelles des données structurées en lignes et colonnes.
+
+## Créer un enregistrement
+
+Ajoutez des enregistrements selon vos besoins, sans limites. Pour ajouter un enregistrement, vous pouvez soit cliquer sur le bouton **+** en haut à droite de l'écran, soit en haut de la colonne **Nom** de l'enregistrement.
+
+Saisissez le nom de l'enregistrement puis appuyez sur `Entrée` pour sauvegarder. Pour modifier le nom d'un enregistrement, cliquez sur son nom dans sa page de détails.
+
+
+
+
+
+
+## Supprimer l'enregistrement
+
+**Vue de l'index :** Pour supprimer un enregistrement, sélectionnez la case à côté de l'enregistrement et cliquez sur le bouton de suppression dans le coin supérieur droit.
+
+**Page de l'enregistrement :** Appuyez sur l'icône `⋮` dans le coin supérieur droit, puis sélectionnez supprimer.
+
+
+
+
+
+
+## Ajouter un champ personnalisé
+
+Pour créer un champ personnalisé, cliquez sur le bouton **+** à l'extrémité droite des colonnes du tableau et sélectionnez **Personnaliser les champs**.
+
+
+
+Vous pouvez également le faire en naviguant vers **Paramètres** > **Modèle de données** > **Personnes**. Cliquez sur **Ajouter un champ**. Choisissez un nom et un type de champ. Le nouveau champ sera disponible dans l'application.
diff --git a/packages/twenty-docs/fr/user-guide/data-model/customize-your-data-model.mdx b/packages/twenty-docs/fr/user-guide/data-model/customize-your-data-model.mdx
new file mode 100644
index 0000000000..67b72f97b8
--- /dev/null
+++ b/packages/twenty-docs/fr/user-guide/data-model/customize-your-data-model.mdx
@@ -0,0 +1,69 @@
+---
+title: Personnalisez votre modèle de données
+info: "Apprenez à concevoir et créer un modèle de données qui reflète votre fonctionnement."
+image: /images/user-guide/fields/custom_data_model.png
+sectionInfo: Modèle de données flexible conçu pour soutenir vos processus métier uniques
+---
+
+
+ 
+
+
+## Qu'est-ce qu'un modèle de données ?
+
+Un modèle de données est la structure qui définit comment l’information est organisée dans votre CRM. Il détermine quels objets existent (comme les entreprises, les personnes ou les opportunités), quelles propriétés ils ont (ce sont les champs) et comment ils se rapportent les uns aux autres. Vous pouvez le considérer comme la carte de vos données clients.
+
+## Pourquoi personnaliser votre modèle de données ?
+
+Chaque entreprise fonctionne différemment. Être en mesure de personnaliser entièrement votre modèle de données signifie que vous pouvez façonner Twenty autour de vos processus au lieu de les forcer dans un système rigide.
+Twenty offre la flexibilité dont vous avez besoin pour façonner le modèle de données qui soutiendra au mieux votre quotidien. Vous pouvez créer autant d'objets et de champs personnalisés que vous le souhaitez, le prix ne changera pas.
+
+## Conseils pour concevoir votre modèle de données
+
+Il n'existe rarement qu'une seule façon de créer un modèle de données. Voici quelques conseils pour vous aider à construire le vôtre.
+
+**1. Commencez par vos objets principaux.**
+Identifiez les principaux concepts avec lesquels vous travaillez (p. ex. entreprises, personnes, opportunités). Ces trois objets sont déjà disponibles car ils sont utilisés très souvent. Mais pensez à d'autres dont vous pourriez avoir besoin.
+Exemple : Stripe nécessiterait un objet `Abonnements`, Airbnb aurait besoin d’un objet `Voyages`, un accélérateur de start-up d’un objet `Sessions`.
+
+**2. Utilisez des champs pour les variations, pas de nouveaux objets.**
+Si quelque chose est simplement une caractéristique d'un objet existant (p. ex. `Industrie` pour une entreprise, ou `Statut` pour une opportunité), faites-en un champ. Les champs sont idéaux pour les catégories, les étiquettes et les attributs.
+
+**3. Créez un nouvel objet lorsque cela se justifie.**
+Si le concept a son propre cycle de vie, ses propriétés ou relations, il mérite généralement un objet. Par exemple :
+
+- **Projets** ayant leurs propres délais, propriétaires, et tâches
+- **Abonnements** reliant des entreprises, des produits et des factures
+- **Événements** impliquant de nombreux participants et actions de suivi
+
+Ceux-ci vont au-delà d'un seul champ car ils transportent leurs propres données et relations.
+
+**4. Créez un objet lorsque le nombre d'enregistrements associés est illimité.**
+Si quelque chose peut être relié à de nombreuses reprises sans en connaître le nombre, il est préférable d'en faire un objet propre. Par exemple, au lieu de créer des champs comme `Produit 1`, `Produit 2`, etc., définissez un objet `Produit` et reliez-le à l'enregistrement d'origine. De cette façon, vous pouvez supporter un, deux, ou cent produits sans changer votre modèle.
+
+**5. Gardez-le simple d'abord.**
+Commencez par des champs. Passez à de nouveaux objets seulement quand vous sentez les limites : trop de champs, des enregistrements répétés ou des relations qui ne s'adaptent pas aisément.
+
+### Note spéciale sur les personnes, les entreprises et les opportunités
+
+- **`Personnes`, `Entreprises` et `Opportunités` sont les seuls objets à partir desquels vous pouvez accéder aux e-mails et aux réunions synchronisés depuis votre boîte mail / calendrier.** Nous recommandons de les utiliser autant que possible. Si vous avez besoin de créer des catégories de `Personnes` ou `Entreprises`, utilisez des champs plutôt que de nouveaux objets.
+
+ Exemple : il est préférable d'utiliser l'objet `Personnes` pour à la fois les prospects et les partenaires, en ajoutant un champ appelé `Type de personne`. Évitez de créer un objet `Partenaire`, car vous ne pourriez pas accéder aux fils de discussion des e-mails depuis celui-ci. À la place, créez différentes vues sous `Personnes` : l'une montrant les partenaires, l'autre montrant les prospects.
+- Étant donné le point ci-dessus, il est normal d'avoir des champs qui ne s'appliquent pas à chaque enregistrement. Par exemple, sous `Personnes`, vous pourriez ajouter un champ `Lien de recommandation` qui n'est pertinent que lorsque `Type de personne = Partenaire`. Cela va : vous pouvez masquer ce champ dans les vues où il n'est pas nécessaire.
+
+### Questions pour guider votre choix
+
+Demandez-vous :
+
+- Est-ce juste une propriété de quelque chose que j'ai déjà, ou a-t-il besoin de ses propres propriétés ?
+- Aurais-je besoin de suivre plusieurs de ceux-ci par enregistrement, sans savoir combien d'avance ?
+- Ce concept se connecte-t-il à plusieurs objets différents, pas seulement un ?
+- Aura-t-il son propre cycle de vie (p. ex. étapes, dates de début/fin) ?
+
+Si la réponse est « oui » à l'un ou plusieurs de ceux-ci, il est probablement temps pour un nouvel objet.
+
+## Besoin d'aide ?
+
+Notre équipe peut vous aider à concevoir et créer le modèle de données dont vous avez besoin. Découvrez notre Pack d'Onboarding [ici](https://twenty.com/onboarding-packages).
+
+
diff --git a/packages/twenty-docs/fr/user-guide/data-model/fields.mdx b/packages/twenty-docs/fr/user-guide/data-model/fields.mdx
new file mode 100644
index 0000000000..119d9c9d62
--- /dev/null
+++ b/packages/twenty-docs/fr/user-guide/data-model/fields.mdx
@@ -0,0 +1,123 @@
+---
+title: Champs
+info: "Comprendre le rôle des champs et comment les manipuler."
+image: /images/user-guide/fields/field.png
+sectionInfo: Modèle de données flexible conçu pour soutenir vos processus métier uniques
+---
+
+
+
+
+
+## À propos des Champs
+
+Les champs sont comme les colonnes d'une feuille de calcul. Ils stockent différents types de données comme du texte, des chiffres ou des dates. Les champs peuvent être standard (intégrés) ou personnalisés (ceux que vous créez).
+
+### Champs Standards
+
+Les champs standard sont intégrés dans Twenty pour répondre aux besoins commerciaux courants.
+
+Par exemple, `Prénom` et `Nom de famille` sont des champs standards dans l'objet `Personnes`. Ils stockent des données textuelles pour les noms individuels.
+
+Vous ne pouvez pas supprimer les champs standard, mais vous pouvez les désactiver si vous n'en avez pas besoin.
+
+Vous pouvez également personnaliser les options des champs de type `SELECT` standard, par exemple les options pour le `Stade` sur les Opportunités.
+
+
+
+### Champs Personnalisés
+
+Les champs personnalisés peuvent être ajoutés à n'importe quel objet. Vous pouvez stocker du texte, des chiffres, des dates, des sélections déroulantes, et plus encore. Utilisez les champs personnalisés pour suivre des informations spécifiques à votre entreprise.
+
+Par exemple, un champ personnalisé pour SpaceX pourrait être `Statut Actif de la Fusée`, indiquant si une fusée est opérationnelle.
+
+
+
+## Créer un Champ Personnalisé
+
+Pour ajouter un champ personnalisé à un objet, suivez ces étapes :
+1. Allez dans les `Paramètres` dans la barre latérale gauche.
+2. Allez dans le `Modèle de Données`, puis sélectionnez l'objet que vous souhaitez personnaliser.
+3. Continuez en cliquant sur `Ajouter Champ`.
+4. Choisissez un nom de champ et un type qui répondent à vos exigences. Envisagez d'ajouter une description du champ pour une meilleure compréhension.
+
+Votre nouveau champ est maintenant disponible dans les champs de l'application. Pour l'afficher sur une vue spécifique, cliquez sur le menu des options, puis sélectionnez `Champs`.
+
+
+
+
+
+
+**Méthode rapide:** Cliquez sur le bouton **+** en haut à droite de tout tableau d'objet, puis sélectionnez `Personnaliser les champs`. Cela vous amène directement aux paramètres du Modèle de Données.
+
+
+
+## Désactiver un champ
+
+Vous pouvez désactiver un champ pour le masquer dans l'application sans perdre vos données. Considérez cela comme cacher le champ plutôt que de le supprimer.
+
+Voici comment vous pouvez le faire:
+
+1. Trouvez le champ que vous voulez désactiver dans vos paramètres d'objet.
+
+2. Cliquez sur les trois points `⋮` à côté du champ pour ouvrir le menu.
+
+3. Sélectionnez `Désactiver` dans le menu déroulant.
+
+
+
+Que se passe-t-il lorsque vous désactivez un champ?
+
+1. **Dans l'application :** Le champ disparaît et vous ne pouvez plus ajouter de nouvelles valeurs.
+
+2. **Relations existantes :** S'il s'agit d'un champ de relation, les connexions existantes restent mais vous ne pouvez pas en créer de nouvelles.
+
+3. **Accès API :** Vous pouvez toujours accéder au champ et à ses données par l'API.
+
+Vous pouvez réactiver les champs standards et personnalisés ou avoir l'option de les supprimer définitivement.
+
+## Rendre les Champs Uniques
+
+Rendez un champ unique pour garantir que des enregistrements distincts ne peuvent pas avoir la même valeur. Par exemple, les adresses e-mail sont uniques pour chaque personne.
+
+Si vous obtenez une erreur lors de la définition de l'unicité, vérifiez les valeurs en double dans vos données (y compris les enregistrements supprimés).
+
+## Bonnes pratiques de configuration des champs
+
+### Conventions de nommage et limitations
+
+- **Les noms de champs de relation ne peuvent être mis à jour** après leur création (impacte la structure API)
+- **Les noms aux singulier et pluriel doivent être distincts** : Notre API GraphQL a besoin de noms distincts pour les mutations
+- **Noms de champs protégés** : certains noms sont réservés à l'usage du système (par exemple, `Type`)
+
+### Champs de devise et de téléphone
+
+- **Devise par défaut** : peut être configurée via le modèle de données
+- **Codes pays par défaut** : peuvent être configurés pour les champs téléphoniques via le modèle de données
+
+### Champs de sélection
+
+- **Une option par défaut peut être sélectionnée** pour chaque champ de sélection
+
+### Champs Texte d'Enregistrement
+
+- **Chaque objet a un champ d'affichage principal**: Ce champ apparaît dans la colonne la plus à gauche et représente l'enregistrement lorsqu'il est lié à d'autres objets. Il doit s'agir d'un champ de texte. Par exemple, le champ `Nom` est utilisé pour les Personnes comme champ principal, donc lorsque vous liez une personne à une entreprise, vous verrez son nom dans la vue de l'entreprise.
+
+### Champs de Relation
+
+- **Connecter les objets ensemble** : Les champs de relation lient les enregistrements de différents objets. Pour des informations détaillées sur la création et la gestion des relations, consultez notre article [Champs de Relation](/user-guide/data-model/relation-fields).
+
diff --git a/packages/twenty-docs/fr/user-guide/data-model/objects.mdx b/packages/twenty-docs/fr/user-guide/data-model/objects.mdx
new file mode 100644
index 0000000000..d21bfd15f2
--- /dev/null
+++ b/packages/twenty-docs/fr/user-guide/data-model/objects.mdx
@@ -0,0 +1,92 @@
+---
+title: Objets
+info: "Apprenez-en davantage sur les objets standard et comment créer des objets personnalisés pour répondre aux besoins de votre entreprise."
+image: /images/user-guide/objects/objects_orange.png
+sectionInfo: Modèle de données flexible conçu pour soutenir vos processus métier uniques
+---
+
+
+ 
+
+
+## Objets Standard
+
+Les objets standard sont des entités prédéfinies dans votre espace de travail pour vous aider à commencer. Ils font partie d'un modèle de données partagé accessible à tous les utilisateurs de Twenty. Vous pouvez les utiliser tels quels, les personnaliser ou les désactiver.
+
+
+
+### Personnes
+
+L'objet `Personnes` stocke vos contacts. Il inclut les détails de contact et l'historique des interactions, afin que vous puissiez voir toutes vos interactions client en un seul endroit.
+
+### Entreprise
+
+L'objet `Entreprises` stocke vos comptes professionnels. Il inclut des détails tels que l'industrie, la taille et la localisation. Les entreprises se connectent aux objets `Personnes` et `Opportunités`.
+
+### Opportunités
+
+L'objet `Opportunités` stocke les données liées aux affaires. Il suit la progression des ventes potentielles, de la prospection à la clôture, en enregistrant les étapes, les tailles des affaires, le compte associé et la date prévue de clôture. Vous pouvez visualiser votre pipeline de ventes dans une mise en page kanban.
+
+## Objets personnalisés
+
+Les objets personnalisés vous permettent de stocker des informations uniques à votre organisation que les objets standards ne peuvent pas gérer. Par exemple, si vous êtes SpaceX, vous pouvez créer un objet personnalisé pour les Fusées et les Lancements.
+
+
+
+### Créer un nouvel objet personnalisé
+
+Pour créer un nouvel objet personnalisé :
+
+1. Accédez à Paramètres dans la barre latérale à gauche.
+2. Sous Espace de travail, allez au Modèle de données. Ici, vous pourrez voir un aperçu de tous vos objets Standard et Personnalisés (actifs et désactivés).
+
+
+
+
+
+
+3. Cliquez sur `+ Nouvel objet` en haut. Entrez le nom (à la fois singulier et pluriel), choisissez une icône, ajoutez une description pour votre objet personnalisé et cliquez sur Enregistrer (en haut à droite). En utilisant Listing comme exemple d'objet personnalisé, le singulier serait "listing" et le pluriel serait "listings" avec une description comme "Les annonces que les hôtes ont créées pour présenter leur propriété."
+
+
+
+
+
+
+4. Une fois que vous avez créé votre objet personnalisé, vous pourrez le gérer. Vous pouvez éditer le nom, l'icône et la description, consulter les différents champs et ajouter d'autres champs.
+
+
+
+**Note :** Si vous n'êtes pas sûr qu'un nouvel objet ou champ soit nécessaire, consultez [cet article](/user-guide/data-model/customize-your-data-model) pour obtenir des conseils sur la conception de votre modèle de données.
+
diff --git a/packages/twenty-docs/fr/user-guide/data-model/relation-fields.mdx b/packages/twenty-docs/fr/user-guide/data-model/relation-fields.mdx
new file mode 100644
index 0000000000..2a85644e8e
--- /dev/null
+++ b/packages/twenty-docs/fr/user-guide/data-model/relation-fields.mdx
@@ -0,0 +1,62 @@
+---
+title: Champs de relation
+info: Découvrez comment créer des relations entre des objets en utilisant des champs de relation et configurer des relations de un-à-plusieurs.
+image: /images/user-guide/fields/relations_field.png
+sectionInfo: Modèle de données flexible conçu pour soutenir vos processus métier uniques
+---
+
+
+ 
+
+
+## Qu'est-ce que les champs de relation ?
+
+Les champs de relation lient les enregistrements d'un objet aux enregistrements d'un autre objet. Par exemple :
+
+- **Personnes** → **Entreprises** (chaque personne travaille pour une entreprise)
+- **Opportunités** → **Personnes** (chaque affaire a une personne de contact)
+- **Tâches** → **Opportunités** (chaque tâche se rapporte à une affaire spécifique)
+
+## Créer des champs de relation
+
+### 1. Ajouter le champ
+
+Allez à **Paramètres → Modèle de données → [Votre objet]** et cliquez sur **Ajouter un champ**.
+
+### 2. Choisir le type de relation
+
+- **Type de champ** : Sélectionnez "Relation"
+- **Objet cible** : Choisissez l'objet à connecter
+- **Relation** : Actuellement, seuls les relations **un-à-plusieurs** sont prises en charge. Assurez-vous de créer la relation dans la bonne direction.
+
+### 3. Configurer les noms de champ
+
+Vous devrez définir des noms pour les deux côtés de la relation :
+
+- **Nom du champ source** : Comment le champ apparaît sur votre objet actuel
+- **Nom du champ cible** : Comment le champ inverse apparaît sur l'objet cible
+
+
+
+
+Chaque entreprise fonctionne différemment. C'est pourquoi Twenty vous permet de modeler le CRM selon vos besoins, sans vous imposer nos processus.
+**Commencez avec ces trois étapes pour le configurer comme vous le souhaitez.**
+
+**Succès rapide** : Commencez par connecter votre boîte mail et personnaliser votre modèle de données avec quelques champs clés. Cela vous procure une valeur immédiate et aide votre équipe à voir Twenty en action avec de vraies données. Vous pouvez le faire sous Paramètres → Comptes.
+
+## 1. Personnalisez votre modèle de données
+
+Twenty offre la flexibilité dont vous avez besoin pour façonner le modèle de données qui soutiendra au mieux votre quotidien.
+Créez des objets et champs de tout type, y compris les relations entre vos différents objets. Vous pouvez le faire sous Paramètres → Modèle de données.
+Voici quelques conseils :
+
+- **Vous n'êtes pas limité dans le nombre de champs ou d'objets personnalisés**. Ajouter des objets et champs personnalisés n'entraînera pas de mise à jour de votre plan.
+- **Personnes, Entreprises et Opportunités sont les trois objets à partir desquels vous pouvez accéder aux emails et réunions synchronisés depuis votre boite aux lettres/calendrier**. Nous recommandons d'utiliser ces éléments autant que possible, en ajoutant des champs pour catégoriser vos enregistrements si besoin. Voici un exemple :
+ - Il vaut mieux utiliser l'objet Personnes pour vos prospects et partenaires, en créant un champ sur l'objet Personnes nommé `Type de personne`, plutôt que de créer un objet personnalisé Partenaire. Parce que vous ne pourriez pas accéder aux emails échangés avec cette personne à partir des enregistrements Partenaire.
+ - Créez différentes vues sous Personnes, une pour afficher les partenaires et une pour afficher les prospects.
+- Deux personnes ne peuvent pas avoir la même adresse email. Deux entreprises ne peuvent pas avoir le même domaine.
+- Vous pouvez désactiver les champs et objets standards que vous ne souhaitez pas utiliser.
+- Vous pouvez masquer les champs des vues : n'ayez pas peur de créer des champs, vous n'aurez pas à tous les afficher.
+
+Lisez [cet article](https://docs.twenty.com/user-guide/data-model/customize-your-data-model) pour apprendre à concevoir votre modèle de données.
+
+## 2. Importez vos données
+
+Importer vos données existantes dans Twenty donne à votre équipe le contexte dès le départ.
+
+### Connectez votre boite aux lettres
+
+Si vous ne l'avez pas fait lors de la création de votre espace de travail, connectez votre **compte Google ou Microsoft** sous Paramètres → Comptes. Cela permet à Twenty de :
+
+- Importer vos messages et réunions
+- Créer automatiquement des contacts basés sur les interactions (optionnel)
+- Garder l'historique de communication visible pour votre équipe
+
+**Utilisez un autre fournisseur ?**
+Vous pouvez ajouter une autre boite aux lettres via SMTP ou un autre calendrier via CalDAV. Vous devrez activer la fonctionnalité sous Paramètres → Versions → Lab, puis revenir à l'onglet Paramètres → Comptes.
+
+### Importez des données via csv
+
+Utilisez le menu Commande (`Cmd + K` ou `Ctrl + K`) pour importer des Personnes, Entreprises, Opportunités ou tout autre objet personnalisé via CSV.
+
+**Lignes directrices principales** :
+
+- Téléchargez le fichier exemple pour comprendre le format attendu
+- Limitez chaque fichier à 10k enregistrements
+- Supprimez les emails en double pour les Personnes ou les domaines en double pour les Entreprises
+- Examinez et corrigez les erreurs (surlignées en jaune) avant de les importer
+
+Lisez [cet article](/user-guide/getting-started/import-export-data) pour en savoir plus sur l'importation de données.
+
+## 3. Créez votre première vue
+
+Créer différentes vues est essentiel pour rendre les données exploitables pour votre équipe.
+Voici comment procéder :
+
+- **Ajouter ou masquer les colonnes**
+ Gérer les champs visibles dans une vue donnée en cliquant sur Options → Champs (en haut à droite). Vous pouvez afficher/masquer des champs à partir de là.
+
+- **Réorganiser les champs**
+ Réorganisez les champs d'une vue donnée en cliquant sur Options → Champs (en haut à droite). Glisser-déposer les champs pour les réorganiser.
+
+- **Filtrer votre vue**
+ Réduisez le nombre d'enregistrements affichés en utilisant les Filtres en haut à droite.
+
+- **Trier les enregistrements**
+ Réorganisez les enregistrements affichés en utilisant la fonction de tri en haut à droite, ou en cliquant directement sur le nom de la colonne.
+
+- **Choisissez la disposition**
+ Vous pouvez passer à une disposition **Kanban** ou à une liste **Grouper Par**, tant que l'objet a un champ de type 'Étape' ou similaire.
+
+- **Enregistrez votre vue comme Favoris**
+ Cela peut être fait en utilisant le menu déroulant affichant les différentes vues.
+
+## Et après ?
+
+Commencez à créer des automatisations en utilisant [les flux de travail](https://docs.twenty.com/user-guide/workflows/getting-started-workflows).
diff --git a/packages/twenty-docs/fr/user-guide/getting-started/create-workspace.mdx b/packages/twenty-docs/fr/user-guide/getting-started/create-workspace.mdx
new file mode 100644
index 0000000000..0e06e765cc
--- /dev/null
+++ b/packages/twenty-docs/fr/user-guide/getting-started/create-workspace.mdx
@@ -0,0 +1,69 @@
+---
+title: Créer un espace de travail
+info: "Suivez un guide pas-à-pas sur comment s'inscrire sur Twenty, choisir un plan d'abonnement, confirmer votre paiement et configurer votre compte, avec des conseils supplémentaires pour obtenir de l'aide si nécessaire."
+image: /images/user-guide/create-workspace/workspace-cover.png
+sectionInfo: Découvrez Twenty, un CRM open-source.
+---
+
+
+
+
+
+## Étape 1 : Inscription
+
+1. Allez sur [Inscription à Twenty](https://app.twenty.com).
+2. Sélectionnez votre méthode d'inscription préférée :
+ - **Continuer avec Google** pour s'inscrire avec un compte Google.
+ - **Continuer avec Microsoft** pour s'inscrire avec un compte Microsoft.
+ - Ou, **Continuer avec l'email** pour l'inscription par courriel.
+
+
+
+
+
+## Étape 2 : Choisir une période d'essai
+
+Choisissez entre deux périodes d'essai :
+
+### 30 jours
+
+Avec carte de crédit
+
+### 7 jours
+
+Sans carte de crédit
+
+Les deux essais incluent :
+
+- Accès complet
+- Contacts illimités
+- Intégration du courriel
+- Objets personnalisés
+- API & Webhooks
+
+Vous pouvez cliquer sur "Changer de plan" pour choisir un autre plan ou intervalle de facturation.
+
+
+
+## Étape 3 : Confirmation du paiement & configuration du compte
+
+Après approbation du paiement via Stripe, vous êtes dirigé pour créer votre espace de travail et votre profil utilisateur. Souvenez-vous que vous pouvez annuler votre abonnement à tout moment.
+
+## Support
+
+Pour toute question ou aide, contactez l'équipe de support dédiée à [contact@twenty.com](mailto:contact@twenty.com) ou envoyez un message sur [Discord](https://discord.gg/cx5n4Jzs57)
+
diff --git a/packages/twenty-docs/fr/user-guide/getting-started/getting-around-twenty.mdx b/packages/twenty-docs/fr/user-guide/getting-started/getting-around-twenty.mdx
new file mode 100644
index 0000000000..0565007abb
--- /dev/null
+++ b/packages/twenty-docs/fr/user-guide/getting-started/getting-around-twenty.mdx
@@ -0,0 +1,79 @@
+---
+title: Se déplacer dans Twenty
+info: "Obtenez un aperçu rapide de la façon de naviguer sur la plate-forme et où effectuer différents types d'actions."
+image: /images/user-guide/what-is-twenty/getting_around.png
+sectionInfo: Découvrez Twenty, un CRM open-source.
+---
+
+
+ 
+
+
+Lorsque vous vous connectez à Twenty pour la première fois, la mise en page devrait être intuitive. Elle est conçue pour vous aider à naviguer rapidement et rester organisé, sans vous gêner.
+
+## La mise en page principale
+
+Le centre de l'écran est **là où vos enregistrements vivent** : personnes, entreprises, opportunités, tâches, notes, flux de travail et tout autre objet que vous avez créé. C'est là que se fait le travail quotidien.
+Vous pouvez **voir, modifier, supprimer des enregistrements** à partir de là ainsi que **créer de nouvelles vues**.
+
+## La barre de navigation
+
+À gauche, de haut en bas, vous pourrez :
+
+- Basculer entre vos **plusieurs espaces de travail** à l'aide du menu déroulant ou créer un nouvel espace de travail
+- Choisissez entre les modes clair et sombre
+- Utilisez la **barre de recherche** (appuyez sur `/` pour y accéder instantanément)
+- Ouvrir la section **Paramètres**
+
+
+
+
+## Services d'implémentation
+
+Que vous ayez besoin d'aide pour commencer ou pour créer des personnalisations avancées, nous avons une solution.
+
+### Packs d'intégration
+
+Obtenez de l'aide de notre équipe principale pour configurer votre espace de travail Twenty avec nos [packs d'intégration](https://twenty.com/onboarding-packages) de 4 heures :
+
+- **Conception du Modèle de Données** : Concevez et créez votre modèle de données personnalisé avec des objets, des champs et des relations.
+- **Migration de Données** : Migrez vos données existantes de votre CRM actuel vers Twenty.
+- **Création de Flux de Travail** : Créez des flux de travail personnalisés pour soutenir vos processus commerciaux.
+
+### Partenaires pour l'Implémentation
+
+Collaborez avec des partenaires certifiés Twenty pour des personnalisations et intégrations plus avancées. Contactez notre équipe via contact@twenty.com pour être mis en relation avec nos [partenaires](https://twenty.com/implementation-services).
+
+
diff --git a/packages/twenty-docs/fr/user-guide/getting-started/import-export-data.mdx b/packages/twenty-docs/fr/user-guide/getting-started/import-export-data.mdx
new file mode 100644
index 0000000000..c8b9809f8a
--- /dev/null
+++ b/packages/twenty-docs/fr/user-guide/getting-started/import-export-data.mdx
@@ -0,0 +1,117 @@
+---
+title: Importer/Exporter des Données
+info: "Apprenez à importer et exporter des données."
+image: /images/user-guide/import-export-data/cloud.png
+sectionInfo: Découvrez Twenty, un CRM open-source.
+---
+
+
+ 
+
+
+## Importer des Données
+
+- Vous pouvez importer des données pour n'importe quel objet en utilisant un fichier .csv, .xlsx, ou .xls.
+- Chacun des fichiers que vous chargez doit contenir **seulement un type d'objet** (par exemple, uniquement des enregistrements Personnels).
+- Vous pouvez utiliser l'importation pour **créer ou mettre à jour des enregistrements**.
+
+### Téléchargez le fichier exemple pour comprendre le format attendu
+
+1. Allez dans une vue avec l'objet que vous êtes sur le point d'importer.
+2. Cliquez sur l'icône `⋮` en haut à droite puis sélectionnez `Importer les enregistrements`.
+3. Cliquez sur `Télécharger le fichier d'exemple`.
+
+### Préparez votre fichier csv
+
+Voici quelques éléments à vérifier avant de charger votre fichier.
+
+- Limitez le nombre d'enregistrements à **10,000 par fichier**.
+- **Supprimez les doublons** de votre fichier.
+ - L'unicité sur `Personnes` est définie par défaut par l'`id` et l'`email`. Vous avez également la possibilité de définir des champs personnalisés à partir de `Personnes` comme uniques lors de la configuration de votre modèle de données.
+ - L'unicité sur `Entreprises` est définie par défaut par l'`id` et le `domaine`. Vous avez également la possibilité de définir des champs personnalisés à partir de `Entreprises` comme uniques lors de la configuration de votre modèle de données.
+ - Pour tout autre objet, y compris les objets personnalisés, vous avez la possibilité de définir certains champs comme uniques. Assurez-vous de ne pas inclure de doublons lors de la préparation de vos fichiers.
+- Nous recommandons d'utiliser la syntaxe `https://domain.com` lors du chargement de vos domaines, car c'est celle utilisée par notre connecteur avec votre boîte aux lettres et votre calendrier.
+- Vous pouvez **importer les relations entre les objets** en fournissant l'un des champs uniques de l'enregistrement associé.
+ - Exemple : Vous souhaitez attacher une personne à une entreprise. Ajoutez une colonne dans le fichier contenant tous les enregistrements `Personnes` qui contient l'`id` de l'entreprise — ou son `domaine`. Vous pourrez mapper ce champ lors du téléversement.
+
+
+### FAQ Importation
+
+Je vois des problèmes de doublons lors du téléversement de mon fichier, que dois-je faire?
+ +Veuillez vous référer à la section **Préparer votre csv** ci-dessus dans cet article, elle contient des instructions sur ce qui sera considéré comme un doublon. + +Puis-je importer des relations entre objets?
+ +Oui, veuillez vous référer à la section **Préparer votre csv** ci-dessus dans cet article, elle contient une section sur l'importation des relations. + +Puis-je mettre à jour des enregistrements existants en utilisant la fonction d'importation?
+ +Oui, vous pouvez mettre à jour des enregistrements existants en utilisant la fonction d'importation. Assurez-vous de fournir l'id (ou tout autre champ unique) lors du re-téléversement de vos enregistrements. + +Puis-je migrer l'`id` de mon (mes) autre(s) outil(s)?
+ +Oui. Vous devez créer un champ que vous définissez comme unique dans votre modèle de données qui contiendra l'`id` de votre (vos) autre(s) outil(s). Veuillez noter que le nom `id` est protégé car il est utilisé pour l'ID Twenty. +Si vous souhaitez créer des relations entre objets à l'aide de ce champ, consultez la section **Préparer votre csv** ci-dessus dans cet article. Elle contient une section sur l'importation des relations. + +
+
+
+
+
diff --git a/packages/twenty-docs/fr/user-guide/getting-started/migrating-from-other-crms.mdx b/packages/twenty-docs/fr/user-guide/getting-started/migrating-from-other-crms.mdx
new file mode 100644
index 0000000000..bed481bb6e
--- /dev/null
+++ b/packages/twenty-docs/fr/user-guide/getting-started/migrating-from-other-crms.mdx
@@ -0,0 +1,90 @@
+---
+title: Migration depuis d'autres CRM
+info: Guide étape par étape pour migrer les données et processus depuis d'autres systèmes CRM vers Twenty.
+image: /images/user-guide/what-is-twenty/migrating_crm.png
+sectionInfo: Un guide rapide pour comprendre les bases de Twenty
+---
+
+
+ 
+
+
+## Avant de démarrer
+
+### 1. Auditez vos données actuelles
+
+- **Sélectionnez quelques objets et champs à migrer** : cette migration est l'opportunité d'un nouveau départ.
+- **Exportez ces données** de votre CRM actuel
+- **Supprimez les doublons** et les enregistrements obsolètes
+- **Liste active des workflows** et automatisations
+
+### 2. Créez votre nouveau modèle de données
+
+Suivez notre [guide du modèle de données](/user-guide/data-model/customize-your-data-model) pour :
+
+- **Concevez le modèle de données** dont vous avez besoin
+- **Attribuez les champs existants** aux objets/champs standards de Twenty
+- **Identifiez les objets/champs personnalisés** dont vous aurez besoin
+- **Créez-les** sous Paramètres → Modèle de données
+
+## Processus de migration
+
+### 1. Importez vos données
+
+**Ordre recommandé :**
+
+1. **Entreprises** en premier (comme enregistrements de base)
+2. **Personnes** en second (liées aux entreprises)
+3. **Opportunités** en troisième (liées aux personnes/entreprises)
+
+Utilisez l'importation CSV via le menu Commande `Cmd + K` (Mac) ou `Ctrl + K` (Windows). Consultez notre [guide d'importation de données](/user-guide/getting-started/import-export-data) pour des instructions détaillées.
+
+### 2. Recréez les workflows
+
+- **Commencez simplement** - recréez d'abord vos automatisations les plus critiques
+- **Utilisez le créateur de workflow de Twenty** pour remplacer les automatisations existantes
+
+## Défis communs
+
+### Problèmes de formattage des données
+
+- **Adresses email** - supprimez les doublons (exigence de l'objet Personnes)
+- **Domaine** - supprimez les doublons (exigence de l'objet Entreprises)
+
+
+
+Twenty est le CRM open-source leader, conçu par des centaines de contributeurs pour répondre à vos besoins commerciaux uniques.
+
+## Vision
+
+Créer un bon CRM est difficile car c'est un numéro d'équilibriste.
+Pour chaque entreprise, les exigences semblent simples, mais les besoins de chacun sont distincts.
+Le résultat est un CRM soit trop basique, soit tentant de faire tout et finissant maître de rien.
+
+Au départ, Twenty ressemble à la plupart des CRM que vous connaissez déjà : vous pouvez suivre les offres, organiser les contacts, gérer les tâches et les notes.
+Mais ce qui le distingue est notre approche de l'extensibilité. Nous construisons une plate-forme ouverte qui fournit les éléments de base pour que vous puissiez résoudre vos problèmes commerciaux uniques.
+
+Nous privilégions les principes universels et les modèles communs plutôt que les listes de fonctionnalités.
+Nous ne prétendons pas avoir toutes les réponses et nous préférons donner aux utilisateurs les moyens de trouver ce qui fonctionne le mieux pour eux.
+L'open-source est la pierre angulaire de notre approche, garantissant que Twenty évolue avec sa communauté, pour sa communauté.
+
+## Avantages
+
+**Personnalisable :** Conçu pour répondre à vos besoins commerciaux.
+
+**Piloté par la communauté :** Conçu et maintenu par une large communauté open source.
+
+**Rentable :** Vous ne serez jamais bloqué avec un fournisseur, car vous pouvez toujours auto-héberger.
+
+## Fonctionnalités principales
+
+**Gestion des contacts :** Stockez et gérez efficacement les données clients. [En savoir plus](/user-guide/crm-essentials/contact-and-account-management).
+
+**Objets personnalisés :** Créez et personnalisez des objets pour répondre aux besoins de votre entreprise. [Détails](/user-guide/data-model/objects).
+
+**Champs personnalisés :** Personnalisez les champs de données pour capturer et organiser des informations spécifiques à vos opérations. [Comprendre plus](/user-guide/data-model/fields).
+
+**Gestion des offres :** Suivez et gérez vos opportunités de vente à travers des [étapes de pipeline](/user-guide/crm-essentials/pipeline) personnalisables.
+
+**Vues Kanban & Table :** Rendez les données exploitables avec [vues de tableau flexibles](/user-guide/crm-essentials/view-management).
+
+**Flux de travail :** Automatisez vos processus métier et intégrez des outils externes grâce à une puissante automatisation des flux de travail. [Commencez](/user-guide/workflows/getting-started-workflows).
+
+**Intégration d'emails :** Consultez les emails d'un client ou d'une entreprise spécifique au sein de votre espace de travail. [Synchronisez votre boîte mail](/user-guide/collaboration/emails-and-calendars).
+
+**Notes :** Créez des notes détaillées pour chaque enregistrement afin de partager plus efficacement les connaissances. [Ajoutez des notes](/user-guide/collaboration/notes).
+
+**Tâches :** Planifiez des tâches pour suivre les interactions clients. [Découvrez comment](/user-guide/collaboration/tasks).
+
+**Autorisations :** Contrôlez l'accès et gérez les rôles des utilisateurs avec des autorisations flexibles au niveau de l'espace de travail et des objets. [Configurez les autorisations](/user-guide/settings/permissions).
+
+**API & Webhooks :** Connectez-vous à d'autres applications et automatisez les flux de travail avec l'API et les Webhooks. [Commencez l'intégration](/user-guide/integrations-api/api-webhooks).
+
+## Rejoignez maintenant
+
+[Inscrivez-vous ici](https://app.twenty.com) ou [devenez contributeur sur GitHub](https://github.com/twentyhq/twenty).
+
diff --git a/packages/twenty-docs/fr/user-guide/integrations-api/apis-overview.mdx b/packages/twenty-docs/fr/user-guide/integrations-api/apis-overview.mdx
new file mode 100644
index 0000000000..13fd0fa1f4
--- /dev/null
+++ b/packages/twenty-docs/fr/user-guide/integrations-api/apis-overview.mdx
@@ -0,0 +1,130 @@
+---
+title: Aperçu des API
+info: Comprenez les quatre différentes API et quand utiliser chacune d'elles.
+image: /images/user-guide/api/api-overview.png
+sectionInfo: Découvrez comment connecter Twenty à vos autres outils.
+---
+
+
+ 
+
+
+Twenty a été conçu pour être convivial pour les développeurs, offrant des API puissantes qui s'adaptent à votre modèle de données personnalisé. Nous fournissons quatre types d'API distincts pour répondre à différents besoins d'intégration.
+
+## Approche axée sur les développeurs
+
+Twenty génère des API spécifiquement pour votre modèle de données, ce qui signifie :
+
+- **Pas besoin d'ID longs** : Utilisez directement les noms de vos objets et champs dans les points de terminaison
+- **Objets standard et personnalisés traités à égalité** : Vos objets personnalisés bénéficient du même traitement API que ceux intégrés
+- **Points de terminaison dédiés** : Chaque objet et champ a son propre point de terminaison API
+- **Documentation personnalisée** : Générée spécifiquement pour le modèle de données de votre espace de travail
+
+
+
+
+## Options d'intégration actuelles
+
+### Intégrations natives
+
+Twenty offre actuellement une intégration native avec :
+
+- **Email & Calendrier** : Connectez Gmail, Outlook, ou des fournisseurs SMTP/CalDAV
+- **Accès API** : Utilisez nos API REST et GraphQL pour créer des intégrations personnalisées
+
+Pour la configuration des e-mails et du calendrier, visitez [Configuration des e-mails & Calendrier](/user-guide/settings/email-calendar-setup).
+
+### Flux de travail (Recommandé)
+
+La principale façon de connecter Twenty à d'autres outils est via notre fonctionnalité **Flux de travail** intégrée :
+
+- **Nœuds HTTP** : Effectuez des appels API vers des services externes
+- **Nœuds de code** : Écrivez une logique personnalisée pour des intégrations complexes
+- **Déclencheurs Webhook** : Recevez des données de systèmes externes
+- **Déclencheurs de mise à jour de champ** : Automatisez les actions basées sur les modifications du CRM
+
+En savoir plus dans notre [section Flux de travail](/user-guide/workflows/getting-started-workflows).
+
+### Intégration Zapier (Héritage)
+
+Nous maintenons une intégration Zapier pour les utilisateurs qui préfèrent les automatisations sans code :
+
+1. Visitez [Twenty sur Zapier](https://zapier.com/apps/twenty/integrations)
+2. Créez un nouveau Zap avec Twenty comme déclencheur ou action
+3. Générez une clé API dans Paramètres → API & Webhooks
+4. Connectez votre espace de travail Twenty à Zapier
+
+## Vision future : Connecteurs construits par la communauté (2026)
+
+### Plateforme d'extensibilité
+
+Nous développons une plateforme d'extensibilité qui permettra aux développeurs de créer des applications comme du code. Cela permettra :
+
+- **Connecteurs personnalisés** : Créez des intégrations avec vos logiciels préférés
+- **Contributions communautaires** : Partagez et découvrez les connecteurs créés par d'autres
+- **Architecture flexible** : Étendez les capacités de Twenty au-delà des fonctionnalités de base
+
+### Création de flux de travail assistée par IA
+
+À venir en 2026, l'assistance IA aidera les utilisateurs à :
+
+- **Auto-générer des flux de travail** : Décrivez vos besoins d'intégration en langage clair
+- **Suggestions intelligentes** : Recevez des recommandations pour connecter vos outils spécifiques
+- **Bibliothèque de modèles** : Accédez à des flux de travail préconstruits pour des cas d'utilisation courants
+
+L'avenir des intégrations Twenty est axé sur la communauté, assisté par l'IA, et infiniment extensible.
+
diff --git a/packages/twenty-docs/fr/user-guide/introduction.mdx b/packages/twenty-docs/fr/user-guide/introduction.mdx
new file mode 100644
index 0000000000..e3d6c18ced
--- /dev/null
+++ b/packages/twenty-docs/fr/user-guide/introduction.mdx
@@ -0,0 +1,46 @@
+---
+title: Vue d'ensemble
+description: Votre guide complet des fonctionnalités de Twenty CRM et des meilleures pratiques.
+---
+
+
+
+
+## Tarifs
+
+
+
+
+## Quoi de neuf
+
+### Rapports personnalisés
+
+Créez des rapports sur mesure pour suivre les indicateurs qui comptent le plus pour votre entreprise.
+
+### Tableaux de bord de vente
+
+Visualisez les performances de votre pipeline de vente avec des tableaux de bord interactifs.
+
+### Analyse des performances
+
+Surveillez la performance de l'équipe et identifiez les tendances dans vos données clients.
+
+## Restez informé
+
+Suivez notre [répertoire GitHub](https://github.com/twentyhq/twenty) ou consultez la section **Paramètres → Versions** dans votre espace de travail pour être averti lorsque les fonctionnalités de reporting deviennent disponibles.
+
diff --git a/packages/twenty-docs/fr/user-guide/resources/github.mdx b/packages/twenty-docs/fr/user-guide/resources/github.mdx
new file mode 100644
index 0000000000..f08eab89a3
--- /dev/null
+++ b/packages/twenty-docs/fr/user-guide/resources/github.mdx
@@ -0,0 +1,58 @@
+---
+title: GitHub
+info: "Découvrez le dépôt GitHub de Twenty et la variété de ressources qu'il héberge, y compris le code source, la documentation et les discussions."
+image: /images/user-guide/github/github-header.png
+sectionInfo: Ressources de terminologie et informations communautaires
+---
+
+
+ 
+
+
+## À propos
+
+Le dépôt GitHub de Twenty héberge une vaste gamme de ressources telles que le code source, la documentation, les discussions et le suivi des problèmes. C'est ici que vous pourrez accéder à l'intégralité du code derrière Twenty.
+
+[Visitez Twenty sur GitHub](https://github.com/twentyhq/twenty)
+
+## Contribution
+
+Contribuer au projet Twenty sur GitHub est un moyen gratifiant d'aider à améliorer le logiciel que vous utilisez. Que vous corrigiez des bogues, suggériez des fonctionnalités ou amélioriez la documentation, vos contributions sont les bienvenues.
+
+### Signaler des problèmes
+
+Rencontrez-vous un problème ? [Créez un problème](https://github.com/twentyhq/twenty/issues/new) sur GitHub, en fournissant autant de détails que possible.
+
+
+
+### Suggérer des Fonctionnalités
+
+Quelles améliorations aimeriez-vous voir sur Twenty ? Peu importe votre savoir-faire technique, vous pouvez rejoindre [la conversation ici](https://github.com/twentyhq/twenty/discussions).
+
+
+
+### Coder une fonctionnalité
+
+Commencez votre parcours en trouvant des tâches pour débutants :
+
+1. Naviguez jusqu'à l'onglet **[Issues](https://github.com/twentyhq/twenty/issues)** sur le dépôt de Twenty.
+2. Filtrez par l'étiquette **[Good First Issue](https://github.com/twentyhq/twenty/labels/good%20first%20issue)** pour trouver des tâches adaptées aux nouveaux.
+3. Choisissez un problème, clonez le dépôt et commencez à contribuer.
+
+
+
+Assurez-vous d'être assigné au problème pour éviter de chevaucher le travail avec d'autres contributeurs.
+
+### Code de Conduite
+
+N'oubliez pas de respecter le [Code de conduite](https://github.com/twentyhq/twenty/blob/main/.github/CODE_OF_CONDUCT.md) de Twenty pendant tout votre processus de contribution.
+
+## Discord
+
+Si vous avez des questions, par exemple sur la façon de contribuer, rejoignez la communauté sur [Discord](https://discord.gg/cx5n4Jzs57)
+
+
+
++
+Merci de contribuer à Twenty ❤️ diff --git a/packages/twenty-docs/fr/user-guide/resources/glossary.mdx b/packages/twenty-docs/fr/user-guide/resources/glossary.mdx new file mode 100644 index 0000000000..9ac07351b7 --- /dev/null +++ b/packages/twenty-docs/fr/user-guide/resources/glossary.mdx @@ -0,0 +1,95 @@ +--- +title: Glossaire +info: "Familiarisez-vous avec la terminologie essentielle utilisée dans Twenty." +image: /images/user-guide/glossary/glossary.png +sectionInfo: Ressources de terminologie et informations communautaires +--- + + +
+
+
+## API
+
+L'API (Interface de Programmation d'Applications) permet de connecter Twenty avec d'autres systèmes logiciels et de créer des intégrations personnalisées.
+
+## Menu Commande
+
+Le Menu Commande est une interface d'accès rapide (ouverte avec `Cmd + K` sur Mac et `Ctrl + K` sur Windows) qui vous permet d'effectuer des actions, de créer des enregistrements et de naviguer efficacement dans votre espace de travail.
+
+## Entreprise & Personnel
+
+Le CRM a deux types fondamentaux d'enregistrements :
+
+- Une `Entreprise` représente une entreprise ou une organisation.
+- `Personnel` représente les clients ou prospects actuels ou potentiels de votre entreprise.
+
+## Champs Personnalisés
+
+Les Champs Personnalisés sont des champs de données que vous créez pour capturer des informations spécifiques aux besoins et processus de votre entreprise.
+
+## Modèle de données
+
+Un Modèle de Données est la structure qui définit comment les informations sont organisées dans votre CRM, y compris quels objets existent, leurs propriétés (champs) et comment ils sont liés les uns aux autres.
+
+## Favoris
+
+Les Favoris sont des enregistrements que vous avez marqués pour un accès rapide, apparaissant dans votre barre latérale pour une navigation instantanée vers des données importantes.
+
+## Champ
+
+Un champ se réfère à une zone spécifique où des données particulières sont stockées pour une entité.
+
+## Intégration
+
+Les Intégrations sont des outils intégrés qui permettent de lier Twenty avec d'autres logiciels ou systèmes.
+
+## Kanban
+
+Un `Kanban` est une manière visuelle de suivre vos processus commerciaux en utilisant des cartes et des colonnes. Chaque colonne représente une étape dans votre processus (par exemple : nouveau, en cours, gagné, perdu), et vous déplacez les enregistrements à travers ces étapes au fur et à mesure de leur progression.
+
+## Objet
+
+Un Objet est une structure de données qui représente un type spécifique d'entité dans votre CRM (comme Personnel, Entreprises ou Opportunités). Les Objets peuvent être standards (intégrés) ou personnalisés (créés par vous).
+
+## Opportunités
+
+Les opportunités dans Twenty CRM sont des affaires potentielles ou des ventes avec des comptes ou des contacts.
+
+## Enregistrer
+
+Un enregistrement indique une instance d'un objet, comme un compte ou un contact spécifique.
+
+## Champs de Relation
+
+Les Champs de Relation créent des connexions entre différents objets, vous permettant de lier des enregistrements ensemble (comme relier une Personne à une Entreprise).
+
+## Champs Standards
+
+Les Champs Standards sont des champs de données prédéfinis qui viennent avec des objets par défaut et fournissent une fonctionnalité commune à tous les espaces de travail.
+
+## Tâches
+
+Les Tâches dans le CRM Twenty sont des activités assignées concernant des contacts, des comptes ou des opportunités.
+
+## Vues
+
+Vous pouvez personnaliser l'affichage de vos enregistrements en utilisant des vues, en définissant différents filtres, mises en page et options de tri pour chaque vue.
+
+## Webhooks
+
+Les Webhooks sont des messages automatisés envoyés de Twenty à d'autres applications lorsque des événements spécifiques se produisent, permettant une synchronisation des données en temps réel.
+
+## Workflows
+
+Les workflows sont des processus automatisés qui déclenchent des actions basées sur des conditions spécifiques, vous aidant à automatiser les tâches répétitives et les processus métier.
+
+## Espace de travail
+
+Un `Espace de Travail` représente généralement une entreprise utilisant Twenty. Il contient tous les enregistrements et données que vous et les membres de votre équipe ajoutez à Twenty.
+Il a un nom de domaine unique, qui est généralement le nom de domaine que votre entreprise utilise pour les adresses e-mail des employés.
+
+## Membres de l'espace de travail
+
+Les Membres de l'Espace de Travail sont les utilisateurs de Twenty de votre équipe qui ont accès à votre espace de travail. Ils peuvent être désignés comme propriétaires ou assignés pour les enregistrements.
+
diff --git a/packages/twenty-docs/fr/user-guide/settings/domains-settings.mdx b/packages/twenty-docs/fr/user-guide/settings/domains-settings.mdx
new file mode 100644
index 0000000000..3fc8601360
--- /dev/null
+++ b/packages/twenty-docs/fr/user-guide/settings/domains-settings.mdx
@@ -0,0 +1,42 @@
+---
+title: Paramètres des domaines
+info: "Configurer les domaines de l'espace de travail et les paramètres d'accès approuvé pour l'inscription automatique des utilisateurs."
+image: /images/user-guide/setup/domains-settings.png
+sectionInfo: Configurez les paramètres et préférences de votre espace de travail Twenty.
+---
+
+
+ 
+
+
+## Domaine personnalisé de l'espace de travail
+
+Définissez une adresse Web personnalisée pour votre espace de travail :
+
+- Choisissez votre sous-domaine préféré (par exemple, votreentreprise.twenty.com)
+- Configurez des domaines personnalisés pour une image de marque professionnelle
+
+## Domaines d'accès approuvés
+
+Autoriser l'accès automatique à l'espace de travail pour des domaines de messagerie spécifiques.
+
+### Comment ça marche
+
+- Ajoutez les domaines de messagerie de votre entreprise (par exemple, @votreentreprise.com)
+- Toute personne avec un e-mail provenant de ces domaines peut rejoindre automatiquement votre espace de travail
+- Aucune invitation manuelle nécessaire pour les membres de l'équipe
+
+### Avantages
+
+- **Intégration plus rapide** : les nouveaux membres de l'équipe rejoignent automatiquement
+- **Meilleure sécurité** : seuls les e-mails vérifiés de l'entreprise peuvent accéder
+- **Moins de travail administratif** : pas besoin d'inviter chaque membre de l'équipe manuellement
+
+## Instructions d'installation
+
+1. Allez dans **Paramètres → Domaines**
+2. Ajoutez votre domaine personnalisé ou des domaines de messagerie approuvés
+3. Vérifiez la propriété du domaine si nécessaire
+
+**Note** : les modifications de domaine peuvent prendre du temps pour être effectives et pourraient nécessiter une vérification.
+
diff --git a/packages/twenty-docs/fr/user-guide/settings/email-calendar-setup.mdx b/packages/twenty-docs/fr/user-guide/settings/email-calendar-setup.mdx
new file mode 100644
index 0000000000..2cbabbc997
--- /dev/null
+++ b/packages/twenty-docs/fr/user-guide/settings/email-calendar-setup.mdx
@@ -0,0 +1,118 @@
+---
+title: Configuration des e-mails & calendrier
+info: "Connectez vos comptes de messagerie et de calendrier."
+image: /images/user-guide/emails/emails_header.png
+sectionInfo: Configurez les paramètres et préférences de votre espace de travail Twenty.
+---
+
+
+
+
+
+## Options de connexion
+
+### Compte Google (Gmail & Google Calendar)
+
+1. Allez dans **Paramètres → Comptes**
+2. Cliquez sur **Ajouter un compte**
+3. Sélectionnez **Continuer avec Google**
+4. Autorisez Twenty à accéder à votre Gmail et à votre Google Calendar
+5. Vos e-mails et événements de calendrier commenceront à se synchroniser automatiquement
+
+### Compte Microsoft (Outlook & Calendrier Microsoft)
+
+1. Allez dans **Paramètres → Comptes**
+2. Cliquez sur **Ajouter un compte**
+3. Sélectionnez **Continuer avec Microsoft**
+4. Autorisez Twenty à accéder à votre Outlook et à votre Calendrier Microsoft
+5. Vos e-mails et événements de calendrier commenceront à se synchroniser automatiquement
+
+### Configuration SMTP/CalDAV (Autres fournisseurs)
+
+Pour les autres fournisseurs de services de messagerie et de calendrier :
+
+1. Allez dans **Paramètres → Releases → Lab** pour activer la fonctionnalité
+2. Retournez à **Paramètres → Comptes**
+3. Configurez les paramètres SMTP pour l'e-mail
+4. Configurez les paramètres CalDAV pour le calendrier
+5. Tester la connexion
+
+### Boîtes aux lettres multiples
+
+- **Comptes illimités** : Connectez plusieurs comptes de messagerie par utilisateur
+- **Gestion de Compte**: Basculez entre différentes boîtes aux lettres
+- **Paramètres de Synchronisation**: Configurez différents paramètres par boîte aux lettres
+
+
+
+
+## Inviter de nouveaux membres
+
+### Utilisation du lien d'invitation
+
+1. Allez dans **Paramètres → Membres**
+2. Copiez le lien d'invitation de l'espace de travail
+3. Partagez le lien avec les nouveaux membres de l'équipe
+4. Ils recevront l'accès une fois qu'ils se seront inscrits
+
+### Invitation directe par e-mail
+
+1. Allez dans **Paramètres → Membres**
+2. Entrez l'adresse e-mail de la personne
+3. Cliquez sur **Inviter**
+4. Ils recevront une invitation par e-mail
+
+## Supprimer des membres
+
+### Supprimer un membre
+
+1. Allez dans **Paramètres → Membres**
+2. Trouvez le membre que vous souhaitez supprimer
+3. Cliquez sur le bouton supprimer à côté de leur nom
+4. Confirmez la suppression
+
+**Remarque** : Les membres supprimés perdent immédiatement l'accès, mais peuvent être réinvités plus tard.
+
+## Besoin d'aide ?
+
+Pour la gestion des rôles et des permissions, consultez l'[article sur les permissions](/user-guide/settings/permissions).
+
diff --git a/packages/twenty-docs/fr/user-guide/settings/permissions.mdx b/packages/twenty-docs/fr/user-guide/settings/permissions.mdx
new file mode 100644
index 0000000000..0adc30d2b5
--- /dev/null
+++ b/packages/twenty-docs/fr/user-guide/settings/permissions.mdx
@@ -0,0 +1,106 @@
+---
+title: Permissions
+info: "Apprenez à contrôler l'accès : attribuer les rôles et définir les permissions."
+image: /images/user-guide/permissions/permissions.png
+sectionInfo: Configurez les paramètres et préférences de votre espace de travail Twenty.
+---
+
+
+ 
+
+
+Le système d'autorisations de Twenty vous permet de contrôler l'accès à trois principales zones :
+
+- **Objets et champs** : Qui peut afficher, éditer ou supprimer des enregistrements et des champs individuels
+- **Paramètres** : Gérez l'accès à la configuration de l'espace de travail et aux fonctions administratives
+- **Actions** : Actions générales de l'espace de travail comme l'importation de données ou l'envoi d'e-mails
+
+## Créer un Rôle
+
+Pour créer un nouveau rôle :
+
+1. Allez dans **Paramètres → Rôles**
+2. Sous **Tous les rôles**, cliquez sur **+ Créer un rôle**
+3. Entrez un nom de rôle
+4. Dans l'onglet par défaut **Permissions**, configurez les autorisations
+5. Cliquez sur **Enregistrer** pour terminer
+
+## Supprimer un Rôle
+
+Pour supprimer un rôle :
+
+1. Allez dans **Paramètres → Rôles**
+2. Cliquez sur le rôle que vous souhaitez supprimer
+3. Ouvrez l'onglet **Paramètres**, puis cliquez sur **Supprimer le rôle**
+4. Cliquez sur **Confirmer** dans la fenêtre modale
+
+Remarque : Si un rôle est supprimé, tout membre de l'espace de travail qui lui est assigné sera automatiquement réattribué au rôle par défaut. Tous sauf le rôle **Admin** peuvent être supprimés. Il doit toujours y avoir au moins un membre assigné au rôle **Admin**.
+
+## Attribuer des Rôles aux Membres
+
+### Voir les Attributions Actuelles
+
+- Allez dans **Paramètres → Rôles**
+- Voir tous les rôles et combien de membres sont assignés à chacun
+- Voir quels membres ont quels rôles
+
+### Attribuer un Rôle à un Membre
+
+1. Allez dans **Paramètres → Rôles**
+2. Cliquez sur le rôle que vous souhaitez assigner
+3. Ouvrez l'onglet **Attribution**
+4. Cliquez sur **+ Attribuer à un membre**
+5. Sélectionnez le membre de l'espace de travail dans la liste
+6. Confirmez l'attribution
+
+### Définir le Rôle par Défaut
+
+1. Allez dans **Paramètres → Rôles**
+2. Dans la section **Options**, trouvez **Rôle par Défaut**
+3. Sélectionnez le rôle que les nouveaux membres devraient automatiquement recevoir
+4. Les nouveaux membres de l'espace de travail seront assignés à ce rôle lorsqu'ils rejoindront
+
+**Remarque** : Vous ne pouvez assigner des rôles qu'aux membres existants de l'espace de travail. Pour inviter de nouveaux membres, utilisez [Gestion des Membres](/user-guide/settings/member-management).
+
+## Personnaliser les Autorisations
+
+Les autorisations déterminent ce que chaque rôle peut accéder ou modifier dans votre espace de travail, y compris les enregistrements d'objets de l'espace de travail, les paramètres et les actions.
+
+### Autorisations d'Objet et de Champ
+
+Contrôlez l'accès aux enregistrements et aux champs individuels :
+
+#### Autorisations au niveau de l'objet
+
+- Sous **Tous les Objets**, appliquez des autorisations comme **Voir l'Enregistrement**, **Modifier les Enregistrements**, **Supprimer les Enregistrements** ou **Détruire les Enregistrements** à tous les objets
+- Sous **Autorisations au Niveau de l'Objet**, configurez des exceptions pour des objets individuels. Celles-ci remplacent les paramètres de **Tous les Objets**
+
+#### Autorisations au Niveau des Champs
+
+- Configurez les autorisations pour les champs individuels au sein de chaque objet
+- Contrôlez qui peut **Voir le Champ**, **Modifier le Champ**, ou qui n'a **Aucun Accès** aux champs spécifiques
+- Les autorisations des champs fonctionnent de la même manière que celles des objets, avec héritage et exceptions
+
+#### Gestion des Exceptions d'Autorisations
+
+Pour remplacer les autorisations parentales et appliquer des règles plus strictes :
+
+- Cliquez sur **X** pour supprimer la règle héritée
+- Sélectionnez les autorisations spécifiques pour l'objet ou le champ sélectionné
+- Cliquez sur l'icône orange **Annuler** (flèche circulaire) pour revenir aux modifications
+
+Lorsque terminé, cliquez sur **Terminer**, puis **Enregistrer** une fois redirigé vers la page de rôle.
+
+### Autorisations des Paramètres de l'Espace de Travail
+
+Contrôlez l'accès aux paramètres de l'espace de travail de deux manières :
+
+- Activez **Accès Complet aux Paramètres** pour accorder un accès total
+- Ou activez des autorisations spécifiques (par exemple, génération de clé API, préférences de l'espace de travail, attribution de rôles, configuration du modèle de données, paramètres de sécurité et gestion des workflows)
+
+### Autorisations des Actions de l'Espace de Travail
+
+Contrôlez l'accès aux actions générales de l'espace de travail :
+
+- Activez **Accès Complet à l'Application** pour accorder toutes les autorisations
+- Ou activez des actions individuelles telles que **Envoyer un Email**, **Importer CSV** et **Exporter CSV**
diff --git a/packages/twenty-docs/fr/user-guide/settings/profile-settings.mdx b/packages/twenty-docs/fr/user-guide/settings/profile-settings.mdx
index 9046fd83aa..3729c054a6 100644
--- a/packages/twenty-docs/fr/user-guide/settings/profile-settings.mdx
+++ b/packages/twenty-docs/fr/user-guide/settings/profile-settings.mdx
@@ -11,7 +11,7 @@ sectionInfo: Configurez les paramètres et préférences de votre espace de trav
## Informations personnelles
-### Nom et Email
+### Nom et e-mail
- **Nom affiché**: Modifiez comment votre nom apparaît aux autres membres de l’espace de travail
- **Adresse e-mail**: Changez votre e-mail de connexion (nécessite vérification)
diff --git a/packages/twenty-docs/fr/user-guide/settings/releases-settings.mdx b/packages/twenty-docs/fr/user-guide/settings/releases-settings.mdx
new file mode 100644
index 0000000000..e104b43b4e
--- /dev/null
+++ b/packages/twenty-docs/fr/user-guide/settings/releases-settings.mdx
@@ -0,0 +1,33 @@
+---
+title: Paramètres des versions
+info: "Découvrez les dernières versions et activez les fonctionnalités bêta dans le Lab."
+image: /images/user-guide/setup/releases.png
+sectionInfo: Configurez les paramètres et préférences de votre espace de travail Twenty.
+---
+
+
+ 
+
+
+## Dernières sorties
+
+Suivre le progrès du développement de Twenty :
+
+- **Notes de version** : Découvrez les nouveautés de chaque version
+- **Mises à jour des fonctionnalités** : Découvrez de nouvelles capacités et améliorations
+
+## Fonctionnalités du Lab
+
+Accédez aux fonctionnalités expérimentales avant leur sortie officielle :
+
+- **Test bêta** : Essayez de nouvelles fonctionnalités pendant leur développement
+- **Indicateurs de fonctionnalité** : Activez ou désactivez certaines fonctionnalités expérimentales
+
+## Comment accéder
+
+1. Allez dans **Paramètres → Versions**
+2. Consultez les notes de version et accédez à l'onglet **Lab** pour les fonctionnalités bêta
+
+Pour plus de ressources communautaires, consultez notre [section Ressources](/user-guide/resources/glossary).
+
+
diff --git a/packages/twenty-docs/fr/user-guide/views/views-sort-filter.mdx b/packages/twenty-docs/fr/user-guide/views/views-sort-filter.mdx
new file mode 100644
index 0000000000..17ec3dea67
--- /dev/null
+++ b/packages/twenty-docs/fr/user-guide/views/views-sort-filter.mdx
@@ -0,0 +1,182 @@
+---
+title: Vues, Tri et Filtre
+info: "Découvrez comment créer, gérer et supprimer des Vues d'Objet."
+image: /images/user-guide/views/filter.png
+sectionInfo: Découvrez comment utiliser des objets standards et personnalisés dans votre espace de travail.
+---
+
+
+ 
+
+
+## À propos des Vues
+
+Vous pouvez voir vos enregistrements de différentes manières en créant des vues. Dans une vue, vous pouvez appliquer des filtres et des tris pour organiser efficacement votre contenu. Par exemple, sur l'objet `Personnes`, vous pouvez créer une vue pour isoler les contacts américains en filtrant ceux avec un numéro de téléphone américain.
+
+### Vue par défaut
+
+Chaque objet est doté d'une vue non filtrée, non triée et non supprimable connue sous le nom de vue par défaut. Elle porte le nom pluriel de l'objet, tel que "Toutes les Entreprises", "Toutes les Personnes", "Toutes les Opportunités".
+
+
+
+## Création, Modification et Suppression des Vues
+
+Vous pouvez créer plusieurs vues personnalisées et les partager avec votre équipe.
+
+### Création d'une Vue
+
+Il y a deux manières de créer une nouvelle vue. Soit directement depuis le `Sélecteur de Vue`, soit en filtrant et triant une vue existante.
+
+#### Depuis le Sélecteur de Vue
+
+1. Ouvrez le Sélecteur de Vue
+2. Cliquez sur le bouton `Ajouter une Vue` en bas du menu du sélecteur de vue.
+3. Choisissez une icône et un nom pour votre vue.
+4. Choisissez un "Type de Vue" entre Tableau et Kanban.
+5. (Vues Kanban uniquement) Pour votre vue Kanban, sélectionnez le champ Sélection que vous souhaitez utiliser comme en-tête de colonne. Le système vous invite à en créer un à partir des Paramètres avant d'activer la création de vue Kanban, si votre objet ne possède pas de champ de type `Sélection`.
+6. Cliquez sur "Créer" pour générer votre nouvelle vue.
+
+La vue nouvellement créée s'ouvre automatiquement.
+
+
+
+
+
+
+#### Depuis le Tri et le Filtrage
+
+Lorsque vous changez le `Tri` et le `Filtrage` d'une vue existante, un bouton `Enregistrer comme nouvelle vue` apparaîtra à l'extrémité droite de la `Barre de Vue`. Cela ouvrira le menu Nouvelle Vue mentionné ci-dessus, vous permettant de créer une nouvelle vue à partir d'une existante.
+
+
+
+
+
+
+### Modification et Suppression d'une Vue
+
+Pour modifier ou supprimer une vue :
+
+1. Ouvrez le Sélecteur de Vue.
+2. Survolez la vue que vous souhaitez modifier.
+3. Cliquez sur les trois points qui apparaissent au survol pour modifier et supprimer les vues.
+
+En cliquant sur modifier, vous pouvez changer l'icône et le nom de la vue ou supprimer complètement la vue.
+
+
+
+
+
+
+## Navigation entre les Vues
+
+Pour passer d'une vue à l'autre, ouvrez simplement le sélecteur de vue et cliquez sur la vue que vous souhaitez ouvrir.
+
+## Personnalisation des Vues
+
+Chaque vue peut être personnalisée pour rationaliser vos processus métier. Les vues aident à segmenter vos données. Vous pouvez personnaliser les vues en utilisant des filtres, des tris et l'affichage des champs.
+
+### Filtrer une Vue
+
+Pour filtrer une vue :
+
+- Cliquez sur **Filtrer** > sélectionnez un champ (par exemple : Nom, Entreprise dans l'objet Personnes).
+- Choisissez une condition, sélectionnez une valeur et appliquez le filtre.
+- Ajoutez plus de filtres avec `+ Ajouter un filtre` ou supprimez-les avec **X**.
+
+
+
+
+
+
+### Trier une Vue
+
+Ordonnez les données de vos champs dans l'ordre croissant ou décroissant :
+
+- Sélectionnez **Trier**, choisissez un champ et définissez l'ordre de tri souhaité.
+- Vous pouvez appliquer et arranger plusieurs tris au besoin.
+
+
+
+
+
+
+### Affichage des Champs
+
+Vous pouvez personnaliser les champs à afficher dans une vue. Pour masquer un champ, cliquez sur **Options** > **Champs** et sélectionnez l'icône de masquage au survol ou cliquez sur l'en-tête de colonne du champ et sélectionnez **masquer**.
+
+Vous pouvez réorganiser les champs en cliquant sur leur en-tête de colonne puis appuyez sur **Déplacer à droite** ou **Déplacer à gauche**.
+
+### Ouverture de l'enregistrement
+
+Pour ouvrir un enregistrement, cliquez sur le nom dans la première colonne. Cette action ouvrira la page de l'enregistrement correspondant sous forme de panneau latéral.
+
diff --git a/packages/twenty-docs/fr/user-guide/workflows/getting-started-workflows.mdx b/packages/twenty-docs/fr/user-guide/workflows/getting-started-workflows.mdx
new file mode 100644
index 0000000000..1221a64ac1
--- /dev/null
+++ b/packages/twenty-docs/fr/user-guide/workflows/getting-started-workflows.mdx
@@ -0,0 +1,77 @@
+---
+title: Démarrer avec les Workflows
+info: "Apprenez comment ajouter des automatisations et des idées pour commencer."
+image: /images/user-guide/workflows/workflow.png
+sectionInfo: Automatisez les processus et intégrez avec des outils externes
+---
+
+
+ 
+
+
+## Pourquoi les Workflows sont importants
+
+Twenty a été conçu pour offrir une flexibilité maximale à ses utilisateurs. Plutôt que de vous obliger à adapter vos processus métier à des fonctionnalités rigides et préconstruites, les workflows vous permettent de créer des automatisations qui créent le CRM qui soutient au mieux vos cas d'utilisation unique.
+
+Les workflows sont la fonctionnalité intégrée de Twenty pour construire ces automatisations. Ils vous donnent les éléments de base pour créer exactement ce dont votre entreprise a besoin, au moment où elle en a besoin.
+
+## Que puis-je faire avec les workflows?
+
+Nous recommandons de créer des automatisations pour deux objectifs principaux :
+
+1. **Automatisations internes pour faciliter le quotidien de votre équipe** : Réduisez le nombre d'entrées manuelles et les tâches répétitives qui ralentissent votre équipe.
+2. **Importez et exportez des données de Twenty** : Connectez Twenty via des appels API et des webhooks à votre base de données et à d'autres outils.
+
+Explorons des exemples de ce qui est possible avant de plonger dans le comment.
+
+## 1. Automatisations internes
+
+Votre CRM n'est utile que si les données sont à jour, mais personne n'aime les actualiser. Utilisez les workflows pour automatiser les tâches répétitives à faible valeur ajoutée et garder votre équipe concentrée sur l'essentiel.
+
+Exemples de ce que vous pouvez automatiser en interne :
+
+- **Gestion des données** : Signalement automatique des e-mails personnels, attribution de leads, validation des données
+- **Processus de vente** : Mises à jour basées sur les étapes, gestion du churn, alertes d'opportunités stagnantes
+- **Productivité** : Rappels de tâches hebdomadaires, suivis de réunion, synchronisation de champs inter-object
+
+Pour des exemples détaillés et des instructions pas à pas, consultez notre guide [Automatisations internes](/user-guide/workflows/internal-automations).
+
+## 2. Intégrations externes
+
+Connectez Twenty avec vos autres outils et sources de données pour créer un système d'affaires unifié. Vous pouvez importer des données dans Twenty à partir de formulaires Web, de bases de données produit, d'enregistreurs d'appels et de services d'enrichissement. Vous pouvez également envoyer des données vers des outils de marketing par e-mail, des systèmes de facturation et d'autres applications commerciales.
+
+Exemples de ce que vous pouvez intégrer :
+
+- **Ingestion de données** : Soumissions de formulaires Web, synchronisation des données produit, notes de réunion, enrichissement des données.
+- **Distribution de données** : Gestion de newsletters, séquences d'e-mails, notation des prospects, génération de factures.
+
+Pour des modèles d'intégration détaillés et des conseils de mise en œuvre, consultez notre guide [Intégration d'outils externes](/user-guide/workflows/external-tool-integration).
+
+### Que faire si je ne veux pas créer ces connexions?
+
+Nous proposons des [Services Professionnels](/user-guide/workflows/professional-services) pour vous aider à créer les automatisations dont vous avez besoin.
+Selon la portée de votre projet, nous vous suggérerons un [Pack d'Intégration](https://twenty.com/onboarding-packages) ou nous vous mettrons en contact avec nos partenaires de mise en œuvre certifiés. Ils peuvent créer votre modèle de données, migrer vos données, construire vos workflows.
+
+### Je ne suis pas sûr que la connexion dont j'ai besoin soit réalisable.
+
+Envoyez-nous un message et nous vous aiderons à évaluer la faisabilité.
+
+## Meilleures Pratiques des Workflows
+
+Lorsque vous commencez à créer des workflows, gardez ces conseils à l'esprit:
+
+- **Renommer les étapes** : Renommez les étapes de votre workflow pour décrire clairement ce que fait chacune. Cela aide à la maintenance et facilite le transfert à des collègues.
+- **Utiliser les données des étapes précédentes** : Vous pouvez utiliser des champs provenant des enregistrements renvoyés par n'importe quelle étape précédente de votre workflow.
+- **Commencez simple** : Débutez avec des workflows basiques et ajoutez de la complexité au fil du temps à mesure que vous maîtrisez le système.
+- **Planifiez avant de construire** : Planifiez la logique de votre workflow avant de commencer à construire pour éviter de vous bloquer en cours de route.
+- **Utilisez les branches judicieusement** : Après une étape `Recherche d'Enregistrements`, créez des branches pour gérer à la fois les scénarios "mise à jour d'un enregistrement existant" et "création d'un nouvel enregistrement", puis fusionnez à nouveau les chemins.
+
+## Ce sur quoi nous travaillons
+
+Voici les principaux éléments sur lesquels nous travaillons pour améliorer les workflows:
+
+- Boucles (L'Itérateur est actuellement en version bêta, activez-le sous Paramètres → Versions → Laboratoire)
+- Étape Si / Sinon
+- Agent IA pour créer des workflows en votre nom
+
+
diff --git a/packages/twenty-docs/fr/user-guide/workflows/internal-automations.mdx b/packages/twenty-docs/fr/user-guide/workflows/internal-automations.mdx
index 0b2bce8a45..1a5e5ca5e5 100644
--- a/packages/twenty-docs/fr/user-guide/workflows/internal-automations.mdx
+++ b/packages/twenty-docs/fr/user-guide/workflows/internal-automations.mdx
@@ -9,7 +9,7 @@ sectionInfo: Automatisez les processus et intégrez avec des outils externes
-Voici des exemples de workflows que vous pourriez déployer pour automatiser les tâches répétitives, réduire le travail manuel et maintenir vos données à jour.
+Voici des exemples que vous pourriez déployer pour automatiser les tâches répétitives, réduire le travail manuel et maintenir vos données à jour.
## Automatisations de gestion des données
@@ -24,9 +24,9 @@ Voici des exemples de workflows que vous pourriez déployer pour automatiser les
**Actions** :
- Action de code pour vérifier si le domaine de l'e-mail correspond à des fournisseurs personnels courants (gmail.com, yahoo.com, etc.)
-- Mettre à jour l'enregistrement pour définir le drapeau "email personnel"
+- Mettre à jour l'enregistrement pour définir le drapeau "est un e-mail personnel"
-### Attribution de leads - Rotation continue
+### Affectation de leads - par Tourniquet
**Problème** : Les nouveaux prospects doivent être distribués équitablement à travers votre équipe de vente pour garantir une charge de travail équilibrée.
@@ -73,7 +73,7 @@ Voici des exemples de workflows que vous pourriez déployer pour automatiser les
- Envoyer une notification par e-mail à l'équipe de réussite client
- Requête HTTP pour mettre à jour le système de facturation externe
-### Gestion de l'Étape d'Opportunité - Renouvellement Perdu Clos
+### Gestion de l'Étape d'Opportunité - Perte de Renouvellement
**Problème**: Quand les opportunités de renouvellement sont perdues, le statut du client doit être mis à jour pour une gestion correcte des comptes.
diff --git a/packages/twenty-docs/fr/user-guide/workflows/professional-services.mdx b/packages/twenty-docs/fr/user-guide/workflows/professional-services.mdx
new file mode 100644
index 0000000000..9585f42fe0
--- /dev/null
+++ b/packages/twenty-docs/fr/user-guide/workflows/professional-services.mdx
@@ -0,0 +1,37 @@
+---
+title: Services Professionnels
+info: Obtenez de l'aide professionnelle pour créer des workflows et automatisations complexes grâce à l'équipe de Twenty et à ses partenaires certifiés.
+image: /images/user-guide/what-is-twenty/implementation_services.png
+sectionInfo: Automatisez les processus et intégrez avec des outils externes
+---
+
+
+
+
+
+## Quand avez-vous besoin d'une aide professionnelle ?
+
+Considérez les services professionnels pour :
+
+- Intégrations complexes de plusieurs systèmes
+- Logique métier avancée et règles d'automatisation
+- Workflows de traitement de données à grande échelle
+- Développement d'API sur mesure
+- Formation d'équipe et optimisation des workflows
+- Quand vous n'avez pas de ressources internes
+
+## Options de Service
+
+### Packs d'intégration
+
+Obtenez de l'aide de notre équipe centrale avec nos packs [d'intégration de 4 heures](https://twenty.com/onboarding-packages) :
+
+- **Création de Workflow** : Construisez des workflows personnalisés pour vos processus métier
+- **Conception de Modèle de Données** : Optimisez votre structure de données pour l'automatisation des workflows
+- **Migration de Données** : Importez des données existantes avec une intégration de workflow appropriée
+
+### Partenaires pour l'Implémentation
+
+Travaillez avec des partenaires certifiés pour des personnalisations avancées. Contactez-nous à contact@twenty.com pour vous connecter avec nos [partenaires de mise en œuvre](https://twenty.com/implementation-services).
+
+
diff --git a/packages/twenty-docs/fr/user-guide/workflows/workflow-credits.mdx b/packages/twenty-docs/fr/user-guide/workflows/workflow-credits.mdx
index 949e921a4f..0e6555b999 100644
--- a/packages/twenty-docs/fr/user-guide/workflows/workflow-credits.mdx
+++ b/packages/twenty-docs/fr/user-guide/workflows/workflow-credits.mdx
@@ -67,7 +67,7 @@ Si vous avez besoin de plus de crédits que votre allocation de plan :
### Conception efficace de flux de travail
-- **Commencez simple** : Commencez par des actions basiques et ajoutez progressivement de la complexité
+- **Commencez simple** et ajoutez de la complexité progressivement
- **Testez en brouillon** : Testez soigneusement les flux de travail avant l'activation pour éviter de gaspiller des crédits en cas d'erreurs
- **Minimisez les requêtes HTTP** : Utilisez des critères de recherche efficaces et combinez les opérations lorsque cela est possible
- **Traitement par lots** : Utilisez efficacement les opérations en masse et les actions d'itérateur
diff --git a/packages/twenty-docs/fr/user-guide/workflows/workflow-features.mdx b/packages/twenty-docs/fr/user-guide/workflows/workflow-features.mdx
new file mode 100644
index 0000000000..ec34753cc1
--- /dev/null
+++ b/packages/twenty-docs/fr/user-guide/workflows/workflow-features.mdx
@@ -0,0 +1,320 @@
+---
+title: Caractéristiques du flux de travail
+info: Référence complète pour tous les déclencheurs de flux de travail disponibles, les actions et les fonctionnalités de gestion.
+image: /images/user-guide/workflows/robot.png
+sectionInfo: Automatisez les processus et intégrez avec des outils externes
+---
+
+
+ 
+
+
+## Déclencheurs de flux de travail
+
+Les flux de travail commencent toujours par un seul déclencheur qui définit quand l’automatisation doit s’exécuter.
+
+### Un enregistrement est créé
+
+Démarre le flux de travail lorsqu'un nouvel enregistrement est créé dans un objet sélectionné (Personnes, Entreprises, Opportunités, ou tout objet personnalisé).
+
+**Configuration**: Sélectionnez le type d'objet à surveiller pour les nouveaux enregistrements.
+
+### Un enregistrement est mis à jour
+
+Démarre le flux de travail lorsque des modifications sont apportées à un enregistrement existant.
+
+**Configuration**:
+
+- Sélectionnez le type d'objet
+- Spécifiez éventuellement quels champs surveiller pour les changements
+
+### Un enregistrement est mis à jour ou créé
+
+Démarre le flux de travail lorsqu'un enregistrement est soit créé soit mis à jour dans un objet sélectionné.
+
+**Pourquoi est-ce important**: Ce déclencheur est particulièrement utile car les enregistrements créés par différentes méthodes se comportent différemment :
+
+- **Importations API/CSV** : Les enregistrements sont créés avec tous les champs remplis immédiatement
+- **Création manuelle** : Les enregistrements sont créés d'abord, puis les champs sont ajoutés lors de mises à jour ultérieures
+
+**Configuration**:
+
+- Sélectionnez le type d'objet à surveiller
+- Spécifiez éventuellement quels champs surveiller pour les changements
+- Le flux de travail se déclenchera à la fois lors de la création initiale et lors de mises à jour ultérieures
+
+### Un enregistrement est supprimé
+
+Démarre le flux de travail lorsqu'un enregistrement est supprimé d'un objet.
+
+**Configuration**: Sélectionnez le type d'objet à surveiller pour les suppressions.
+
+### Lancer manuellement
+
+Démarre le flux de travail lorsqu'il est déclenché par une action de l'utilisateur. Ce déclencheur peut être accessible via le menu Cmd+K ou via un bouton personnalisé dans la barre de navigation supérieure.
+
+**Configuration de disponibilité**:
+Choisissez comment le flux de travail doit gérer la sélection des enregistrements :
+
+- **Global** : Aucun enregistrement n'est requis pour déclencher ce flux de travail. Le flux de travail est déclenché de n'importe où (depuis n'importe quel objet) et n'utilise pas d'enregistrement(s) en tant qu'entrée.
+
+- **Unique** : Le(s) enregistrement(s) sélectionné(s) seront transmis à votre flux de travail. Cela est configuré pour un objet donné. Plusieurs enregistrements peuvent être sélectionnés avant de déclencher le flux de travail. Le flux de travail s'exécutera autant de fois qu'il y a d'enregistrements sélectionnés.
+
+