@doctocar/tooling 0.3.1-16 → 0.3.1-17

package/dist/firebase/firestore/utils/dataValidators/professionalService/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./isValidServicePricingAndDurationForVehicle";
+export * from "./isValidProfessionalService";
+export * from "./isValidProfessionalServiceType";

package/dist/firebase/firestore/utils/dataValidators/professionalService/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./isValidServicePricingAndDurationForVehicle"), exports);
+__exportStar(require("./isValidProfessionalService"), exports);
+__exportStar(require("./isValidProfessionalServiceType"), exports);

package/dist/firebase/firestore/utils/dataValidators/professionalService/isValidProfessionalService.d.ts

@@ -0,0 +1,2 @@
+import type { IsValidProfessionalServiceParams } from "./types";
+export declare function isValidProfessionalService({ professionalService, countryProfessionalServicePublicConfig, }: IsValidProfessionalServiceParams): Promise<void>;

package/dist/firebase/firestore/utils/dataValidators/professionalService/isValidProfessionalService.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidProfessionalService = isValidProfessionalService;
+const errors_1 = require("../../../../../errors");
+const enums_1 = require("../../../enums");
+const isValidServicePricingAndDurationForVehicle_1 = require("./isValidServicePricingAndDurationForVehicle");
+async function isValidProfessionalService({ professionalService, countryProfessionalServicePublicConfig, }) {
+    if (professionalService.isActive === undefined ||
+        typeof professionalService.isActive !== "boolean") {
+        throw new errors_1.DoctoCarError("Professional service is active is required and must be a boolean", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_IS_ACTIVE);
+    }
+    if (professionalService.type === undefined ||
+        !Object.values(enums_1.ServicesTypes).includes(professionalService.type)) {
+        throw new errors_1.DoctoCarError("Professional service type is required and must be a valid professional service type", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_TYPE);
+    }
+    const professionalServicePublicConfig = countryProfessionalServicePublicConfig[professionalService.type];
+    if (professionalServicePublicConfig === undefined) {
+        throw new errors_1.DoctoCarError("Professional service public config is not defined for the professional service type", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_TYPE);
+    }
+    if (professionalService.pricingAndDurationByVehicleType !== undefined) {
+        for (const pricingAndDuration of Object.values(professionalService.pricingAndDurationByVehicleType)) {
+            if (!(0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)({
+                servicePublicConfig: professionalServicePublicConfig,
+                servicePricingAndDurationForVehicle: pricingAndDuration,
+            })) {
+                throw new errors_1.DoctoCarError("Pricing and duration for vehicle type is not valid for the professional service", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_VEHICLE_TYPE_PRICING_AND_DURATION);
+            }
+        }
+    }
+    const professionalServiceParents = professionalServicePublicConfig.parentsServices;
+    if (professionalServiceParents !== undefined &&
+        professionalServiceParents.length > 0) {
+        if (professionalService.parentsServices === undefined ||
+            professionalService.parentsServices.length !==
+                professionalServiceParents.length) {
+            throw new errors_1.DoctoCarError("Professional service parents services are required and must match the professional service type", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_PARENTS_SERVICES);
+        }
+        for (const professionalServiceParent of professionalServiceParents) {
+            if (!professionalService.parentsServices?.includes(professionalServiceParent)) {
+                throw new errors_1.DoctoCarError("Professional service parents services are required and must match the professional service type", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_PARENTS_SERVICES);
+            }
+        }
+    }
+}

package/dist/firebase/firestore/utils/dataValidators/professionalService/isValidProfessionalServicePricingAndDurationForVehicle.d.ts

@@ -0,0 +1,2 @@
+import type { IsValidProfessionalServicePricingAndDurationForVehicleParams } from "./types";
+export declare function isValidProfessionalServicePricingAndDurationForVehicle({ servicePricingAndDuration, professionalServicePublicConfig, }: IsValidProfessionalServicePricingAndDurationForVehicleParams): boolean;

package/dist/firebase/firestore/utils/dataValidators/professionalService/isValidProfessionalServicePricingAndDurationForVehicle.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidProfessionalServicePricingAndDurationForVehicle = isValidProfessionalServicePricingAndDurationForVehicle;
+const enums_1 = require("../../../../../enums");
+const constants_1 = require("../../../constants");
+const enums_2 = require("../../../enums");
+function isValidProfessionalServicePricingAndDurationForVehicle({ servicePricingAndDuration, professionalServicePublicConfig, }) {
+    return (typeof servicePricingAndDuration.isActive === "boolean" &&
+        Object.values(enums_2.VehicleTypes).includes(servicePricingAndDuration.type) &&
+        typeof servicePricingAndDuration.pricePreTaxInCents === "number" &&
+        servicePricingAndDuration.pricePreTaxInCents >=
+            professionalServicePublicConfig.byVehicleType[servicePricingAndDuration.type].minimumPriceInCents &&
+        servicePricingAndDuration.pricePreTaxInCents <=
+            professionalServicePublicConfig.byVehicleType[servicePricingAndDuration.type].maximumPriceInCents &&
+        servicePricingAndDuration.pricePreTaxInCents %
+            constants_1.PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS ===
+            0 &&
+        Object.values(enums_1.SupportedIsoCurrency).includes(servicePricingAndDuration.currency) &&
+        typeof servicePricingAndDuration.durationInMinutes === "number" &&
+        servicePricingAndDuration.durationInMinutes ==
+            professionalServicePublicConfig.byVehicleType[servicePricingAndDuration.type].durationInMinutes &&
+        servicePricingAndDuration.durationInMinutes %
+            constants_1.PROFESSIONAL_SERVICE_MINIMUM_DURATION_INCREMENT_IN_MINUTES ===
+            0);
+}

package/dist/firebase/firestore/utils/dataValidators/professionalService/isValidProfessionalServiceType.d.ts

@@ -0,0 +1,2 @@
+import { ServicesTypes } from "../../../enums";
+export declare function isValidProfessionalServiceType(professionalServiceType: string): professionalServiceType is ServicesTypes;

package/dist/firebase/firestore/utils/dataValidators/professionalService/isValidProfessionalServiceType.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidProfessionalServiceType = isValidProfessionalServiceType;
+const enums_1 = require("../../../enums");
+function isValidProfessionalServiceType(professionalServiceType) {
+    return Object.values(enums_1.ServicesTypes).includes(professionalServiceType);
+}

package/dist/firebase/firestore/utils/dataValidators/professionalService/isValidServicePricingAndDurationForVehicle.d.ts

@@ -0,0 +1,2 @@
+import type { IsValidServicePricingAndDurationForVehicleParams } from "./types";
+export declare function isValidServicePricingAndDurationForVehicle({ servicePricingAndDurationForVehicle, servicePublicConfig, }: IsValidServicePricingAndDurationForVehicleParams): boolean;

package/dist/firebase/firestore/utils/dataValidators/professionalService/isValidServicePricingAndDurationForVehicle.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidServicePricingAndDurationForVehicle = isValidServicePricingAndDurationForVehicle;
+const enums_1 = require("../../../../../enums");
+const constants_1 = require("../../../constants");
+const enums_2 = require("../../../enums");
+function isValidServicePricingAndDurationForVehicle({ servicePricingAndDurationForVehicle, servicePublicConfig, }) {
+    const servicePublicConfigByVehicleType = servicePublicConfig.byVehicleType;
+    const servicePublicConfigForVehicle = servicePublicConfigByVehicleType[servicePricingAndDurationForVehicle.type];
+    return (servicePublicConfigForVehicle !== undefined &&
+        typeof servicePricingAndDurationForVehicle.isActive === "boolean" &&
+        Object.values(enums_2.VehicleTypes).includes(servicePricingAndDurationForVehicle.type) &&
+        typeof servicePricingAndDurationForVehicle.pricePreTaxInCents ===
+            "number" &&
+        servicePricingAndDurationForVehicle.pricePreTaxInCents >=
+            servicePublicConfigForVehicle.minimumPriceInCents &&
+        servicePricingAndDurationForVehicle.pricePreTaxInCents <=
+            servicePublicConfigForVehicle.maximumPriceInCents &&
+        servicePricingAndDurationForVehicle.pricePreTaxInCents %
+            constants_1.PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS ===
+            0 &&
+        Object.values(enums_1.SupportedIsoCurrency).includes(servicePricingAndDurationForVehicle.currency) &&
+        typeof servicePricingAndDurationForVehicle.durationInMinutes === "number" &&
+        servicePricingAndDurationForVehicle.durationInMinutes ==
+            servicePublicConfigForVehicle.durationInMinutes &&
+        servicePricingAndDurationForVehicle.durationInMinutes %
+            constants_1.PROFESSIONAL_SERVICE_MINIMUM_DURATION_INCREMENT_IN_MINUTES ===
+            0);
+}

package/dist/firebase/firestore/utils/dataValidators/professionalService/isValidVehicleForProfessionalService.d.ts

@@ -0,0 +1,2 @@
+import type { IsValidVehicleForProfessionalServiceParams } from "./types";
+export declare function isValidVehicleForProfessionalService({ vehicleType, professionalServicePublicConfig, }: IsValidVehicleForProfessionalServiceParams): boolean;

package/dist/firebase/firestore/utils/dataValidators/professionalService/isValidVehicleForProfessionalService.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidVehicleForProfessionalService = isValidVehicleForProfessionalService;
+function isValidVehicleForProfessionalService({ vehicleType, professionalServicePublicConfig, }) {
+    try {
+        return professionalServicePublicConfig.allowedVehicles.includes(vehicleType);
+    }
+    catch (e) {
+        return false;
+    }
+}

package/dist/firebase/firestore/utils/dataValidators/professionalService/types/IsValidProfessionalServiceParams.type.d.ts

@@ -0,0 +1,6 @@
+import type { ServicesTypes } from "../../../../enums";
+import type { CountryServicesPublicConfig, ProfessionalService } from "../../../../types";
+export type IsValidProfessionalServiceParams = {
+    professionalService: ProfessionalService<ServicesTypes>;
+    countryProfessionalServicePublicConfig: CountryServicesPublicConfig;
+};

package/dist/firebase/firestore/utils/dataValidators/professionalService/types/IsValidProfessionalServiceParams.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/firebase/firestore/utils/dataValidators/professionalService/types/IsValidProfessionalServicePricingAndDurationForVehicleParams.type.d.ts

@@ -0,0 +1,5 @@
+import type { FirestoreServicesPublicConfig, ServicePricingAndDurationForVehicle } from "../../../../types";
+export type IsValidProfessionalServicePricingAndDurationForVehicleParams = {
+    servicePricingAndDuration: ServicePricingAndDurationForVehicle;
+    professionalServicePublicConfig: FirestoreServicesPublicConfig;
+};

package/dist/firebase/firestore/utils/dataValidators/professionalService/types/IsValidProfessionalServicePricingAndDurationForVehicleParams.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/firebase/firestore/utils/dataValidators/professionalService/types/IsValidServicePricingAndDurationForVehicleParams.type.d.ts

@@ -0,0 +1,5 @@
+import type { FirestoreServicesPublicConfig, ServicePricingAndDurationForVehicle } from "../../../../types";
+export type IsValidServicePricingAndDurationForVehicleParams = {
+    servicePricingAndDurationForVehicle: ServicePricingAndDurationForVehicle;
+    servicePublicConfig: FirestoreServicesPublicConfig;
+};

package/dist/firebase/firestore/utils/dataValidators/professionalService/types/IsValidServicePricingAndDurationForVehicleParams.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/firebase/firestore/utils/dataValidators/professionalService/types/IsValidVehicleForProfessionalServiceParams.type.d.ts

@@ -0,0 +1,6 @@
+import type { VehicleTypes } from "../../../../enums";
+import type { FirestoreServicesPublicConfig } from "../../../../types";
+export type IsValidVehicleForProfessionalServiceParams = {
+    vehicleType: VehicleTypes;
+    professionalServicePublicConfig: FirestoreServicesPublicConfig;
+};

package/dist/firebase/firestore/utils/dataValidators/professionalService/types/IsValidVehicleForProfessionalServiceParams.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/firebase/firestore/utils/dataValidators/professionalService/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./IsValidProfessionalServiceParams.type";
+export * from "./IsValidServicePricingAndDurationForVehicleParams.type";
+export * from "./IsValidVehicleForProfessionalServiceParams.type";

package/dist/firebase/firestore/utils/dataValidators/professionalService/types/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./IsValidProfessionalServiceParams.type"), exports);
+__exportStar(require("./IsValidServicePricingAndDurationForVehicleParams.type"), exports);
+__exportStar(require("./IsValidVehicleForProfessionalServiceParams.type"), exports);

package/dist/firebase/firestore/utils/dataValidators/services/types/IsValidVehicleForProfessionalServiceParams.type.d.ts

@@ -0,0 +1,6 @@
+import type { VehicleTypes } from "../../../../enums";
+import type { FirestoreServicesPublicConfig } from "../../../../types";
+export type IsValidVehicleForProfessionalServiceParams = {
+    vehicleType: VehicleTypes;
+    professionalServicePublicConfig: FirestoreServicesPublicConfig;
+};

package/dist/firebase/firestore/utils/dataValidators/services/types/IsValidVehicleForProfessionalServiceParams.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/firebase/firestore/utils/entities/__tests__/entityDocumentSupportsOrganizationMembers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/firebase/firestore/utils/entities/__tests__/entityDocumentSupportsOrganizationMembers.test.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const enums_1 = require("../../../../../enums");
+const enums_2 = require("../../../enums");
+const frenchCompanyRegistrationStub_1 = require("../../stubs/company/frenchCompanyRegistrationStub");
+const firestoreEntityDocumentStub_1 = require("../../stubs/entities/firestoreEntityDocumentStub");
+const entityLegalDetailsStub_1 = require("../../stubs/entities/entityLegalDetailsStub");
+const entityRegistrationStub_1 = require("../../stubs/entities/entityRegistrationStub");
+const entityDocumentSupportsOrganizationMembers_1 = require("../entityDocumentSupportsOrganizationMembers");
+describe("entityDocumentSupportsOrganizationMembers", () => {
+    it("returns false if entity document is undefined", () => {
+        expect((0, entityDocumentSupportsOrganizationMembers_1.entityDocumentSupportsOrganizationMembers)(undefined)).toBe(false);
+    });
+    it("returns false if legal type is INDIVIDUAL", () => {
+        expect((0, entityDocumentSupportsOrganizationMembers_1.entityDocumentSupportsOrganizationMembers)((0, firestoreEntityDocumentStub_1.firestoreEntityDocumentStub)({
+            legalType: enums_2.EntityLegalType.INDIVIDUAL,
+        }))).toBe(false);
+    });
+    it("returns false for COMPANY with micro-entrepreneur legal form", () => {
+        const doc = (0, firestoreEntityDocumentStub_1.firestoreEntityDocumentStub)({
+            legalType: enums_2.EntityLegalType.COMPANY,
+            legalDetails: (0, entityLegalDetailsStub_1.entityLegalDetailsStub)({
+                registration: (0, entityRegistrationStub_1.entityRegistrationStub)({
+                    data: (0, frenchCompanyRegistrationStub_1.frenchCompanyRegistrationStub)({
+                        legalForm: enums_1.SupportedFrenchCompanyLegalForms.MICRO_ENTREPRENEUR,
+                    }),
+                }),
+            }),
+        });
+        expect((0, entityDocumentSupportsOrganizationMembers_1.entityDocumentSupportsOrganizationMembers)(doc)).toBe(false);
+    });
+    it("returns false for COMPANY with entreprise individuelle legal form", () => {
+        const doc = (0, firestoreEntityDocumentStub_1.firestoreEntityDocumentStub)({
+            legalType: enums_2.EntityLegalType.COMPANY,
+            legalDetails: (0, entityLegalDetailsStub_1.entityLegalDetailsStub)({
+                registration: (0, entityRegistrationStub_1.entityRegistrationStub)({
+                    data: (0, frenchCompanyRegistrationStub_1.frenchCompanyRegistrationStub)({
+                        legalForm: enums_1.SupportedFrenchCompanyLegalForms.ENTREPRISE_INDIVIDUELLE,
+                    }),
+                }),
+            }),
+        });
+        expect((0, entityDocumentSupportsOrganizationMembers_1.entityDocumentSupportsOrganizationMembers)(doc)).toBe(false);
+    });
+    it("returns true for COMPANY with SARL legal form", () => {
+        expect((0, entityDocumentSupportsOrganizationMembers_1.entityDocumentSupportsOrganizationMembers)((0, firestoreEntityDocumentStub_1.firestoreEntityDocumentStub)({
+            legalType: enums_2.EntityLegalType.COMPANY,
+        }))).toBe(true);
+    });
+    it("returns true for COMPANY when legal form is missing (legacy / incomplete entity)", () => {
+        expect((0, entityDocumentSupportsOrganizationMembers_1.entityDocumentSupportsOrganizationMembers)((0, firestoreEntityDocumentStub_1.firestoreEntityDocumentStub)({
+            legalType: enums_2.EntityLegalType.COMPANY,
+            legalDetails: undefined,
+        }))).toBe(true);
+    });
+});

package/dist/firebase/firestore/utils/entities/__tests__/entityDocumentSupportsOrganizationMembers.util.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/firebase/firestore/utils/entities/__tests__/entityDocumentSupportsOrganizationMembers.util.test.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const enums_1 = require("../../../../../enums");
+const enums_2 = require("../../../enums");
+const frenchCompanyRegistrationStub_1 = require("../../stubs/company/frenchCompanyRegistrationStub");
+const firestoreEntityDocumentStub_1 = require("../../stubs/entities/firestoreEntityDocumentStub");
+const entityLegalDetailsStub_1 = require("../../stubs/entities/entityLegalDetailsStub");
+const entityRegistrationStub_1 = require("../../stubs/entities/entityRegistrationStub");
+const entityDocumentSupportsOrganizationMembers_util_1 = require("../../entities/entityDocumentSupportsOrganizationMembers.util");
+describe("entityDocumentSupportsOrganizationMembers", () => {
+    it("returns false if entity document is undefined", () => {
+        expect((0, entityDocumentSupportsOrganizationMembers_util_1.entityDocumentSupportsOrganizationMembers)(undefined)).toBe(false);
+    });
+    it("returns false if legal type is INDIVIDUAL", () => {
+        expect((0, entityDocumentSupportsOrganizationMembers_util_1.entityDocumentSupportsOrganizationMembers)((0, firestoreEntityDocumentStub_1.firestoreEntityDocumentStub)({
+            legalType: enums_2.EntityLegalType.INDIVIDUAL,
+        }))).toBe(false);
+    });
+    it("returns false for COMPANY with micro-entrepreneur legal form", () => {
+        const doc = (0, firestoreEntityDocumentStub_1.firestoreEntityDocumentStub)({
+            legalType: enums_2.EntityLegalType.COMPANY,
+            legalDetails: (0, entityLegalDetailsStub_1.entityLegalDetailsStub)({
+                registration: (0, entityRegistrationStub_1.entityRegistrationStub)({
+                    data: (0, frenchCompanyRegistrationStub_1.frenchCompanyRegistrationStub)({
+                        legalForm: enums_1.SupportedFrenchCompanyLegalForms.MICRO_ENTREPRENEUR,
+                    }),
+                }),
+            }),
+        });
+        expect((0, entityDocumentSupportsOrganizationMembers_util_1.entityDocumentSupportsOrganizationMembers)(doc)).toBe(false);
+    });
+    it("returns false for COMPANY with entreprise individuelle legal form", () => {
+        const doc = (0, firestoreEntityDocumentStub_1.firestoreEntityDocumentStub)({
+            legalType: enums_2.EntityLegalType.COMPANY,
+            legalDetails: (0, entityLegalDetailsStub_1.entityLegalDetailsStub)({
+                registration: (0, entityRegistrationStub_1.entityRegistrationStub)({
+                    data: (0, frenchCompanyRegistrationStub_1.frenchCompanyRegistrationStub)({
+                        legalForm: enums_1.SupportedFrenchCompanyLegalForms.ENTREPRISE_INDIVIDUELLE,
+                    }),
+                }),
+            }),
+        });
+        expect((0, entityDocumentSupportsOrganizationMembers_util_1.entityDocumentSupportsOrganizationMembers)(doc)).toBe(false);
+    });
+    it("returns true for COMPANY with SARL legal form", () => {
+        expect((0, entityDocumentSupportsOrganizationMembers_util_1.entityDocumentSupportsOrganizationMembers)((0, firestoreEntityDocumentStub_1.firestoreEntityDocumentStub)({
+            legalType: enums_2.EntityLegalType.COMPANY,
+        }))).toBe(true);
+    });
+    it("returns true for COMPANY when legal form is missing (legacy / incomplete entity)", () => {
+        expect((0, entityDocumentSupportsOrganizationMembers_util_1.entityDocumentSupportsOrganizationMembers)((0, firestoreEntityDocumentStub_1.firestoreEntityDocumentStub)({
+            legalType: enums_2.EntityLegalType.COMPANY,
+            legalDetails: undefined,
+        }))).toBe(true);
+    });
+});

package/dist/firebase/firestore/utils/entities/entityDocumentSupportsOrganizationMembers.d.ts

@@ -0,0 +1,6 @@
+import type { FirestoreEntityDocument } from "../../types";
+/**
+ * Organization / multi-member account UI applies to company entities whose
+ * French legal form is not a solo structure (micro-entrepreneur, EI).
+ */
+export declare function entityDocumentSupportsOrganizationMembers(entityDocument: FirestoreEntityDocument | undefined): boolean;

package/dist/firebase/firestore/utils/entities/entityDocumentSupportsOrganizationMembers.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.entityDocumentSupportsOrganizationMembers = entityDocumentSupportsOrganizationMembers;
+const enums_1 = require("../../../../enums");
+const enums_2 = require("../../enums");
+/**
+ * Organization / multi-member account UI applies to company entities whose
+ * French legal form is not a solo structure (micro-entrepreneur, EI).
+ */
+function entityDocumentSupportsOrganizationMembers(entityDocument) {
+    if (!entityDocument || entityDocument.legalType !== enums_2.EntityLegalType.COMPANY) {
+        return false;
+    }
+    const legalForm = entityDocument.legalDetails?.registration?.data?.legalForm;
+    if (legalForm === enums_1.SupportedFrenchCompanyLegalForms.MICRO_ENTREPRENEUR ||
+        legalForm === enums_1.SupportedFrenchCompanyLegalForms.ENTREPRISE_INDIVIDUELLE) {
+        return false;
+    }
+    return true;
+}

package/dist/firebase/firestore/utils/entities/entityDocumentSupportsOrganizationMembers.util.d.ts

@@ -0,0 +1,6 @@
+import type { FirestoreEntityDocument } from "../../types";
+/**
+ * Organization / multi-member account UI applies to company entities whose
+ * French legal form is not a solo structure (micro-entrepreneur, EI).
+ */
+export declare function entityDocumentSupportsOrganizationMembers(entityDocument: FirestoreEntityDocument | undefined): boolean;

package/dist/firebase/firestore/utils/entities/entityDocumentSupportsOrganizationMembers.util.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.entityDocumentSupportsOrganizationMembers = entityDocumentSupportsOrganizationMembers;
+const enums_1 = require("../../../../enums");
+const enums_2 = require("../../enums");
+/**
+ * Organization / multi-member account UI applies to company entities whose
+ * French legal form is not a solo structure (micro-entrepreneur, EI).
+ */
+function entityDocumentSupportsOrganizationMembers(entityDocument) {
+    if (!entityDocument || entityDocument.legalType !== enums_2.EntityLegalType.COMPANY) {
+        return false;
+    }
+    const legalForm = entityDocument.legalDetails?.registration?.data?.legalForm;
+    if (legalForm === enums_1.SupportedFrenchCompanyLegalForms.MICRO_ENTREPRENEUR ||
+        legalForm === enums_1.SupportedFrenchCompanyLegalForms.ENTREPRISE_INDIVIDUELLE) {
+        return false;
+    }
+    return true;
+}

package/dist/firebase/firestore/utils/order/__tests__/buildOrderProfessionalServicePreTaxLinesAndProfessionalServicesDetails.service.test.d.ts

@@ -0,0 +1 @@
+export {};