@adyen/kyc-components 3.82.6 → 3.83.0-beta.1

package/dist/{fieldConfigurations-DfVO1kZe.js → fieldConfigurations-CK0kTwGU.js}

@@ -2,22 +2,22 @@
 {
   try {
     let e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
-    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "e591264f-1b15-46c2-99b5-c5fdbfc18102", e._sentryDebugIdIdentifier = "sentry-dbid-e591264f-1b15-46c2-99b5-c5fdbfc18102");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "cf90bf7f-266b-44e1-bae0-b22c9d71fd3b", e._sentryDebugIdIdentifier = "sentry-dbid-cf90bf7f-266b-44e1-bae0-b22c9d71fd3b");
   } catch (e) {
   }
 }
 ;
-import { c as useLegalEntity, R as ROOT_LE, X as useExperimentsContext, am as getCapabilityProblems, g as getLegalEntityCountry, N as createLogger, b as useApiContext, an as hasText, ao as isValidMinLength, ap as matchesRegex, a9 as isEmpty, aq as NO_ALPHABET_REGEX, ar as EMOJI_REGEX, as as hasRepeatedCharacters, at as isInvalidName, au as OTHER_ENTITIES_VALID_CHAR_REGEX, av as LATIN_SPACE_MARK_PUNCTUATION_REGEX, aw as standardKatakanaValidator, ax as standardKanjiValidator, U as useAnalyticsContext, a as useTranslation, L as Loader } from "./StoreProvider-BWVRmzZI.js";
+import { c as useLegalEntity, R as ROOT_LE, X as useExperimentsContext, an as getCapabilityProblems, g as getLegalEntityCountry, N as createLogger, ao as businessDetailsApiKeyMapping, ap as individualApiKeyMapping, aq as remediationHasFileUploadField, ar as dataMissingRemediationsToFieldsMap, as as keysOf, b as useApiContext, at as hasText, au as isValidMinLength, av as matchesRegex, a7 as isEmpty, aw as NO_ALPHABET_REGEX, ax as EMOJI_REGEX, ay as hasRepeatedCharacters, az as isInvalidName, aA as OTHER_ENTITIES_VALID_CHAR_REGEX, aB as LATIN_SPACE_MARK_PUNCTUATION_REGEX, aC as standardKatakanaValidator, aD as standardKanjiValidator, U as useAnalyticsContext, a as useTranslation, L as Loader } from "./StoreProvider-CNMP4kya.js";
 import { useContext, useMemo, useRef, useState, useEffect } from "preact/hooks";
 import { jsx, jsxs, Fragment } from "preact/jsx-runtime";
 import { createContext } from "preact";
-import { a as Alert } from "./Alert-BuZyBPdN.js";
+import { a as Alert } from "./Alert-BD8qAZI-.js";
 import cx from "classnames";
-import { d as debouncedInputEvent } from "./analytics-oZidjUEi.js";
-import { c as convertFullToHalf } from "./InputText-1Il1vZcv.js";
+import { d as debouncedInputEvent } from "./analytics-CcmolsZA.js";
+import { c as convertFullToHalf } from "./InputText-BTZqEFXC.js";
 import { Suspense } from "preact/compat";
-import { b as useId } from "./useForm-BSzxrzKr.js";
-import { R as Radio } from "./CountryField-C_sYT__J.js";
+import { c as useId } from "./useForm-cpULl6pL.js";
+import { R as Radio } from "./CountryField-DmonPNZO.js";
 const useCapabilityProblems = () => {
   const { data: rootLegalEntity } = useLegalEntity(ROOT_LE);
   const { isExperimentEnabled } = useExperimentsContext();
@@ -32,6 +32,288 @@ const TrustedFieldsProviders = {
   SINGPASS: "singpass",
   KOMPANY: "kompany"
 };
+const linkedFieldsMap = {
+  "additionalInformation.vatNumber": [
+    "additionalInformation.exemptedFromVat",
+    "additionalInformation.vatAbsenceReason"
+  ]
+};
+function calculateLinkedRequiredFields({
+  field,
+  formId,
+  customRules,
+  scenarioConfiguration,
+  dataMissingErrors,
+  formFieldsWithExistingData
+}) {
+  const tldsField = makeTLDSFieldName(formId, field);
+  const isRootField = Boolean(linkedFieldsMap[tldsField]);
+  if (isRootField) {
+    const linkedFields = linkedFieldsMap[tldsField];
+    const fieldSettings = scenarioConfiguration?.[field];
+    const isFieldRequiredBySettings = fieldSettings && isFieldRequired(fieldSettings, customRules);
+    const isFieldPopulated = formFieldsWithExistingData?.includes(field);
+    const isFieldNeededToRemediateDataMissingError = isFieldRequiredToRemediateDataMissingError(
+      formId,
+      field,
+      dataMissingErrors
+    );
+    const areLinkedFieldsPopulated2 = linkedFields?.some((linkedField) => {
+      const linkedFieldKey = linkedField.split(".")[1];
+      const isLinkedFieldPopulated = formFieldsWithExistingData?.includes(linkedFieldKey);
+      return isLinkedFieldPopulated;
+    });
+    const isRootFieldRequired2 = isFieldRequiredBySettings || isFieldPopulated || isFieldNeededToRemediateDataMissingError || areLinkedFieldsPopulated2;
+    if (!isRootFieldRequired2) {
+      return {
+        isRequiredFromLinkedField: false,
+        isOptionalFromLinkedField: false
+      };
+    }
+    switch (field) {
+      case "vatNumber": {
+        const processedRule = customRules.countryUsesVat();
+        return {
+          isRequiredFromLinkedField: processedRule === "REQUIRED",
+          isOptionalFromLinkedField: processedRule === "OPTIONAL"
+        };
+      }
+    }
+  }
+  const rootLinkedField = Object.entries(linkedFieldsMap).find(
+    ([, linkedFields]) => linkedFields.includes(tldsField)
+  )?.[0];
+  if (!rootLinkedField)
+    return {
+      isRequiredFromLinkedField: false,
+      isOptionalFromLinkedField: false
+    };
+  const rootFieldKey = rootLinkedField.split(".")[1];
+  const rootFieldSettings = scenarioConfiguration?.[rootFieldKey];
+  const isRootFieldRequired = rootFieldSettings && isFieldRequired(rootFieldSettings, customRules);
+  const isRootFieldPopulated = formFieldsWithExistingData?.includes(rootFieldKey);
+  const areLinkedFieldsPopulated = linkedFieldsMap[rootLinkedField]?.some(
+    (linkedField) => {
+      const fieldKey = linkedField.split(".")[1];
+      return formFieldsWithExistingData?.includes(fieldKey);
+    }
+  );
+  const isRootFieldRequiredToRemediateDataMissingError = isFieldRequiredToRemediateDataMissingError(
+    formId,
+    rootFieldKey,
+    dataMissingErrors
+  );
+  const isRootLinkedFieldRequired = isRootFieldRequired || isRootFieldPopulated || areLinkedFieldsPopulated || isRootFieldRequiredToRemediateDataMissingError;
+  if (!isRootLinkedFieldRequired) {
+    return {
+      isRequiredFromLinkedField: false,
+      isOptionalFromLinkedField: false
+    };
+  }
+  switch (field) {
+    case "exemptedFromVat": {
+      const processedRule = customRules.isVatExempt();
+      return {
+        isRequiredFromLinkedField: processedRule === "REQUIRED",
+        isOptionalFromLinkedField: processedRule === "OPTIONAL"
+      };
+    }
+    case "vatAbsenceReason": {
+      const processedRule = customRules.isVatExempt();
+      return {
+        isRequiredFromLinkedField: processedRule === "REQUIRED",
+        isOptionalFromLinkedField: processedRule === "OPTIONAL"
+      };
+    }
+    default:
+      return {
+        isRequiredFromLinkedField: false,
+        isOptionalFromLinkedField: false
+      };
+  }
+}
+const logger$2 = createLogger();
+const composePerScenarioFormConfigurations = (scenarios = [], configurations) => scenarios.reduce(
+  (composedConfiguration, scenarioName) => ({
+    ...composedConfiguration,
+    ...configurations[scenarioName]
+  }),
+  {}
+);
+const augmentWithCountryConfigs = (countrySpecificConfig, baseFormConfig) => {
+  if (!countrySpecificConfig) return baseFormConfig;
+  return keysOf(countrySpecificConfig).reduce(
+    (mergedConfig, field) => ({
+      ...mergedConfig,
+      [field]: {
+        ...baseFormConfig[field],
+        ...countrySpecificConfig[field]
+      }
+    }),
+    baseFormConfig
+  );
+};
+const evaluateRules = (fieldSettings, customRules) => {
+  const ruleNames = [fieldSettings.rule, ...fieldSettings.rules ?? []].filter(
+    Boolean
+  );
+  const rules = ruleNames.map((ruleName) => {
+    switch (ruleName) {
+      case "REQUIRED":
+        return () => "REQUIRED";
+      case "OPTIONAL":
+        return () => "OPTIONAL";
+      default: {
+        const ruleFn = customRules[ruleName];
+        if (!ruleFn) {
+          logger$2.error(`Rule with name '${ruleName}' is not defined`);
+          return () => void 0;
+        }
+        return ruleFn;
+      }
+    }
+  });
+  return rules.map((rule) => rule());
+};
+const isFieldRequired = (fieldSettings, customRules) => {
+  return evaluateRules(fieldSettings, customRules).every((result) => result === "REQUIRED");
+};
+const isFieldOptional = (fieldSettings, customRules) => {
+  return evaluateRules(fieldSettings, customRules).every((result) => result === "OPTIONAL");
+};
+function getPropsFromConfigurations({
+  scenarioConfiguration,
+  forms,
+  remediationActions,
+  dataMissingErrors,
+  fieldsWithExistingData,
+  // TODO can type more strictly as `MappingKey<FormSchema>`
+  customRules,
+  legalEntityType,
+  legalEntityTrustedFields,
+  remediationFieldAsOptional = false
+}) {
+  const requiredFields = {};
+  const optionalFields = {};
+  const allFields = {};
+  const obscuredFields = {};
+  const trustedFields = {};
+  if (!scenarioConfiguration) {
+    return;
+  }
+  const readonly = ["legalFormDescription"];
+  const trustedFieldMappings = legalEntityTrustedFields?.reduce((acc, trusted) => {
+    switch (trusted.provider) {
+      case TrustedFieldsProviders.KOMPANY: {
+        if (legalEntityType === "organization") {
+          return [
+            ...acc,
+            ...trusted.fields.map(
+              (tf) => businessDetailsApiKeyMapping[tf]
+            )
+          ];
+        }
+        return acc;
+      }
+      case TrustedFieldsProviders.SINGPASS: {
+        if (legalEntityType === "organization") {
+          const orgFields = trusted.fields.filter(
+            (field) => field.split(".")[0] === "organization"
+          );
+          return [
+            ...acc,
+            ...orgFields.map(
+              (tf) => businessDetailsApiKeyMapping[tf]
+            )
+          ];
+        }
+        if (legalEntityType === "individual") {
+          const individualFields = trusted.fields.filter(
+            (field) => field.split(".")[0] === "individual"
+          );
+          return [
+            ...acc,
+            ...individualFields.map(
+              (tf) => individualApiKeyMapping[tf]
+            )
+          ];
+        }
+        return acc;
+      }
+      default:
+        return acc;
+    }
+  }, []);
+  Object.entries(forms).forEach(([_formId, formDetails]) => {
+    const formId = _formId;
+    const formFieldsWithExistingData = fieldsWithExistingData.filter((field) => field.startsWith(formId)).map((field) => field.slice(field.lastIndexOf(".") + 1));
+    if (trustedFieldMappings) {
+      trustedFields[formId] = getFormTrustedFields(formId, trustedFieldMappings);
+    }
+    formDetails.fields?.forEach((_field) => {
+      const field = _field;
+      const fieldSettings = scenarioConfiguration[field];
+      const isRequiredFromFieldConfig = fieldSettings && isFieldRequired(fieldSettings, customRules);
+      const isOptionalFromFieldConfig = fieldSettings && isFieldOptional(fieldSettings, customRules);
+      const isFieldRequiredByRemediationAction = showRemediationField(field, remediationActions);
+      const isFieldNeededToRemediateDataMissingError = isFieldRequiredToRemediateDataMissingError(
+        formId,
+        field,
+        dataMissingErrors
+      );
+      const isRequiredByRemediationAction = !remediationFieldAsOptional && isFieldRequiredByRemediationAction;
+      const isOptionalByRemediationAction = remediationFieldAsOptional && isFieldRequiredByRemediationAction;
+      const isRequiredFieldPopulated = !isOptionalFromFieldConfig && formFieldsWithExistingData.includes(field);
+      const { isRequiredFromLinkedField, isOptionalFromLinkedField } = calculateLinkedRequiredFields({
+        field,
+        formId,
+        customRules,
+        scenarioConfiguration,
+        dataMissingErrors,
+        formFieldsWithExistingData
+      });
+      const isRequired = (isRequiredFromFieldConfig || isRequiredByRemediationAction || isFieldNeededToRemediateDataMissingError || isRequiredFieldPopulated || isRequiredFromLinkedField) && !isOptionalFromLinkedField;
+      if (isRequired && !readonly.includes(field)) {
+        requiredFields[formId] = requiredFields[formId] ? [...requiredFields[formId], field] : [field];
+        allFields[formId] = allFields[formId] ? [...allFields[formId], field] : [field];
+      }
+      const isOptional = !isRequired && (isOptionalFromFieldConfig || isOptionalByRemediationAction || isOptionalFromLinkedField);
+      if (isOptional) {
+        optionalFields[formId] = optionalFields[formId] ? [...optionalFields[formId], field] : [field];
+        allFields[formId] = allFields[formId] ? [...allFields[formId], field] : [field];
+      }
+      if (fieldSettings?.obscured) {
+        obscuredFields[formId] = obscuredFields[formId] ? [...obscuredFields[formId], field] : [field];
+      }
+    });
+  });
+  return {
+    requiredFields,
+    optionalFields,
+    allFields,
+    obscuredFields,
+    trustedFields
+  };
+}
+const showRemediationField = (field, remediationActions) => remediationActions.some(
+  (rem) => rem.fields?.includes(field) && remediationHasFileUploadField(rem)
+);
+const makeTLDSFieldName = (formId, fieldName) => {
+  if (fieldName === "proofOfOrganizationTaxInfo") {
+    return `${formId}.taxDocument`;
+  }
+  return `${formId}.${fieldName}`;
+};
+const isFieldRequiredToRemediateDataMissingError = (formId, field, dataMissingErrors) => {
+  const dataMissingRemediations = dataMissingErrors.flatMap((error) => error.remediatingActions).filter(
+    (remediatingAction) => !!remediatingAction && remediatingAction.code in dataMissingRemediationsToFieldsMap
+  );
+  const missingFields = dataMissingRemediations.flatMap((remediatingAction) => dataMissingRemediationsToFieldsMap[remediatingAction.code]).filter((missingField) => Boolean(missingField)).map((missingField) => makeTLDSFieldName(formId, missingField));
+  return missingFields.includes(makeTLDSFieldName(formId, field));
+};
+const getFormTrustedFields = (formId, trustedFields) => trustedFields.filter((field) => field.split(".")[0] === formId).map(
+  (field) => field.split(".").filter((item) => formId !== item).join(".")
+);
 const IgnoreLocalStorageContext = createContext(false);
 const useIgnoreLocalStorage = () => useContext(IgnoreLocalStorageContext);
 const logger$1 = createLogger();
@@ -429,6 +711,7 @@ const RadioGroupCard = ({
     optionId(option)
   )) });
 };
+const createFormRules = (rules) => rules;
 const resolveFieldMetadata = (countryEntry, params, defaultMetadata) => {
   if (typeof countryEntry === "object") {
     return countryEntry;
@@ -445,13 +728,17 @@ export {
   TextArea as T,
   useAccountHolder as a,
   useCapabilityProblems as b,
-  validateNotEmptyOnBlur as c,
-  validateLatinSpaceMarkPunctuationOnlyOnBlur as d,
-  TrustedFieldsProviders as e,
-  validatePatternOnBlur as f,
+  createFormRules as c,
+  getPropsFromConfigurations as d,
+  validateNotEmptyOnBlur as e,
+  validateLatinSpaceMarkPunctuationOnlyOnBlur as f,
   getProblemsForEntity as g,
-  validateJaKanaLegalCompanyName as h,
-  validateJaHaniLegalCompanyName as i,
+  TrustedFieldsProviders as h,
+  validatePatternOnBlur as i,
+  composePerScenarioFormConfigurations as j,
+  augmentWithCountryConfigs as k,
+  validateJaKanaLegalCompanyName as l,
+  validateJaHaniLegalCompanyName as m,
   resolveFieldMetadata as r,
   useLocalStorage as u,
   validateLegalCompanyName as v

package/dist/{fr-FR-Cv0k-3Xc.js → fr-FR-B3qQW3oG.js}

@@ -2,7 +2,7 @@
 {
   try {
     let e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
-    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "2b4ba72c-f5e9-40e5-865d-c259bda6512f", e._sentryDebugIdIdentifier = "sentry-dbid-2b4ba72c-f5e9-40e5-865d-c259bda6512f");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "9ed4dd71-05a5-4d1e-8f8e-a07b3487c0e0", e._sentryDebugIdIdentifier = "sentry-dbid-9ed4dd71-05a5-4d1e-8f8e-a07b3487c0e0");
   } catch (e) {
   }
 }
@@ -18,6 +18,8 @@ const frFR = {
   pleaseEnterValidAccountDetails: "Veuillez saisir des informations de compte valides",
   pleaseEnterValidField: "Veuillez saisir des valeurs valides : %{fieldNames}",
   selectTheBankToReceivePayouts: "Après cette page, vous pourrez sélectionner la banque auprès de laquelle vous souhaitez recevoir les reversements.",
+  theBankAccountHolderMustBeInYourName: "Le compte bancaire doit être à votre nom : <strong>%{name}</strong>",
+  theBankAccountHolderMustHaveTheSameNameAsYourCompany: "Le titulaire du compte bancaire doit avoir le même nom que votre société <strong>%{companyName}</strong>.",
   thisAccountWillBeVerifiedToPrevent: "Ce compte bancaire sera vérifié pour prévenir la fraude ou toute autre utilisation abusive des fonds conformément aux réglementations mondiales.",
   toContinuePleaseChooseAVerificationMethod: "Pour continuer, veuillez choisir une méthode de vérification et réessayez.",
   toHelpVerifyYourBankDetailsBusiness: "Pour vérifier vos coordonnées bancaires, nous avons besoin d'un relevé bancaire indiquant clairement le nom de votre société et daté de moins de 12 mois.",

package/dist/fr-FR-BZbWBKOT.js

@@ -0,0 +1,13 @@
+;
+{
+  try {
+    let e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "4d32304f-d355-407a-be37-47cfc5566d77", e._sentryDebugIdIdentifier = "sentry-dbid-4d32304f-d355-407a-be37-47cfc5566d77");
+  } catch (e) {
+  }
+}
+;
+const frFR = /* @__PURE__ */ JSON.parse(`{"addDetailsManuallyQuestion":"Ajouter des informations manuellement ?","adyenKeepsDataAsLongAsLegallyRequired":"Adyen ne conserve pas vos données au-delà de la période exigée par la loi. Les données ne seront pas utilisées à d'autres fins ou par d'autres tiers que celles et ceux énoncé(e)s.","aNomineeDirectorIsAppointed":"Un directeur désigné est nommé pour défendre les intérêts d'un tiers.","aNomineeShareholderHoldsShares":"Un actionnaire désigné détient des actions pour le compte d'un tiers.","backPage":"Verso","becauseThisPersonIsUnderXYearsOld":"Comme cette personne a moins de %{age} ans, les informations concernant un représentant légal seront collectées à une étape ultérieure.","beneficialOwner":"Bénéficiaire effectif","byContinuingToUseThisService":"En continuant à utiliser ce service, vous acceptez avoir lu, compris et accepté","byProceedingToTheNextStepYouConfirmThatYouHaveReadUnderstandAndAcceptTheTerms":"En passant à l'étape suivante, vous confirmez que vous avez lu, compris et accepté la <el1>Politique de confidentialité d'Onfido</el1> et les <el2>Conditions d'utilisation d'Onfido</el2>.","controllingPersonDescriptionA1L1":"<strong>Cadres supérieurs :</strong> par exemple, un PDG, un directeur financier, un directeur commercial ou un rôle similaire avec une influence significative.","controllingPersonDescriptionA1L2":"<strong>Décisionnaires importants :</strong> l'individu est responsable d'une série de décisions cruciales, allant des opérations quotidiennes à la direction des fusions et acquisitions.","controllingPersonDescriptionA1L3":"<strong>Personne ayant autorité sur les nominations :</strong> l'individu peut nommer ou retirer des cadres supérieurs avec ou sans le soutien d'un Conseil d'administration.","controllingPersonDescriptionA1L4":"<strong>Personne ayant un autre contrôle significatif :</strong> l'individu peut exercer d'autres formes de contrôle significatif ou a une responsabilité substantielle dans l'orientation stratégique de l'entreprise.","controllingPersonDescriptionA1P1":"Une personne détenant le contrôle est une personne qui a un contrôle exécutif ou important sur les activités d’une entreprise. Le « contrôle significatif » est défini de manière large dans la législation juridique et de conformité, mais couvre généralement quatre types de rôles :","controllingPersonDescriptionA2":"Oui, une « personne détenant le contrôle » est un type de bénéficiaire effectif (UBO).","controllingPersonDescriptionAlertContent":"La propriété par le contrôle signifie quelque chose de différent pour chaque entreprise. Si vous n'êtes pas sûr, ajoutez plus de personnes plutôt que de les ignorer pour éviter des problèmes plus tard.","controllingPersonDescriptionQ1":"Qu’est-ce que la propriété par le contrôle ?","controllingPersonDescriptionQ2":"Une personne qui détient le contrôle par la propriété est-elle un bénéficiaire effectif ?","controllingPersonGuideDescription":"Une <strong>personne exerçant un contrôle</strong> est une personne autorisée à prendre des décisions importantes concernant l'entreprise. Cette personne peut être propriétaire ou non.","controllingPersonSummaryLabel":"Dispose d'une autorité significative pour contrôler l'orientation stratégique de l'entreprise.","deleteIdDocument":"Supprimer la pièce d'identité ?","directorDescription":"Une personne désignée pour gérer les activités et les affaires d'une entreprise","directorDescriptionA1":"Un administrateur est une personne physique nommée pour gérer les affaires d'une entreprise. En tant que groupe, un conseil d'administration est responsable de la gouvernance et de la surveillance globales de l'entreprise.","directorDescriptionA2":"Oui, une entreprise peut avoir plusieurs administrateurs. C’est plus courant pour les grandes entreprises lorsqu’elles sont structurées avec un conseil d’administration.","directorDescriptionQ1":"Qu'est-ce qu'un directeur ?","directorDescriptionQ2":"Une entreprise peut-elle avoir plusieurs directeurs ?","directorGuideDescription":"Un <strong>directeur</strong> est une personne désignée pour gérer les activités et les affaires d'une entreprise. Vous trouverez la liste de vos directeurs dans le registre des sociétés.","directorSummaryLabel":"A été nommé pour superviser la direction stratégique de l'entreprise.","documentNotExpiredOrDamaged":"Le document doit être en cours de validité et ne doit pas être endommagé","documentVerification":"Vérification du document","doesThisPersonHaveSignificantResponsibility":"Cette personne a-t-elle une responsabilité importante en matière de contrôle, de gestion ou de direction des opérations commerciales ?","doesThisPersonHaveTheAuthority":"Cette personne a-t-elle l'autorité de signer des contrats et d'autres documents officiels au nom de l'entreprise ?","doesThisPersonOwn25PercentOrMoreOfBusiness":"Cette personne détient-elle 25 % ou plus de l'entreprise, que ce soit directement ou indirectement ?","frontPage":"Recto","fullDocumentVisible":"Le document complet doit être visible et tout le texte doit être lisible","howVerificationWithOnfidoWork":"Comment fonctionne la vérification avec notre partenaire Onfido ?","idNowDescription":"Pour éviter la fraude et assurer la sécurité de nos services, nous devons vérifier votre identité au moyen d'un bref entretien en direct.","idNowDescriptionName":"Seul %{name} peut effectuer ce processus.","imagesInColor":"Les images doivent être en couleur","includeFrontAndBack":"Inclure le recto et le verso, chacun dans un fichier séparé","isThisPersonANomineeDirectorAppointed":"Cette personne est-elle un administrateur désigné nommé pour défendre les intérêts d'un tiers ?","isThisPersonANomineeShareholderAppointedToHold":"Cette personne est-elle un actionnaire désigné nommé pour détenir des actions pour le compte d'un tiers ?","isThisPersonListedAsADirector":"Cette personne est-elle mentionnée en qualité de directrice/directeur sur des documents juridiques ou autres documents officiels ?","itCanTakeUpTo":"La vérification des informations personnelles ajoutées manuellement peut prendre jusqu'à trois jours ouvrables supplémentaires.","legalRepresentativeDetails":"Coordonnées du représentant légal","legalRepresentativeForMinorIsRequired":"Un représentant légal pour mineur est nécessaire","madeAMistake":"Vous avez fait une erreur ?","moreAboutDirectors":"En savoir plus sur les directeurs","moreAboutOwners":"En savoir plus sur les propriétaires","moreAboutOwnershipThroughControl":"En savoir plus sur la propriété par le contrôle","onfidoFacialScanPolicy":"la Politique d'Onfido relative au scan facial et à l'enregistrement vocal,","onfidoIsOurTrustedPartner":"Notre partenaire Onfido accélère la configuration de votre compte en vérifiant votre identité en temps réel.  ","onfidoWillGiveFeedbackInRealTime":"Onfido vous tiendra informé en temps réel","ownerGuideDescription":"Un <strong>propriétaire</strong> est une personne qui détient au moins 25 % de la société, par le biais de droits de vote, de capitaux propres ou similaire.","ownersAndDecisionMakers":"Propriétaires et décideurs","ownersAndDecisionMakersDescription":"Nous devons collecter des informations sur au moins un représentant de l'entreprise ainsi que sur tous ses propriétaires. Nous collectons ces informations pour nous conformer aux réglementations financières internationales.","ownersAndDecisionMakersDescriptionA1":"En tant que prestataire de paiements, nous devons nous assurer que nos services ne sont pas utilisés pour commettre des crimes financiers, tels que le blanchiment d'argent, le financement du terrorisme ou toute autre forme de fraude. Les processus de connaissance du client (KYC) et de connaissance de l'entreprise (KYB) nous permettent d'identifier et d'atténuer les actions risquées ou illégales, ce qui contribue à maintenir un système financier mondial sûr et conforme.","ownersAndDecisionMakersDescriptionA2P1":"Nous devons collecter et valider des informations sur les individus qui détiennent au moins 25 % de l'entreprise (directement ou indirectement) et sur tous les individus considérés comme propriétaires grâce à un contrôle significatif de l'entreprise.","ownersAndDecisionMakersDescriptionA2P2":"Selon la structure de propriété de l'entreprise, il peut s'agir de tous les propriétaires ou seulement de certains d'entre eux. Si vous n'êtes pas sûr, ajoutez d'autres personnes plutôt que de les ignorer afin d'éviter des problèmes plus tard.","ownersAndDecisionMakersDescriptionA3":"« Décideur » est le terme que nous utilisons pour décrire les individus qui peuvent ou non être propriétaires, mais qui ont une responsabilité importante dans l'orientation stratégique de l'entreprise.","ownersAndDecisionMakersDescriptionA4":"Vous pouvez toujours sauvegarder votre progression et revenir plus tard. Il ne sera pas possible d’accéder aux services de paiements en cours de traitement tant que toutes les informations sur le propriétaire et le décisionnaire n’auront pas été recueillies et validées.","ownersAndDecisionMakersDescriptionAlertContent":"Nous devons en savoir plus sur les propriétaires et les décideurs de votre entreprise pour nous conformer aux réglementations financières mondiales.","ownersAndDecisionMakersDescriptionQ1":"Pourquoi collectez-vous ces informations ?","ownersAndDecisionMakersDescriptionQ2":"Dois-je fournir des informations sur chaque propriétaire ?","ownersAndDecisionMakersDescriptionQ3":"Qu'est-ce qu'un décideur ?","ownersAndDecisionMakersDescriptionQ4":"Je n'ai pas accès aux informations personnelles de quelqu'un en ce moment. Que dois-je faire ?","ownersDescriptionA1P1":"Les propriétaires directs sont des individus qui possèdent des actions ou des intérêts dans l'entreprise directement en leur nom.","ownersDescriptionA1P2":"Les propriétaires indirects détiennent des actions ou des intérêts dans l'entreprise par l'intermédiaire d'une autre société ou entité, souvent une société holding ou une fiducie.","ownersDescriptionA2P1":"Nous devons collecter et valider des informations sur les individus qui détiennent au moins 25 % de l'entreprise (directement ou indirectement) et sur tous les individus considérés comme propriétaires grâce à un contrôle significatif de l'entreprise.","ownersDescriptionA2P2":"Selon la structure de propriété de l'entreprise, il peut s'agir de tous les propriétaires ou seulement de certains d'entre eux. Si vous n’êtes pas sûr, ajoutez d’autres personnes plutôt que de les ignorer pour limiter les problèmes plus tard.","ownersDescriptionA3":"Pour nous conformer aux exigences réglementaires mondiales, nous devons mettre en œuvre un processus de diligence raisonnable afin de prévenir le blanchiment d'argent, le financement du terrorisme et de détecter les violations des sanctions. Pour nous assurer que nos services sont utilisés en toute sécurité, nous devons collecter et valider des informations sur tous les bénéficiaires effectifs (UBO) de cette entreprise.","ownersDescriptionA4":"Un bénéficiaire effectif (UBO) est la personne physique qui, en dernier ressort, contrôle une entité juridique. Un UBO doit être une personne physique et ne peut pas être une fiducie, une société holding ou une autre entité juridique.","ownersDescriptionAlertContent":"Nous devons connaître toutes les personnes physiques qui possèdent au moins 25 % de l'entreprise, que ce soit directement ou indirectement.","ownersDescriptionAlertTitle":"En termes plus simples","ownersDescriptionQ1":"Quelle est la différence entre la propriété directe et la propriété indirecte ?","ownersDescriptionQ2":"Quels propriétaires dois-je vous signaler ?","ownersDescriptionQ3":"Pourquoi avez-vous besoin de connaître les propriétaires directs et indirects ?","ownersDescriptionQ4":"Qu'est-ce qu'un bénéficiaire effectif ultime ?","ownerSummaryLabel":"Détient au moins 25 % de l'entreprise directement ou indirectement.","personalDetails":"Informations personnelles","personalIdentityDetails":"Informations personnelles d'identité","providePageWithPhotoAndCode":"Fournissez la page avec la photo, y compris le code en bas","providePersonalAddress":"Renseigner votre adresse personnelle","signatory":"Signataire","signatoryGuideDescription":"Un <strong>signataire</strong> a été autorisé à signer des documents officiels au nom de l'entreprise. En règle générale, un signataire est également un propriétaire ou une personne exerçant un contrôle.","submitIdDocumentsAgain":"Envoyer à nouveau les pièces d'identité","theIdCheckWillBeAutomaticallyValidated":"Si l'image est bonne, la vérification de la pièce d'identité sera automatique","thisPersonsPrimaryAddress":"L'adresse principale de cette personne, généralement utilisée pour les opérations bancaires personnelles et les services publics.","toHelpProtectAgainstFraudAndKeepOurServices":"Pour éviter la fraude et assurer la sécurité de nos services, nous vérifierons votre identité en comparant votre pièce d'identité avec votre selfie.","usePhoneToScanId":"Utilisez votre téléphone pour prendre une photo de la pièce d'identité","verifyIndividualIdentity":"Vérifier l'identité de %{name}","weHaveToMakeSureThatEveryone":"Nous devons nous assurer que l'identité de toutes les personnes qui ont recours à nos services est vérifiée. Pour ce faire, nous comparerons toutes ces informations à celles figurant dans des documents officiels. Cette procédure fait partie de la réglementation financière que nous devons suivre en tant que fournisseur de services de paiement.","weOnlyUseTheseDetailsForIdentityVerification":"Nous utilisons ces informations uniquement pour la vérification d'identité. Découvrez comment vos données sont gérées dans notre","yesAddManually":"Oui, ajouter manuellement","youHaveSuccessfullyProvidedTheIdDocument":"Vous avez bien fourni la pièce d'identité.","youMayBeAskedToReUpload":"Il se peut que l'on vous demande d'importer à nouveau une autre pièce d'identité à l'avenir."}`);
+export {
+  frFR as default
+};

package/dist/fr-FR-BxO1IR9C.js

@@ -0,0 +1,45 @@
+;
+{
+  try {
+    let e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "db532783-e265-46bf-9f29-13d3467bd346", e._sentryDebugIdIdentifier = "sentry-dbid-db532783-e265-46bf-9f29-13d3467bd346");
+  } catch (e) {
+  }
+}
+;
+const frFR = {
+  andResubmit: "et envoyez-les à nouveau.",
+  browseFiles: "Parcourir les fichiers",
+  cancel: "Annuler",
+  close: "Fermer",
+  confirm: "Confirmer",
+  dropFilesToUpload: "Déposez les fichiers à importer",
+  dropFileToUpload: "Déposez le fichier à importer",
+  fieldHasUnsupportedFormats: "Le format de %{fieldName} n'est pas pris en charge.",
+  fieldIsRequired: "Champ obligatoire",
+  formatIsCorrect: "Le format est correct",
+  good: "Correct",
+  informationCouldNotBeSubmitted: "Impossible d'envoyer les informations",
+  loading: "Chargement",
+  maxFileSize: "Taille maximale du fichier : %{maxSize}. Maximum 1 page.",
+  maxFileSizeOnly: "Taille maximale du fichier : %{maxSize}.",
+  noGlare: "Pas de reflet",
+  noOptionsFound: "Aucune option trouvée",
+  notBlurry: "Pas flou",
+  notCutOff: "Entier, non coupé",
+  notExpired: "En cours de validité",
+  remove: "Supprimer",
+  someFieldsHaveUnsupportedFormatedUpdateInfoAndResubmit: "Le format de certains champs n'est pas pris en charge. Mettez à jour les informations et envoyez-les à nouveau.",
+  supportedFileTypes: "Types de fichiers pris en charge : %{fileTypes}",
+  taskComplete: "Tâche terminée",
+  taskHasErrors: "La tâche contient des erreurs",
+  taskInProgress: "Tâche en cours",
+  undoWithTimer: "Annuler... %{secondsLeft}",
+  updateTheInformation: "Mettez à jour les informations",
+  upToFiles: "Jusqu'à %{maxFiles} fichier(s).",
+  xCharactersLeft: "%{charactersLeft} caractères restants",
+  XOfYSteps: "%{currentStep} sur %{totalSteps} "
+};
+export {
+  frFR as default
+};