@proconnect-gouv/proconnect.identite 1.0.0 → 1.2.0

package/src/managers/certification/is-organization-dirigeant.ts

@@ -1,136 +1,162 @@
 //
 
-import { NotFoundError } from "#src/errors";
-import { fromInfogreffe } from "#src/mappers/certification";
-import { fromSiret } from "#src/mappers/organization";
+import { InvalidCertificationError, NotFoundError } from "#src/errors";
 import type { GetFranceConnectUserInfoHandler } from "#src/repositories/user";
-import { isEntrepriseUnipersonnelle } from "#src/services/organization";
-import type { IdentityVector } from "#src/types";
-import type {
-  EntrepriseApiInfogreffeRepository,
-  EntrepriseApiInseeRepository,
-} from "@proconnect-gouv/proconnect.entreprise/api";
-import type { InseeSireneEstablishmentSiretResponseData } from "@proconnect-gouv/proconnect.entreprise/types";
-import type { InseeApiRepository } from "@proconnect-gouv/proconnect.insee/api";
-import { formatBirthdate } from "@proconnect-gouv/proconnect.insee/formatters";
-import { distance } from "./distance.js";
+import type { IdentityVector, Organization } from "#src/types";
+import type { ApiEntrepriseInfogreffeRepository } from "@proconnect-gouv/proconnect.api_entreprise/api";
+import type { FindUniteLegaleBySirenHandler } from "@proconnect-gouv/proconnect.insee/api";
+import type { FindPouvoirsBySirenHandler } from "@proconnect-gouv/proconnect.registre_national_entreprises/api";
+import { match } from "ts-pattern";
+import z from "zod/v4";
+import * as ApiEntreprise from "./adapters/api_entreprise.js";
+import * as FranceConnect from "./adapters/franceconnect.js";
+import * as INSEE from "./adapters/insee.js";
+import * as RNE from "./adapters/rne.js";
+import { certificationScore } from "./certification-score.js";
 
 //
 
 type IsOrganizationExecutiveFactoryFactoryConfig = {
-  EntrepriseApiInfogreffeRepository: EntrepriseApiInfogreffeRepository;
-  EntrepriseApiInseeRepository: Pick<
-    EntrepriseApiInseeRepository,
-    "findBySiret"
+  ApiEntrepriseInfogreffeRepository: Pick<
+    ApiEntrepriseInfogreffeRepository,
+    "findMandatairesSociauxBySiren"
   >;
   EQUALITY_THRESHOLD?: number;
-  getFranceConnectUserInfo: GetFranceConnectUserInfoHandler;
-  InseeApiRepository: Pick<InseeApiRepository, "findBySiret">;
-  log?: typeof console.log;
+  FranceConnectApiRepository: {
+    getFranceConnectUserInfo: GetFranceConnectUserInfoHandler;
+  };
+  InseeApiRepository: { findBySiren: FindUniteLegaleBySirenHandler };
+  RegistreNationalEntreprisesApiRepository: {
+    findPouvoirsBySiren: FindPouvoirsBySirenHandler;
+  };
 };
 
 //
 
+async function getMandatairesSociaux(
+  {
+    RegistreNationalEntreprisesApiRepository,
+    ApiEntrepriseInfogreffeRepository,
+  }: IsOrganizationExecutiveFactoryFactoryConfig,
+  siren: string,
+) {
+  try {
+    const pouvoirs =
+      await RegistreNationalEntreprisesApiRepository.findPouvoirsBySiren(siren);
+    const dirigeants = pouvoirs.map(RNE.toIdentityVector);
+
+    return {
+      dirigeants,
+      source: SourceDirigeant.enum["registre-national-entreprises.inpi.fr/api"],
+    };
+  } catch {
+    const mandataires =
+      await ApiEntrepriseInfogreffeRepository.findMandatairesSociauxBySiren(
+        siren,
+      );
+    const dirigeants = mandataires.map(ApiEntreprise.toIdentityVector);
+
+    return {
+      dirigeants,
+      source:
+        SourceDirigeant.enum[
+          "entreprise.api.gouv.fr/v3/infogreffe/rcs/unites_legales/{siren}/mandataires_sociaux"
+        ],
+    };
+  }
+}
+
 export function isOrganizationDirigeantFactory(
   config: IsOrganizationExecutiveFactoryFactoryConfig,
 ) {
-  const {
-    EQUALITY_THRESHOLD = 0,
-    EntrepriseApiInseeRepository,
-    EntrepriseApiInfogreffeRepository,
-    InseeApiRepository,
-    getFranceConnectUserInfo,
-    log = () => {},
-  } = config;
+  const { InseeApiRepository, FranceConnectApiRepository } = config;
 
   return async function isOrganizationDirigeant(
-    siret: string,
+    organization: Organization,
     user_id: number,
   ) {
-    const establishment = await EntrepriseApiInseeRepository.findBySiret(siret);
-    const franceconnectUserInfo = await getFranceConnectUserInfo(user_id);
+    const siren = organization.siret.substring(0, 9);
+    const franceconnectUserInfo =
+      await FranceConnectApiRepository.getFranceConnectUserInfo(user_id);
     if (!franceconnectUserInfo) {
       throw new NotFoundError("FranceConnect UserInfo not found");
     }
 
-    const sourceDirigeants =
-      await getSourceDirigeantsFromEstablishment(establishment);
-
-    if (sourceDirigeants.length === 0) {
-      throw new NotFoundError("No mandataires found");
-    }
-
-    const distances = sourceDirigeants.map((sourceDirigeant) =>
-      Math.abs(distance(franceconnectUserInfo, sourceDirigeant)),
-    );
-
-    const closestSourceDirigeantDistance = Math.min(...distances);
-    const closestSourceDirigeant =
-      sourceDirigeants[distances.indexOf(closestSourceDirigeantDistance)];
-
-    log(
-      closestSourceDirigeant,
-      " is the closest source dirigeant to ",
-      franceconnectUserInfo,
-      " with a distance of ",
-      closestSourceDirigeantDistance,
-    );
-
-    return closestSourceDirigeantDistance === EQUALITY_THRESHOLD;
+    const identity = FranceConnect.toIdentityVector(franceconnectUserInfo);
+
+    const prefered_source =
+      organization.cached_libelle_categorie_juridique ===
+      "Entrepreneur individuel"
+        ? SourceDirigeant.enum["api.insee.fr/api-sirene/private"]
+        : SourceDirigeant.enum["registre-national-entreprises.inpi.fr/api"];
+
+    const { dirigeants, source } = await match(prefered_source)
+      .with("api.insee.fr/api-sirene/private", async () => ({
+        dirigeants: await InseeApiRepository.findBySiren(siren)
+          .then(INSEE.toIdentityVector)
+          .then((vector) => [vector]),
+        source: SourceDirigeant.enum["api.insee.fr/api-sirene/private"],
+      }))
+      .with("registre-national-entreprises.inpi.fr/api", () =>
+        getMandatairesSociaux(config, siren),
+      )
+      .exhaustive();
+
+    const result = match_identity_to_dirigeant(identity, dirigeants);
+
+    if (result.kind === "no_candidates")
+      throw new InvalidCertificationError("No candidates found");
+    return {
+      details: {
+        ...result.closest,
+        identity,
+        source,
+      },
+      cause: result.kind,
+      ok: result.kind === "exact_match",
+    };
   };
-
-  async function getSourceDirigeantsFromEstablishment(
-    establishment: InseeSireneEstablishmentSiretResponseData,
-  ): Promise<IdentityVector[]> {
-    const organization = fromSiret(establishment);
-
-    if (
-      isEntrepriseUnipersonnelle({
-        cached_libelle_categorie_juridique:
-          organization.libelleCategorieJuridique,
-        cached_tranche_effectifs: organization.trancheEffectifs,
-      })
-    ) {
-      return getSourceDirigeantsFromInsseApi(establishment.siret);
-    }
-    return getSourceDirigeantsFromEntrepriseApi(
-      establishment.unite_legale.siren,
-    );
-  }
-
-  async function getSourceDirigeantsFromInsseApi(siret: string) {
-    const { uniteLegale } = await InseeApiRepository.findBySiret(siret);
-    const birthdate = formatBirthdate(
-      String(uniteLegale?.dateNaissanceUniteLegale),
-    );
-
-    return [
-      {
-        birthplace: uniteLegale?.codeCommuneNaissanceUniteLegale ?? null,
-        birthdate: isNaN(birthdate.getTime()) ? null : birthdate,
-        family_name: uniteLegale?.nomUniteLegale ?? null,
-        given_name: [
-          uniteLegale?.prenom1UniteLegale,
-          uniteLegale?.prenom2UniteLegale,
-          uniteLegale?.prenom3UniteLegale,
-          uniteLegale?.prenom4UniteLegale,
-        ]
-          .filter(Boolean)
-          .join(" "),
-      } satisfies IdentityVector,
-    ];
-  }
-
-  async function getSourceDirigeantsFromEntrepriseApi(siren: string) {
-    const mandataires =
-      await EntrepriseApiInfogreffeRepository.findMandatairesSociauxBySiren(
-        siren,
-      );
-
-    return mandataires.map((mandataire) => fromInfogreffe(mandataire));
-  }
 }
 
 export type IsOrganizationDirigeantHandler = ReturnType<
   typeof isOrganizationDirigeantFactory
 >;
+
+const SourceDirigeant = z.enum([
+  "api.insee.fr/api-sirene/private",
+  "entreprise.api.gouv.fr/v3/infogreffe/rcs/unites_legales/{siren}/mandataires_sociaux",
+  "registre-national-entreprises.inpi.fr/api",
+]);
+
+function match_identity_to_dirigeant(
+  identity: IdentityVector,
+  dirigeants: IdentityVector[],
+) {
+  if (dirigeants.length === 0) return { kind: "no_candidates" as const };
+
+  const [closest] = dirigeants
+    .map((dirigeant) => ({
+      dirigeant,
+      score: certificationScore(identity, dirigeant),
+    }))
+    .toSorted((a, b) => b.score - a.score); // Sort by score descending (higher is better)
+
+  // According to the specification, only score of 5 (perfect match) is certified
+  return match(closest.score)
+    .with(5, () => ({
+      kind: "exact_match" as const,
+      closest,
+    }))
+    .with(4, () => ({
+      kind: "close_match" as const,
+      closest,
+    }))
+    .with(3, () => ({
+      kind: "close_match" as const,
+      closest,
+    }))
+    .otherwise(() => ({
+      kind: "below_threshold" as const,
+      closest,
+    }));
+}

package/src/managers/certification/normalize.test.ts

@@ -0,0 +1,71 @@
+//
+
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { extractFirstName, normalizeText } from "./normalize.js";
+
+//
+
+describe("normalizeText", () => {
+  it("converts to uppercase", () => {
+    assert.equal(normalizeText("bernard"), "BERNARD");
+  });
+
+  it("removes accents and cedillas", () => {
+    assert.equal(normalizeText("José"), "JOSE");
+    assert.equal(normalizeText("François"), "FRANCOIS");
+    assert.equal(normalizeText("Hélène"), "HELENE");
+  });
+
+  it("replaces special characters with spaces", () => {
+    assert.equal(normalizeText("Jean-Pierre"), "JEAN PIERRE");
+    assert.equal(normalizeText("O'Connor"), "O CONNOR");
+    assert.equal(normalizeText("Marie.Anne"), "MARIE ANNE");
+  });
+
+  it("removes multiple spaces", () => {
+    assert.equal(normalizeText("Jean   Pierre"), "JEAN PIERRE");
+  });
+
+  it("trims leading and trailing spaces", () => {
+    assert.equal(normalizeText("  Jean  "), "JEAN");
+  });
+
+  it("handles null and undefined", () => {
+    assert.equal(normalizeText(null), "");
+    assert.equal(normalizeText(undefined), "");
+  });
+
+  it("handles complex names", () => {
+    assert.equal(
+      normalizeText("Marie-Thérèse D'Aubigné"),
+      "MARIE THERESE D AUBIGNE",
+    );
+  });
+
+  it("handles ligatures", () => {
+    assert.equal(normalizeText("Œuvre"), "OEUVRE");
+    assert.equal(normalizeText("Cæsar"), "CAESAR");
+  });
+});
+
+describe("extractFirstName", () => {
+  it("extracts first name before space", () => {
+    assert.equal(extractFirstName("Jean Pierre"), "JEAN");
+    assert.equal(extractFirstName("Marie Thérèse Anne"), "MARIE");
+  });
+
+  it("normalizes before extracting", () => {
+    assert.equal(extractFirstName("Jean-Pierre"), "JEAN");
+    assert.equal(extractFirstName("Marie-Thérèse"), "MARIE");
+  });
+
+  it("handles single name", () => {
+    assert.equal(extractFirstName("Jean"), "JEAN");
+  });
+
+  it("handles null and undefined", () => {
+    assert.equal(extractFirstName(null), "");
+    assert.equal(extractFirstName(undefined), "");
+  });
+});

package/src/managers/certification/normalize.ts

@@ -0,0 +1,72 @@
+//
+
+/**
+ * Normalizes text for identity matching:
+ * - Convert to uppercase
+ * - Replace accented characters with their simple versions
+ * - Replace special characters (including ' and -) with spaces
+ * - Remove multiple consecutive spaces
+ * - Trim leading and trailing spaces
+ *
+ * @param text - The text to normalize
+ * @returns The normalized text
+ */
+export function normalizeText(text: string | null | undefined): string {
+  if (!text) return "";
+
+  // Convert to uppercase
+  let normalized = text.toUpperCase();
+
+  // Replace accented characters with their simple versions
+  const accentMap: Record<string, string> = {
+    À: "A",
+    Â: "A",
+    Ä: "A",
+    Ç: "C",
+    É: "E",
+    È: "E",
+    Ê: "E",
+    Ë: "E",
+    Î: "I",
+    Ï: "I",
+    Ô: "O",
+    Ö: "O",
+    Ù: "U",
+    Û: "U",
+    Ü: "U",
+    Ÿ: "Y",
+    Æ: "AE",
+    Œ: "OE",
+  };
+
+  for (const [accented, simple] of Object.entries(accentMap)) {
+    normalized = normalized.replaceAll(accented, simple);
+  }
+
+  // Replace special characters (including ' and -) with spaces
+  // Keep only letters, digits, and spaces
+  normalized = normalized.replace(/[^A-Z0-9 ]/g, " ");
+
+  // Remove multiple consecutive spaces
+  normalized = normalized.replace(/\s+/g, " ");
+
+  // Trim leading and trailing spaces
+  normalized = normalized.trim();
+
+  return normalized;
+}
+
+/**
+ * Extracts the first name from a normalized full name string.
+ * The first name is the part before the first space.
+ *
+ * @param givenName - The full given name (may contain multiple names)
+ * @returns The first name only
+ */
+export function extractFirstName(givenName: string | null | undefined): string {
+  if (!givenName) return "";
+
+  const normalized = normalizeText(givenName);
+  const parts = normalized.split(" ");
+  return parts[0] || "";
+}

package/src/managers/organization/adapters/api_entreprise.test.ts

@@ -0,0 +1,31 @@
+//
+
+import {
+  AppleEuropeInc,
+  MaireClamart,
+  Papillon,
+  RogalDornEntrepreneur,
+} from "@proconnect-gouv/proconnect.api_entreprise/testing/seed/v3-insee-sirene-etablissements-siret";
+import { suite, test } from "node:test";
+import { toOrganizationInfo } from "./api_entreprise.js";
+
+suite("toOrganizationInfo", () => {
+  test("AppleEuropeInc", (t) => {
+    const organization = toOrganizationInfo(AppleEuropeInc);
+    t.assert.snapshot(organization);
+  });
+
+  test("Commune de clamart - Mairie", (t) => {
+    const organization = toOrganizationInfo(MaireClamart);
+    t.assert.snapshot(organization);
+  });
+
+  test("RogalDornEntrepreneur", (t) => {
+    const organization = toOrganizationInfo(RogalDornEntrepreneur);
+    t.assert.snapshot(organization);
+  });
+  test("Papillon", (t) => {
+    const organization = toOrganizationInfo(Papillon);
+    t.assert.snapshot(organization);
+  });
+});

package/src/{mappers/organization/from-siret.test.ts.snapshot → managers/organization/adapters/api_entreprise.test.ts.snapshot}

@@ -1,4 +1,4 @@
-exports[`fromSiret > AppleEuropeInc 1`] = `
+exports[`toOrganizationInfo > AppleEuropeInc 1`] = `
 {
   "activitePrincipale": "70.22Z",
   "adresse": "100 west ten wilmington delawa, 99404, ETATS-UNIS",
@@ -21,7 +21,7 @@ exports[`fromSiret > AppleEuropeInc 1`] = `
 }
 `;
 
-exports[`fromSiret > Commune de clamart - Mairie 1`] = `
+exports[`toOrganizationInfo > Commune de clamart - Mairie 1`] = `
 {
   "activitePrincipale": "84.11Z",
   "adresse": "1 place maurice gunsbourg, 92140 Clamart",
@@ -44,7 +44,30 @@ exports[`fromSiret > Commune de clamart - Mairie 1`] = `
 }
 `;
 
-exports[`fromSiret > RogalDornEntrepreneur 1`] = `
+exports[`toOrganizationInfo > Papillon 1`] = `
+{
+  "activitePrincipale": "47.59A",
+  "adresse": "5-7, 5 rue du moulin aux moines, 72650 La chapelle-saint-aubin",
+  "categorieJuridique": "5710",
+  "codeOfficielGeographique": "72065",
+  "codePostal": "72650",
+  "enseigne": "",
+  "estActive": true,
+  "estDiffusible": true,
+  "etatAdministratif": "A",
+  "libelle": "Papillon",
+  "libelleActivitePrincipale": "47.59A - Commerce de détail de meubles",
+  "libelleCategorieJuridique": "SAS, société par actions simplifiée",
+  "libelleTrancheEffectif": "3 à 5 salariés, en 2022",
+  "nomComplet": "Papillon",
+  "siret": "39234600300198",
+  "statutDiffusion": "diffusible",
+  "trancheEffectifs": "02",
+  "trancheEffectifsUniteLegale": "11"
+}
+`;
+
+exports[`toOrganizationInfo > RogalDornEntrepreneur 1`] = `
 {
   "activitePrincipale": "62.02A",
   "adresse": "06155 Vallauris",

package/src/{mappers/organization/from-siret.ts → managers/organization/adapters/api_entreprise.ts}

@@ -1,19 +1,23 @@
 //
 
 import "#src/types";
-import { OrganizationInfoSchema, type OrganizationInfo } from "#src/types";
+import {
+  OrganizationInfoSchema,
+  type Organization,
+  type OrganizationInfo,
+} from "#src/types";
 import {
   formatAddress,
   formatMainActivity,
   formatNomComplet,
   libelleFromCodeEffectif,
-} from "@proconnect-gouv/proconnect.entreprise/formatters";
-import type { InseeSireneEstablishmentSiretResponseData } from "@proconnect-gouv/proconnect.entreprise/types";
+} from "@proconnect-gouv/proconnect.api_entreprise/formatters";
+import type { InseeSireneEstablishmentSiretResponseData } from "@proconnect-gouv/proconnect.api_entreprise/types";
 import { capitalize } from "lodash-es";
 
 //
 
-export function fromSiret(
+export function toOrganizationInfo(
   siretData: InseeSireneEstablishmentSiretResponseData,
 ): OrganizationInfo {
   const isPartiallyNonDiffusible =
@@ -71,5 +75,51 @@ export function fromSiret(
     statutDiffusion: siretData.status_diffusion,
     trancheEffectifs,
     trancheEffectifsUniteLegale,
-  } satisfies OrganizationInfo);
+  });
+}
+
+export function toPartialOrganization(organization_info: OrganizationInfo) {
+  const {
+    activitePrincipale: cached_activite_principale,
+    adresse: cached_adresse,
+    categorieJuridique: cached_categorie_juridique,
+    codeOfficielGeographique: cached_code_officiel_geographique,
+    codePostal: cached_code_postal,
+    enseigne: cached_enseigne,
+    estActive: cached_est_active,
+    estDiffusible: cached_est_diffusible,
+    etatAdministratif: cached_etat_administratif,
+    libelle: cached_libelle,
+    libelleActivitePrincipale: cached_libelle_activite_principale,
+    libelleCategorieJuridique: cached_libelle_categorie_juridique,
+    libelleTrancheEffectif: cached_libelle_tranche_effectif,
+    nomComplet: cached_nom_complet,
+    siret,
+    statutDiffusion: cached_statut_diffusion,
+    trancheEffectifs: cached_tranche_effectifs,
+    trancheEffectifsUniteLegale: cached_tranche_effectifs_unite_legale,
+  } = organization_info;
+  return {
+    cached_activite_principale,
+    cached_adresse,
+    cached_categorie_juridique,
+    cached_code_officiel_geographique,
+    cached_code_postal,
+    cached_enseigne,
+    cached_est_active,
+    cached_est_diffusible,
+    cached_etat_administratif,
+    cached_libelle_activite_principale,
+    cached_libelle_categorie_juridique,
+    cached_libelle_tranche_effectif,
+    cached_libelle,
+    cached_nom_complet,
+    cached_statut_diffusion,
+    cached_tranche_effectifs_unite_legale,
+    cached_tranche_effectifs,
+    siret,
+  } satisfies Omit<
+    Organization,
+    "created_at" | "id" | "updated_at" | "organization_info_fetched_at"
+  >;
 }

package/src/managers/organization/get-organization-info.test.ts

@@ -2,8 +2,8 @@ import { NotFoundError } from "#src/errors";
 import {
   CommunautéDeCommunes,
   RogalDornEntrepreneur,
-} from "@proconnect-gouv/proconnect.entreprise/testing/seed/insee/siret";
-import type { InseeSireneEstablishmentSiretResponseData } from "@proconnect-gouv/proconnect.entreprise/types";
+} from "@proconnect-gouv/proconnect.api_entreprise/testing/seed/v3-insee-sirene-etablissements-siret";
+import type { InseeSireneEstablishmentSiretResponseData } from "@proconnect-gouv/proconnect.api_entreprise/types";
 import assert from "node:assert/strict";
 import { suite, test } from "node:test";
 import { getOrganizationInfoFactory } from "./get-organization-info.js";

package/src/managers/organization/get-organization-info.ts

@@ -1,18 +1,18 @@
 //
 
 import { InvalidSiretError, NotFoundError } from "#src/errors";
-import { OrganizationInfoMapper } from "#src/mappers";
 import { type OrganizationInfo } from "#src/types";
-import type { EntrepriseApiInseeRepository } from "@proconnect-gouv/proconnect.entreprise/api";
+import type { ApiEntrepriseInseeRepository } from "@proconnect-gouv/proconnect.api_entreprise/api";
 import {
-  EntrepriseApiConnectionError,
-  EntrepriseApiInvalidSiret,
-} from "@proconnect-gouv/proconnect.entreprise/types";
+  ApiEntrepriseConnectionError,
+  ApiEntrepriseInvalidSiret,
+} from "@proconnect-gouv/proconnect.api_entreprise/types";
+import * as ApiEntreprise from "./adapters/api_entreprise.js";
 
 //
 
 export function getOrganizationInfoFactory(
-  config: EntrepriseApiInseeRepository,
+  config: ApiEntrepriseInseeRepository,
 ) {
   const { findBySiren, findBySiret } = config;
 
@@ -23,11 +23,11 @@ export function getOrganizationInfoFactory(
       let establishment: OrganizationInfo;
 
       if (siretOrSiren.match(/^\d{14}$/)) {
-        establishment = OrganizationInfoMapper.fromSiret(
+        establishment = ApiEntreprise.toOrganizationInfo(
           await findBySiret(siretOrSiren),
         );
       } else if (siretOrSiren.match(/^\d{9}$/)) {
-        establishment = OrganizationInfoMapper.fromSiret(
+        establishment = ApiEntreprise.toOrganizationInfo(
           await findBySiren(siretOrSiren),
         );
       } else {
@@ -42,10 +42,10 @@ export function getOrganizationInfoFactory(
 
       return establishment;
     } catch (e) {
-      if (EntrepriseApiInvalidSiret.isInvalidSiret(e))
+      if (ApiEntrepriseInvalidSiret.isInvalidSiret(e))
         throw new InvalidSiretError();
 
-      throw new EntrepriseApiConnectionError(
+      throw new ApiEntrepriseConnectionError(
         "unknown error while fetching entreprise.api.gouv.fr",
         { cause: e },
       );

package/src/repositories/organization/get-users-by-organization.test.ts.snapshot

@@ -3,7 +3,7 @@ exports[`getUsersByOrganizationFactory > should find users by organization id 1`
   {
     "id": 1,
     "email": "lion.eljonson@darkangels.world",
-    "encrypted_password": "",
+    "encrypted_password": null,
     "reset_password_token": null,
     "reset_password_sent_at": null,
     "sign_in_count": 0,