@adminiumjs/i18n 0.2.5 → 0.2.6

package/dist/resources/fr-fr/automations.d.ts

@@ -0,0 +1,417 @@
+/**
+ * GENERATED MIRROR of ../../../locales/fr-FR/automations.json — do not edit by hand.
+ * The JSON file is the canonical hand-authored bundle (10-i18n-theming.md §3.1);
+ * this TS mirror exists so the runtime can bundle a namespace (en-US's eager
+ * ones) or chunk-split it (every other locale, and en-US's deferred `studio`)
+ * without JSON import attributes (browser + NodeNext safe).
+ * Parity is enforced by src/resources/parity.test.ts. Regenerate with
+ * scripts/gen-resources.mjs.
+ */
+declare const _default: {
+    readonly rules: {
+        readonly title: "Règles d'automatisation";
+        readonly subtitle: "Déclenchez des flux automatiquement quand quelque chose se produit.";
+        readonly new: "Nouvelle règle";
+        readonly empty: {
+            readonly title: "Aucune règle pour l'instant";
+            readonly body: "Créez une règle pour exécuter des étapes automatiquement quand quelque chose se produit.";
+        };
+        readonly none: "Sélectionnez une règle pour voir son flux";
+    };
+    readonly kpi: {
+        readonly activeRules: "Règles actives";
+        readonly runsToday: "Exécutions aujourd'hui";
+        readonly successRate: "Taux de réussite";
+        readonly timeSaved: "Temps gagné (mois)";
+    };
+    readonly filter: {
+        readonly all: "Toutes";
+        readonly active: "Actives";
+        readonly paused: "En pause";
+    };
+    readonly card: {
+        readonly runs: "exécutions";
+        readonly success: "réussite";
+        readonly never: "Jamais exécutée";
+        readonly toggle: "Activer/désactiver";
+    };
+    readonly status: {
+        readonly active: "Active";
+        readonly paused: "En pause";
+    };
+    readonly flow: {
+        readonly steps: "{count, plural, one {# étape} other {# étapes}}";
+        readonly saves: "gagne {time} / exécution";
+        readonly runs30d: "exéc. 30 j";
+        readonly success: "réussite";
+        readonly test: "Tester";
+        readonly running: "En cours";
+        readonly noSample: "Aucun enregistrement pour tester — ajoutez-en un d'abord";
+        readonly menu: "Actions sur la règle";
+    };
+    readonly menu: {
+        readonly rename: "Renommer";
+        readonly duplicate: "Dupliquer";
+        readonly delete: "Supprimer";
+    };
+    readonly delete: {
+        readonly title: "Supprimer {name} ?";
+        readonly body: "Son historique d'exécutions part avec elle. Cette action est irréversible.";
+        readonly confirm: "Supprimer";
+        readonly cancel: "Annuler";
+    };
+    readonly save: {
+        readonly unsaved: "Modifications non enregistrées";
+        readonly saving: "Enregistrement…";
+        readonly saved: "Tout est enregistré";
+        readonly action: "Enregistrer";
+    };
+    readonly guard: {
+        readonly title: "Quitter sans enregistrer ?";
+        readonly body: "Vos modifications sur cette règle seront perdues.";
+        readonly stay: "Continuer l'édition";
+        readonly leave: "Quitter";
+    };
+    readonly toast: {
+        readonly saved: "Règle enregistrée";
+        readonly enabled: "{name} est activée";
+        readonly paused: "{name} est en pause";
+        readonly incomplete: "Terminez « {step} » avant d'activer cette règle";
+        readonly duplicated: "{name} dupliquée";
+        readonly deleted: "{name} supprimée";
+        readonly failed: "Cela n'a pas été enregistré — {reason}";
+    };
+    readonly canvas: {
+        readonly insert: "Insérer une étape ici";
+        readonly addStep: "Ajouter une étape";
+        readonly remove: "Supprimer l'étape";
+    };
+    readonly kind: {
+        readonly trigger: "DÉCLENCHEUR";
+        readonly condition: "FILTRE";
+        readonly branch: "SI / SINON";
+        readonly wait: "DÉLAI";
+        readonly action: "ACTION";
+    };
+    readonly branch: {
+        readonly ifMatches: "Si ça correspond";
+        readonly otherwise: "Sinon";
+    };
+    readonly picker: {
+        readonly title: "Ajouter une étape";
+        readonly before: "Avant · {title}";
+        readonly end: "À la fin du flux";
+        readonly inBranch: "Dans la branche · {label}";
+        readonly actions: "Actions";
+        readonly logic: "Logique";
+        readonly close: "Fermer";
+    };
+    readonly pick: {
+        readonly email: "Envoyer un e-mail";
+        readonly emailDesc: "Depuis un modèle enregistré";
+        readonly notification: "Envoyer une notification";
+        readonly notificationDesc: "Prévenir des personnes de cet espace";
+        readonly create: "Créer un enregistrement";
+        readonly createDesc: "Ajouter une ligne à une table";
+        readonly update: "Mettre à jour un champ";
+        readonly updateDesc: "Réécrire dans un enregistrement";
+        readonly webhook: "Appeler un webhook";
+        readonly webhookDesc: "Envoyer des données n'importe où";
+        readonly slack: "Message Slack";
+        readonly slackDesc: "Publier dans un canal";
+        readonly branch: "Branche si / sinon";
+        readonly branchDesc: "Séparer en deux chemins";
+        readonly filter: "Continuer seulement si";
+        readonly filterDesc: "S'arrêter si ça ne correspond pas";
+        readonly wait: "Attendre / temporiser";
+        readonly waitDesc: "Patienter avant l'étape suivante";
+        readonly stop: "Arrêter le flux";
+        readonly stopDesc: "Interrompre cette exécution ici";
+    };
+    readonly node: {
+        readonly email: {
+            readonly sub: "Modèle · à choisir";
+            readonly summary: "Modèle · {template} → {to}";
+        };
+        readonly notification: {
+            readonly sub: "Choisissez qui prévenir";
+            readonly summary: "À · {who}";
+        };
+        readonly create: {
+            readonly sub: "Table · à choisir";
+            readonly summary: "{table} · {count} valeurs";
+        };
+        readonly update: {
+            readonly sub: "Définir une valeur";
+            readonly summary: "{pairs}";
+        };
+        readonly webhook: {
+            readonly sub: "POST · charge JSON";
+            readonly summary: "{method} {host}";
+        };
+        readonly slack: {
+            readonly sub: "Canal · ajoutez une URL de webhook";
+            readonly summary: "Slack · {host}";
+        };
+        readonly wait: {
+            readonly title: "Attendre / temporiser";
+            readonly sub: "Pause de {duration}";
+        };
+        readonly stop: {
+            readonly title: "Arrêter le flux";
+            readonly sub: "Met fin à l'exécution";
+        };
+        readonly condition: {
+            readonly empty: "Définir une condition";
+        };
+        readonly trigger: {
+            readonly record: "Quand un enregistrement est {event} dans {table}";
+            readonly interval: "Toutes les {minutes} minutes";
+            readonly daily: "Chaque jour à {time}";
+            readonly weekly: "Chaque semaine le {day} à {time}";
+            readonly monthly: "Chaque mois le {day} à {time}";
+            readonly sub: "Déclencheur · {event}";
+        };
+    };
+    readonly event: {
+        readonly created: "créé";
+        readonly updated: "mis à jour";
+        readonly deleted: "supprimé";
+    };
+    readonly insp: {
+        readonly stepName: "Nom de l'étape";
+        readonly description: "Description";
+        readonly condition: "Condition";
+        readonly lookAt: "Regarder";
+        readonly thisRecord: "Cet enregistrement";
+        readonly related: "Enregistrements liés";
+        readonly field: "Champ";
+        readonly value: "Valeur";
+        readonly countOf: "Nombre de";
+        readonly where: "où";
+        readonly isThisRecords: "est égal au champ de cet enregistrement";
+        readonly andWhere: "et où";
+        readonly branchLabels: "Libellés des branches";
+        readonly onError: "Continuer en cas d'erreur";
+        readonly onErrorBody: "Exécuter les étapes suivantes même si celle-ci échoue";
+        readonly moveUp: "Monter";
+        readonly moveDown: "Descendre";
+        readonly duplicate: "Dupliquer";
+        readonly delete: "Supprimer";
+        readonly close: "Fermer";
+        readonly settings: "Réglages";
+    };
+    readonly op: {
+        readonly is: "est";
+        readonly isNot: "n'est pas";
+        readonly contains: "contient";
+        readonly gt: "est supérieur à";
+        readonly lt: "est inférieur à";
+        readonly isEmpty: "est vide";
+        readonly notEmpty: "n'est pas vide";
+        readonly withinNext: "est dans les prochaines";
+        readonly withinLast: "est dans les dernières";
+        readonly moreThanAgo: "était il y a plus de …";
+        readonly moreThanAhead: "est dans plus de …";
+    };
+    readonly unit: {
+        readonly minutes: "{count, plural, one {minute} other {minutes}}";
+        readonly hours: "{count, plural, one {heure} other {heures}}";
+        readonly days: "{count, plural, one {jour} other {jours}}";
+    };
+    readonly trig: {
+        readonly title: "Déclencheur";
+        readonly kind: "Quand";
+        readonly record: "Un enregistrement est {event}";
+        readonly schedule: "Selon un calendrier";
+        readonly table: "Table";
+        readonly changed: "Seulement quand cette colonne change";
+        readonly anyColumn: "N'importe quelle colonne";
+        readonly watch: {
+            readonly on: "Surveille aussi les lignes écrites hors d'Adminium · chaque minute · via {column}";
+            readonly off: "Surveillance désactivée : cette table n'a ni colonne de type « {shape} » ni clé croissante, donc seules les écritures faites via Adminium déclenchent cette règle";
+            readonly deleted: "Les lignes supprimées ne peuvent pas être surveillées ; seules les suppressions faites via Adminium déclenchent cette règle";
+            readonly fromNow: "Les lignes à partir de maintenant";
+        };
+        readonly when: "Seulement si";
+        readonly every: "Toutes les";
+        readonly at: "À";
+        readonly timezone: "Fuseau horaire";
+        readonly forEach: "Pour chaque enregistrement de";
+        readonly forEachWhere: "où";
+        readonly noTable: "Aucune table — une exécution par tick";
+        readonly once: "Une fois par enregistrement";
+        readonly onceBody: "Un enregistrement déjà traité ne l'est pas de nouveau";
+        readonly timeSaved: "Temps gagné par exécution";
+        readonly timeSavedBody: "Minutes qu'une personne aurait passées — affiché comme « gagne » sur la règle";
+        readonly addCondition: "Ajouter une condition";
+        readonly connection: "Connexion";
+    };
+    readonly sched: {
+        readonly interval: "Intervalle";
+        readonly daily: "Quotidien";
+        readonly weekly: "Hebdomadaire";
+        readonly monthly: "Mensuel";
+    };
+    readonly email: {
+        readonly template: "Modèle";
+        readonly to: "À";
+        readonly toField: "L'e-mail de cet enregistrement";
+        readonly toFixed: "Adresses";
+        readonly column: "Colonne";
+        readonly addresses: "Ajouter une adresse…";
+    };
+    readonly notif: {
+        readonly to: "Envoyer à";
+        readonly roles: "Toutes les personnes ayant un rôle";
+        readonly users: "Des personnes précises";
+        readonly title: "Titre";
+        readonly body: "Message";
+    };
+    readonly rec: {
+        readonly table: "Table";
+        readonly values: "Valeurs";
+        readonly addValue: "Ajouter une valeur";
+        readonly column: "Colonne";
+        readonly value: "Valeur";
+        readonly now: "Maintenant";
+        readonly remove: "Supprimer cette valeur";
+        readonly tokenHint: "Utilisez {token} pour reprendre la valeur de l'enregistrement";
+    };
+    readonly hook: {
+        readonly url: "URL";
+        readonly method: "Méthode";
+        readonly body: "Corps";
+        readonly bodyJson: "JSON (événement, règle, enregistrement)";
+        readonly bodyText: "Texte personnalisé";
+        readonly header: "En-tête";
+        readonly headerName: "Nom";
+        readonly headerValue: "Valeur";
+        readonly slackUrl: "URL du webhook Slack";
+        readonly slackText: "Message";
+    };
+    readonly wait: {
+        readonly for: "Attendre";
+        readonly max: "Jusqu'à 30 jours";
+        readonly amount: "Quantité";
+        readonly unit: "Unité";
+    };
+    readonly modal: {
+        readonly title: "Nouvelle règle";
+        readonly subtitle: "Déclenchez des flux automatiquement quand quelque chose se produit.";
+        readonly name: "Nom de la règle";
+        readonly namePlaceholder: "ex. Accueillir les nouvelles inscriptions";
+        readonly when: "Quand (déclencheur)";
+        readonly then: "Alors (action)";
+        readonly enable: "Activer immédiatement";
+        readonly enableBody: "Commence à s'exécuter dès la création de la règle";
+        readonly cancel: "Annuler";
+        readonly create: "Créer la règle";
+        readonly doneTitle: "Règle créée";
+        readonly doneBody: "Votre règle est active et s'exécutera au prochain déclenchement.";
+        readonly savedTitle: "Règle enregistrée";
+        readonly savedBody: "Terminez ses étapes, puis activez-la.";
+        readonly done: "Terminé";
+        readonly trigger: {
+            readonly recordCreated: "Un enregistrement est créé";
+            readonly recordUpdated: "Un enregistrement est mis à jour";
+            readonly recordDeleted: "Un enregistrement est supprimé";
+            readonly schedule: "Selon un calendrier";
+        };
+        readonly connection: "{connection} · {table}";
+        readonly tablePlaceholder: "Rechercher une table…";
+        readonly tableEmpty: "Aucune table correspondante";
+    };
+    readonly logs: {
+        readonly title: "Journaux des flux";
+        readonly subtitle: "Historique d'exécution de vos automatisations.";
+        readonly refresh: "Actualiser";
+        readonly kpi: {
+            readonly runsToday: "Exécutions aujourd'hui";
+            readonly success: "Taux de réussite";
+            readonly failed: "Échecs";
+            readonly avgDuration: "Durée moy.";
+        };
+        readonly filter: {
+            readonly all: "Toutes";
+            readonly success: "Réussies";
+            readonly failed: "Échouées";
+            readonly running: "En cours";
+        };
+        readonly status: {
+            readonly success: "Réussie";
+            readonly failed: "Échouée";
+            readonly running: "En cours";
+            readonly pending: "Démarre {when}";
+            readonly waiting: "En attente · reprend {when}";
+            readonly skipped: "Ignorée";
+            readonly cancelled: "Annulée";
+        };
+        readonly trigger: "Déclencheur";
+        readonly duration: "Durée";
+        readonly started: "Démarrée";
+        readonly trace: "Trace d'exécution";
+        readonly loadOlder: "Charger plus anciennes";
+        readonly empty: {
+            readonly title: "Aucune exécution";
+            readonly filtered: "Aucune exécution « {status} » ces 7 derniers jours";
+        };
+        readonly select: "Sélectionnez une exécution pour voir sa trace";
+        readonly justNow: "à l'instant";
+    };
+    readonly trace: {
+        readonly trigger: "enregistrement = {label} · {summary}";
+        readonly scheduleTick: "top · {stamp}";
+        readonly evaluated: "évalué → {result}";
+        readonly stopped: "évalué → false · arrêté";
+        readonly branch: "a pris « {label} »";
+        readonly wait: "reprend {stamp}";
+        readonly wouldWait: "Attendrait {duration}";
+        readonly email: {
+            readonly ok: "{smtp} · remis à {to}";
+            readonly fail: "ERREUR · {reason}";
+            readonly would: "Enverrait « {subject} » à {to}";
+            readonly noSmtp: "SMTP n'est pas configuré — Réglages → E-mail";
+            readonly noRecipient: "Aucun destinataire : {column} est vide";
+        };
+        readonly notif: {
+            readonly ok: "{count, plural, one {# personne} other {# personnes}} prévenue(s)";
+        };
+        readonly create: {
+            readonly ok: "{label} créé";
+        };
+        readonly update: {
+            readonly ok: "{pairs} défini";
+        };
+        readonly write: {
+            readonly would: "Définirait {pairs}";
+        };
+        readonly hook: {
+            readonly ok: "{method} {path} → {status} · {ms} ms";
+            readonly fail: "{method} {path} → {status}";
+            readonly would: "Ferait {method} {url}";
+        };
+        readonly stop: "Arrêté ici";
+        readonly undone: "Annulé avant son exécution";
+        readonly gone: "L'enregistrement n'existe plus";
+        readonly ruleOff: "La règle a été désactivée pendant l'attente";
+        readonly skipped: "—";
+        readonly document: {
+            readonly ok: "document établi · {number}";
+            readonly skipped: "aucun document établi · {reason}";
+            readonly would: "Établirait {kind} · {name}";
+            readonly off: "correspondance désactivée · {name}";
+        };
+    };
+    readonly dur: {
+        readonly ms: "{ms} ms";
+        readonly s: "{s} s";
+        readonly none: "—";
+    };
+    readonly saved: {
+        readonly h: "{h} h";
+        readonly m: "{m} min";
+    };
+};
+export default _default;
+//# sourceMappingURL=automations.d.ts.map

package/dist/resources/fr-fr/automations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"automations.d.ts","sourceRoot":"","sources":["../../../src/resources/fr-fr/automations.ts"],"names":[],"mappings":"AACA;;;;;;;;GAQG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACH,wBAqZW"}