@doctocar/tooling 0.3.1-1 → 0.3.1-12

package/dist/firebase/firestore/utils/users/__tests__/assertProfessionalUserIsBookable.util.test.js

@@ -1,400 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable @typescript-eslint/no-explicit-any */
-const enums_1 = require("../../../../../enums");
-const errors_1 = require("../../../../../errors");
-const enums_2 = require("../../../enums");
-const dataValidators_1 = require("../../dataValidators");
-const stubs_1 = require("../../stubs");
-const assertProfessionalUserIsBookable_util_1 = require("../assertProfessionalUserIsBookable.util");
-jest.mock("../../dataValidators", () => ({
-    ...jest.requireActual("../../dataValidators"),
-    isCompanyVatValid: jest.fn(),
-    isLegalAddressValid: jest.fn(),
-    isFrenchCompanyRegistrationValid: jest.fn(),
-}));
-const validProfessionalInfos = (0, stubs_1.firestoreUserDocumentProfessionalInfosStub)({
-    privacyPolicyPro: {
-        acceptedAt: (0, stubs_1.firestoreTimestampStub)(),
-        version: "1.0.0",
-    },
-    termsOfService: {
-        acceptedAt: (0, stubs_1.firestoreTimestampStub)(),
-        version: "1.0.0",
-    },
-    companyDetails: (0, stubs_1.professionalCompanyDetailsStub)({}),
-    stripe: {
-        accountId: "acct_123",
-        chargesEnabled: true,
-        payoutsEnabled: true,
-        detailsSubmitted: true,
-    },
-});
-const validProfessionalUserDocument = (0, stubs_1.firestoreUserDocumentStub)({
-    isTest: false,
-    professionalInfos: validProfessionalInfos,
-});
-const validProfessionalUserPublicDocument = (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
-    isBookable: true,
-    isTest: false,
-    activeServicesVehiclesCombos: ["service1-vehicle1", "service2-vehicle2"],
-});
-const platformPublicConfigDocument = (0, stubs_1.firestorePlatformPublicConfigDocumentStub)({
-    data: {
-        legal: {
-            privacyPolicy: {
-                version: "1.0.0",
-                documentUrl: "https://example.com/privacy-policy",
-            },
-            privacyPolicyPro: {
-                version: "1.0.0",
-                documentUrl: "https://example.com/privacy-policy-pro",
-            },
-            termsOfService: {
-                version: "1.0.0",
-                documentUrl: "https://example.com/terms-of-service",
-            },
-            selfBillingAgreement: {
-                version: "1.0.0",
-                documentUrl: "https://example.com/self-billing-agreement",
-            },
-            termsOfUse: {
-                version: "1.0.0",
-                documentUrl: "https://example.com/terms-of-use",
-            },
-        },
-    },
-});
-const successCases = [
-    {
-        name: "valid professional user",
-        professionalUserDocument: validProfessionalUserDocument,
-        professionalUserPublicDocument: validProfessionalUserPublicDocument,
-        platformPublicConfigDocument,
-        isCompanyVatValidReturnValue: true,
-        isLegalAddressValidReturnValue: true,
-        isFrenchCompanyRegistrationValidReturnValue: true,
-        only: false,
-    },
-    {
-        name: "valid professional Test user with no stripe",
-        only: false,
-        professionalUserDocument: {
-            ...validProfessionalUserDocument,
-            isTest: true,
-            professionalInfos: (0, stubs_1.firestoreUserDocumentProfessionalInfosStub)({
-                ...validProfessionalUserDocument.professionalInfos,
-                stripe: undefined,
-            }),
-        },
-        professionalUserPublicDocument: validProfessionalUserPublicDocument,
-        platformPublicConfigDocument,
-        isCompanyVatValidReturnValue: true,
-        isLegalAddressValidReturnValue: true,
-        isFrenchCompanyRegistrationValidReturnValue: true,
-    },
-];
-const errorCases = [
-    {
-        name: "missing privacy policy acceptance",
-        only: false,
-        professionalUserDocument: (0, stubs_1.firestoreUserDocumentStub)({
-            isTest: false,
-            professionalInfos: {
-                ...validProfessionalInfos,
-                privacyPolicyPro: { acceptedAt: undefined, version: "1.0.0" },
-            },
-        }),
-        professionalUserPublicDocument: validProfessionalUserPublicDocument,
-        platformPublicConfigDocument,
-        isCompanyVatValidReturnValue: true,
-        isLegalAddressValidReturnValue: true,
-        isFrenchCompanyRegistrationValidReturnValue: true,
-        expectedError: new errors_1.DoctoCarError("Professional user has not accepted the latest privacy policy", enums_2.ProfessionalNonBookableReason.USER_HAS_NOT_ACCEPTED_LATEST_PRIVACY_POLICY),
-    },
-    {
-        name: "Invalid privacy policy acceptance version",
-        only: false,
-        professionalUserDocument: (0, stubs_1.firestoreUserDocumentStub)({
-            isTest: false,
-            professionalInfos: {
-                ...validProfessionalInfos,
-                privacyPolicyPro: {
-                    acceptedAt: (0, stubs_1.firestoreTimestampStub)(),
-                    version: "0.1.0",
-                },
-            },
-        }),
-        professionalUserPublicDocument: validProfessionalUserPublicDocument,
-        platformPublicConfigDocument,
-        isCompanyVatValidReturnValue: true,
-        isLegalAddressValidReturnValue: true,
-        isFrenchCompanyRegistrationValidReturnValue: true,
-        expectedError: new errors_1.DoctoCarError("Professional user has not accepted the latest privacy policy", enums_2.ProfessionalNonBookableReason.USER_HAS_NOT_ACCEPTED_LATEST_PRIVACY_POLICY),
-    },
-    {
-        name: "Invalid if privacyPolicyPro version is newer",
-        only: false,
-        professionalUserDocument: (0, stubs_1.firestoreUserDocumentStub)({
-            isTest: false,
-            professionalInfos: {
-                ...validProfessionalInfos,
-                privacyPolicyPro: {
-                    acceptedAt: (0, stubs_1.firestoreTimestampStub)(),
-                    version: "2.0.0",
-                },
-            },
-        }),
-        professionalUserPublicDocument: validProfessionalUserPublicDocument,
-        platformPublicConfigDocument,
-        isCompanyVatValidReturnValue: true,
-        isLegalAddressValidReturnValue: true,
-        isFrenchCompanyRegistrationValidReturnValue: true,
-        expectedError: new errors_1.DoctoCarError("Professional user has not accepted the latest privacy policy", enums_2.ProfessionalNonBookableReason.USER_HAS_NOT_ACCEPTED_LATEST_PRIVACY_POLICY),
-    },
-    {
-        name: "Invalid if termsOfService version is newer",
-        only: false,
-        professionalUserDocument: (0, stubs_1.firestoreUserDocumentStub)({
-            isTest: false,
-            professionalInfos: {
-                ...validProfessionalInfos,
-                termsOfService: {
-                    acceptedAt: (0, stubs_1.firestoreTimestampStub)(),
-                    version: "2.0.0",
-                },
-            },
-        }),
-        professionalUserPublicDocument: validProfessionalUserPublicDocument,
-        platformPublicConfigDocument,
-        isCompanyVatValidReturnValue: true,
-        isLegalAddressValidReturnValue: true,
-        isFrenchCompanyRegistrationValidReturnValue: true,
-        expectedError: new errors_1.DoctoCarError("Professional user has not accepted the latest terms of service", enums_2.ProfessionalNonBookableReason.USER_HAS_NOT_ACCEPTED_LATEST_TERMS_OF_USE),
-    },
-    {
-        name: "missing terms of service acceptance",
-        only: false,
-        professionalUserDocument: (0, stubs_1.firestoreUserDocumentStub)({
-            isTest: false,
-            professionalInfos: {
-                ...validProfessionalInfos,
-                termsOfService: { acceptedAt: undefined, version: "1.0.0" },
-            },
-        }),
-        professionalUserPublicDocument: validProfessionalUserPublicDocument,
-        platformPublicConfigDocument,
-        isCompanyVatValidReturnValue: true,
-        isLegalAddressValidReturnValue: true,
-        isFrenchCompanyRegistrationValidReturnValue: true,
-        expectedError: new errors_1.DoctoCarError("Professional user has not accepted the latest terms of service", enums_2.ProfessionalNonBookableReason.USER_HAS_NOT_ACCEPTED_LATEST_TERMS_OF_USE),
-    },
-    {
-        name: "Invalid terms of service acceptance",
-        only: false,
-        professionalUserDocument: (0, stubs_1.firestoreUserDocumentStub)({
-            isTest: false,
-            professionalInfos: {
-                ...validProfessionalInfos,
-                termsOfService: {
-                    acceptedAt: (0, stubs_1.firestoreTimestampStub)(),
-                    version: "0.1.0",
-                },
-            },
-        }),
-        professionalUserPublicDocument: validProfessionalUserPublicDocument,
-        platformPublicConfigDocument,
-        isCompanyVatValidReturnValue: true,
-        isLegalAddressValidReturnValue: true,
-        isFrenchCompanyRegistrationValidReturnValue: true,
-        expectedError: new errors_1.DoctoCarError("Professional user has not accepted the latest terms of service", enums_2.ProfessionalNonBookableReason.USER_HAS_NOT_ACCEPTED_LATEST_TERMS_OF_USE),
-    },
-    {
-        name: "invalid company VAT details",
-        only: false,
-        professionalUserDocument: validProfessionalUserDocument,
-        professionalUserPublicDocument: validProfessionalUserPublicDocument,
-        platformPublicConfigDocument,
-        isCompanyVatValidReturnValue: false,
-        isLegalAddressValidReturnValue: true,
-        isFrenchCompanyRegistrationValidReturnValue: true,
-        expectedError: new errors_1.DoctoCarError("Professional user company VAT details are not valid", enums_2.ProfessionalNonBookableReason.COMPANY_VAT_DETAILS_ARE_NOT_VALID),
-    },
-    {
-        name: "invalid legal address",
-        only: false,
-        professionalUserDocument: validProfessionalUserDocument,
-        professionalUserPublicDocument: validProfessionalUserPublicDocument,
-        platformPublicConfigDocument,
-        isCompanyVatValidReturnValue: true,
-        isLegalAddressValidReturnValue: false,
-        isFrenchCompanyRegistrationValidReturnValue: true,
-        expectedError: new errors_1.DoctoCarError("Professional user legal address is not valid", enums_2.ProfessionalNonBookableReason.COMPANY_LEGAL_ADDRESS_IS_NOT_VALID),
-    },
-    {
-        name: "Stripe account not configured for non-test user",
-        only: false,
-        professionalUserDocument: {
-            ...validProfessionalUserDocument,
-            isTest: false,
-            professionalInfos: (0, stubs_1.firestoreUserDocumentProfessionalInfosStub)({
-                ...validProfessionalUserDocument.professionalInfos,
-                stripe: undefined,
-            }),
-        },
-        professionalUserPublicDocument: validProfessionalUserPublicDocument,
-        platformPublicConfigDocument,
-        isCompanyVatValidReturnValue: true,
-        isLegalAddressValidReturnValue: true,
-        isFrenchCompanyRegistrationValidReturnValue: true,
-        expectedError: new errors_1.DoctoCarError("Professional user Stripe account is not properly configured", enums_2.ProfessionalNonBookableReason.COMPANY_STRIPE_ACCOUNT_NOT_CONFIGURED),
-    },
-    {
-        name: "Stripe account hasDiscrepancyWithFirestore true for non-test user",
-        only: false,
-        professionalUserDocument: {
-            ...validProfessionalUserDocument,
-            isTest: false,
-            professionalInfos: (0, stubs_1.firestoreUserDocumentProfessionalInfosStub)({
-                ...validProfessionalUserDocument.professionalInfos,
-                stripe: {
-                    accountId: "acct_123",
-                    chargesEnabled: true,
-                    payoutsEnabled: true,
-                    detailsSubmitted: true,
-                    hasDiscrepancyWithFirestore: true,
-                },
-            }),
-        },
-        professionalUserPublicDocument: validProfessionalUserPublicDocument,
-        platformPublicConfigDocument,
-        isCompanyVatValidReturnValue: true,
-        isLegalAddressValidReturnValue: true,
-        isFrenchCompanyRegistrationValidReturnValue: true,
-        expectedError: new errors_1.DoctoCarError("Mismatch between Stripe account details and Firestore professional infos", enums_2.ProfessionalNonBookableReason.COMPANY_STRIPE_ACCOUNT_HAS_DISCREPANCY_WITH_FIRESTORE),
-    },
-    {
-        name: "No active services vehicles combos",
-        only: false,
-        professionalUserDocument: validProfessionalUserDocument,
-        professionalUserPublicDocument: {
-            ...validProfessionalUserPublicDocument,
-            activeServicesVehiclesCombos: [],
-        },
-        platformPublicConfigDocument,
-        isCompanyVatValidReturnValue: true,
-        isLegalAddressValidReturnValue: true,
-        isFrenchCompanyRegistrationValidReturnValue: true,
-        expectedError: new errors_1.DoctoCarError("Professional user has no active services or vehicles combos", enums_2.ProfessionalNonBookableReason.USER_HAS_NO_ACTIVE_SERVICES_VEHICLES_COMBOS),
-    },
-    {
-        name: "Unsupported country",
-        only: false,
-        professionalUserDocument: (0, stubs_1.firestoreUserDocumentStub)({
-            isTest: false,
-            professionalInfos: (0, stubs_1.firestoreUserDocumentProfessionalInfosStub)({
-                ...validProfessionalInfos,
-                companyDetails: (0, stubs_1.professionalCompanyDetailsStub)({
-                    legalAddress: {
-                        ...validProfessionalInfos.companyDetails.legalAddress,
-                        country: "unsupported",
-                    },
-                    registration: {
-                        FR: validProfessionalInfos.companyDetails.registration.FR,
-                    },
-                }),
-            }),
-        }),
-        professionalUserPublicDocument: validProfessionalUserPublicDocument,
-        platformPublicConfigDocument,
-        isCompanyVatValidReturnValue: true,
-        isLegalAddressValidReturnValue: true,
-        isFrenchCompanyRegistrationValidReturnValue: true,
-        expectedError: new errors_1.DoctoCarError("Professional user country 'unsupported' is not supported", enums_2.ProfessionalNonBookableReason.COUNTRY_IS_NOT_SUPPORTED),
-    },
-    {
-        name: "Invalid French company registration",
-        only: false,
-        professionalUserDocument: (0, stubs_1.firestoreUserDocumentStub)({
-            isTest: false,
-            professionalInfos: (0, stubs_1.firestoreUserDocumentProfessionalInfosStub)({
-                ...validProfessionalInfos,
-                companyDetails: (0, stubs_1.professionalCompanyDetailsStub)({
-                    legalAddress: {
-                        ...validProfessionalInfos.companyDetails.legalAddress,
-                        country: enums_1.SupportedCountryIsoCodes.FRANCE,
-                    },
-                    registration: {},
-                }),
-            }),
-        }),
-        professionalUserPublicDocument: validProfessionalUserPublicDocument,
-        platformPublicConfigDocument,
-        isCompanyVatValidReturnValue: true,
-        isLegalAddressValidReturnValue: true,
-        isFrenchCompanyRegistrationValidReturnValue: false,
-        expectedError: new errors_1.DoctoCarError(`Professional user company registration details for country '${enums_1.SupportedCountryIsoCodes.FRANCE}' are not valid`, enums_2.ProfessionalNonBookableReason.COMPANY_REGISTRATION_DETAILS_ARE_NOT_VALID),
-    },
-];
-const hasOnly = errorCases.some((c) => c.only);
-const filteredErrorCases = hasOnly
-    ? errorCases.filter((c) => c.only)
-    : errorCases;
-describe("assertProfessionalUserIsBookable", () => {
-    let isCompanyVatValidMock;
-    let isLegalAddressValidMock;
-    let isFrenchCompanyRegistrationValidMock;
-    beforeEach(() => {
-        isCompanyVatValidMock = dataValidators_1.isCompanyVatValid;
-        isLegalAddressValidMock = dataValidators_1.isLegalAddressValid;
-        isFrenchCompanyRegistrationValidMock =
-            dataValidators_1.isFrenchCompanyRegistrationValid;
-    });
-    afterEach(() => {
-        jest.clearAllMocks();
-    });
-    describe("success cases", () => {
-        test.each(successCases)("should NOT throw if $name", ({ professionalUserDocument, professionalUserPublicDocument, platformPublicConfigDocument, isCompanyVatValidReturnValue, isLegalAddressValidReturnValue, isFrenchCompanyRegistrationValidReturnValue, }) => {
-            isCompanyVatValidMock.mockReturnValue(isCompanyVatValidReturnValue);
-            isLegalAddressValidMock.mockReturnValue(isLegalAddressValidReturnValue);
-            isFrenchCompanyRegistrationValidMock.mockReturnValue(isFrenchCompanyRegistrationValidReturnValue);
-            try {
-                (0, assertProfessionalUserIsBookable_util_1.assertProfessionalUserIsBookable)(professionalUserDocument, professionalUserPublicDocument, platformPublicConfigDocument);
-                expect(isCompanyVatValidMock).toHaveBeenCalledTimes(1);
-                expect(isCompanyVatValidMock).toHaveBeenCalledWith(professionalUserDocument.professionalInfos.companyDetails
-                    .vatDetails);
-                expect(isLegalAddressValidMock).toHaveBeenCalledTimes(1);
-                expect(isLegalAddressValidMock).toHaveBeenCalledWith(professionalUserDocument.professionalInfos.companyDetails
-                    .legalAddress);
-                expect(isFrenchCompanyRegistrationValidMock).toHaveBeenCalledTimes(1);
-                expect(isFrenchCompanyRegistrationValidMock).toHaveBeenCalledWith({
-                    registration: professionalUserDocument.professionalInfos.companyDetails
-                        .registration.FR,
-                });
-            }
-            catch (e) {
-                throw new Error(`validateSelectedProfessionalsServiceTypesOrThrow should not throw, but it did: ${e}`);
-            }
-        });
-    });
-    describe("error cases", () => {
-        test.each(filteredErrorCases)("should throw if $name", ({ professionalUserDocument, professionalUserPublicDocument, platformPublicConfigDocument, isCompanyVatValidReturnValue, isLegalAddressValidReturnValue, expectedError, isFrenchCompanyRegistrationValidReturnValue, }) => {
-            isCompanyVatValidMock.mockReturnValue(isCompanyVatValidReturnValue);
-            isLegalAddressValidMock.mockReturnValue(isLegalAddressValidReturnValue);
-            isFrenchCompanyRegistrationValidMock.mockReturnValue(isFrenchCompanyRegistrationValidReturnValue);
-            try {
-                (0, assertProfessionalUserIsBookable_util_1.assertProfessionalUserIsBookable)(professionalUserDocument, professionalUserPublicDocument, platformPublicConfigDocument);
-                throw new Error("assertProfessionalUserIsBookable did not throw");
-            }
-            catch (error) {
-                if (error instanceof errors_1.DoctoCarError) {
-                    expect(error.message).toBe(expectedError?.message);
-                    expect(error.errorCode).toBe(expectedError?.errorCode);
-                }
-                else {
-                    throw new Error(`Expected DoctoCarError, but got: ${error}`);
-                }
-            }
-        });
-    });
-});

package/dist/firebase/firestore/utils/users/assertCustomerUserCanBookServices.d.ts

@@ -1,3 +0,0 @@
-import type { FirestorePlatformPublicConfigDocument, FirestoreUserDocument } from "../../types";
-import type { BookingReadyCustomerUserDocument } from "./types";
-export declare function assertCustomerUserCanBookServices(customerUserDocument: FirestoreUserDocument, platformConfigDocument: FirestorePlatformPublicConfigDocument): asserts customerUserDocument is BookingReadyCustomerUserDocument;

package/dist/firebase/firestore/utils/users/assertCustomerUserCanBookServices.js

@@ -1,35 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertCustomerUserCanBookServices = assertCustomerUserCanBookServices;
-const semver_1 = __importDefault(require("semver"));
-const errors_1 = require("../../../../errors");
-const enums_1 = require("../../enums");
-const dataValidators_1 = require("../dataValidators");
-const errors_2 = require("./errors");
-function assertCustomerUserCanBookServices(customerUserDocument, platformConfigDocument) {
-    if (customerUserDocument.customerInfos?.privacyPolicy?.acceptedAt ===
-        undefined ||
-        customerUserDocument.customerInfos?.privacyPolicy.version === undefined ||
-        !semver_1.default.eq(customerUserDocument.customerInfos?.privacyPolicy.version, platformConfigDocument.data.legal.privacyPolicy.version)) {
-        throw new errors_1.DoctoCarError("Customer user has not accepted the latest privacy policy", errors_2.AssertCustomerUserCanBookServicesErrorCodes.USER_HAS_NOT_ACCEPTED_LATEST_PRIVACY_POLICY);
-    }
-    if (customerUserDocument.customerInfos?.termsOfUse?.acceptedAt === undefined ||
-        customerUserDocument.customerInfos?.termsOfUse.version === undefined ||
-        !semver_1.default.eq(customerUserDocument.customerInfos?.termsOfUse.version, platformConfigDocument.data.legal.termsOfUse.version)) {
-        throw new errors_1.DoctoCarError("Customer user has not accepted the latest terms of use", errors_2.AssertCustomerUserCanBookServicesErrorCodes.USER_HAS_NOT_ACCEPTED_LATEST_TERMS_OF_USE);
-    }
-    if ((0, dataValidators_1.isLegalAddressValid)(customerUserDocument.customerInfos.billingAddress) ===
-        false) {
-        throw new errors_1.DoctoCarError("Customer user billing address is not valid", errors_2.AssertCustomerUserCanBookServicesErrorCodes.BILLING_ADDRESS_IS_NOT_VALID);
-    }
-    if (customerUserDocument.customerInfos.customerAccountType ===
-        enums_1.CustomerAccountTypes.BUSINESS) {
-        if (!customerUserDocument.customerInfos.companyDetails?.legalAddress ||
-            (0, dataValidators_1.isLegalAddressValid)(customerUserDocument.customerInfos.companyDetails.legalAddress) === false) {
-            throw new errors_1.DoctoCarError("Customer user company legal address is not valid", errors_2.AssertCustomerUserCanBookServicesErrorCodes.LEGAL_ADDRESS_IS_NOT_VALID);
-        }
-    }
-}

package/dist/firebase/firestore/utils/users/assertProfessionalUserIsBookable.util.d.ts

@@ -1,3 +0,0 @@
-import type { FirestorePlatformPublicConfigDocument, FirestoreProfessionalUserPublicDocument, FirestoreUserDocument } from "../../types";
-import type { BookableProfessionalUserDocument } from "./types";
-export declare function assertProfessionalUserIsBookable(professionalUserDocument: FirestoreUserDocument, professionalUserPublicDocument: FirestoreProfessionalUserPublicDocument, platformPublicConfigDocument: FirestorePlatformPublicConfigDocument): asserts professionalUserDocument is BookableProfessionalUserDocument;

package/dist/firebase/firestore/utils/users/assertProfessionalUserIsBookable.util.js

@@ -1,66 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertProfessionalUserIsBookable = assertProfessionalUserIsBookable;
-const semver_1 = __importDefault(require("semver"));
-const errors_1 = require("../../../../errors");
-const dataValidators_1 = require("../dataValidators");
-const enums_1 = require("../../../../enums");
-const enums_2 = require("../../enums");
-function assertProfessionalUserIsBookable(professionalUserDocument, professionalUserPublicDocument, platformPublicConfigDocument) {
-    if (professionalUserDocument.professionalInfos?.privacyPolicyPro?.acceptedAt ===
-        undefined ||
-        professionalUserDocument.professionalInfos?.privacyPolicyPro?.version ===
-            undefined ||
-        !semver_1.default.eq(professionalUserDocument.professionalInfos?.privacyPolicyPro.version, platformPublicConfigDocument.data.legal.privacyPolicyPro.version)) {
-        throw new errors_1.DoctoCarError("Professional user has not accepted the latest privacy policy", enums_2.ProfessionalNonBookableReason.USER_HAS_NOT_ACCEPTED_LATEST_PRIVACY_POLICY);
-    }
-    if (professionalUserDocument.professionalInfos?.termsOfService?.acceptedAt ===
-        undefined ||
-        professionalUserDocument.professionalInfos?.termsOfService?.version ===
-            undefined ||
-        !semver_1.default.eq(professionalUserDocument.professionalInfos?.termsOfService.version, platformPublicConfigDocument.data.legal.termsOfService.version)) {
-        throw new errors_1.DoctoCarError("Professional user has not accepted the latest terms of service", enums_2.ProfessionalNonBookableReason.USER_HAS_NOT_ACCEPTED_LATEST_TERMS_OF_USE);
-    }
-    if (!professionalUserDocument.professionalInfos?.companyDetails.vatDetails ||
-        (0, dataValidators_1.isCompanyVatValid)(professionalUserDocument.professionalInfos?.companyDetails.vatDetails) === false) {
-        throw new errors_1.DoctoCarError("Professional user company VAT details are not valid", enums_2.ProfessionalNonBookableReason.COMPANY_VAT_DETAILS_ARE_NOT_VALID);
-    }
-    if ((0, dataValidators_1.isLegalAddressValid)(professionalUserDocument.professionalInfos.companyDetails.legalAddress) === false) {
-        throw new errors_1.DoctoCarError("Professional user legal address is not valid", enums_2.ProfessionalNonBookableReason.COMPANY_LEGAL_ADDRESS_IS_NOT_VALID);
-    }
-    const legalCountry = professionalUserDocument.professionalInfos.companyDetails.legalAddress
-        .country;
-    switch (legalCountry) {
-        case enums_1.SupportedCountryIsoCodes.FRANCE: {
-            const companyRegistration = professionalUserDocument.professionalInfos.companyDetails.registration[legalCountry];
-            if (!companyRegistration ||
-                !(0, dataValidators_1.isFrenchCompanyRegistrationValid)({ registration: companyRegistration })) {
-                throw new errors_1.DoctoCarError(`Professional user company registration details for country '${legalCountry}' are not valid`, enums_2.ProfessionalNonBookableReason.COMPANY_REGISTRATION_DETAILS_ARE_NOT_VALID);
-            }
-            break;
-        }
-        default:
-            throw new errors_1.DoctoCarError(`Professional user country '${legalCountry}' is not supported`, enums_2.ProfessionalNonBookableReason.COUNTRY_IS_NOT_SUPPORTED);
-    }
-    if (professionalUserDocument.isTest !== true) {
-        const stripe = professionalUserDocument.professionalInfos?.stripe;
-        if (!stripe) {
-            throw new errors_1.DoctoCarError("Professional user Stripe account is not properly configured", enums_2.ProfessionalNonBookableReason.COMPANY_STRIPE_ACCOUNT_NOT_CONFIGURED);
-        }
-        if (!stripe.accountId ||
-            !stripe.chargesEnabled ||
-            !stripe.payoutsEnabled ||
-            !stripe.detailsSubmitted) {
-            throw new errors_1.DoctoCarError("Professional user Stripe account is not properly configured", enums_2.ProfessionalNonBookableReason.COMPANY_STRIPE_ACCOUNT_NOT_CONFIGURED);
-        }
-        if (stripe.hasDiscrepancyWithFirestore === true) {
-            throw new errors_1.DoctoCarError("Mismatch between Stripe account details and Firestore professional infos", enums_2.ProfessionalNonBookableReason.COMPANY_STRIPE_ACCOUNT_HAS_DISCREPANCY_WITH_FIRESTORE);
-        }
-    }
-    if (professionalUserPublicDocument.activeServicesVehiclesCombos.length < 1) {
-        throw new errors_1.DoctoCarError("Professional user has no active services or vehicles combos", enums_2.ProfessionalNonBookableReason.USER_HAS_NO_ACTIVE_SERVICES_VEHICLES_COMBOS);
-    }
-}

package/dist/firebase/firestore/utils/users/errors/enums/AssertCustomerUserCanBookServicesErrorCodes.enum.d.ts

@@ -1,7 +0,0 @@
-export declare enum AssertCustomerUserCanBookServicesErrorCodes {
-    USER_HAS_NOT_ACCEPTED_LATEST_PRIVACY_POLICY = "USER_HAS_NOT_ACCEPTED_LATEST_PRIVACY_POLICY",
-    USER_HAS_NOT_ACCEPTED_LATEST_TERMS_OF_USE = "USER_HAS_NOT_ACCEPTED_LATEST_TERMS_OF_USE",
-    BILLING_ADDRESS_IS_NOT_VALID = "BILLING_ADDRESS_IS_NOT_VALID",
-    LEGAL_ADDRESS_IS_NOT_VALID = "LEGAL_ADDRESS_IS_NOT_VALID",
-    USER_ONBOARDING_NOT_COMPLETED = "USER_ONBOARDING_NOT_COMPLETED"
-}

package/dist/firebase/firestore/utils/users/errors/enums/AssertCustomerUserCanBookServicesErrorCodes.enum.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AssertCustomerUserCanBookServicesErrorCodes = void 0;
-var AssertCustomerUserCanBookServicesErrorCodes;
-(function (AssertCustomerUserCanBookServicesErrorCodes) {
-    AssertCustomerUserCanBookServicesErrorCodes["USER_HAS_NOT_ACCEPTED_LATEST_PRIVACY_POLICY"] = "USER_HAS_NOT_ACCEPTED_LATEST_PRIVACY_POLICY";
-    AssertCustomerUserCanBookServicesErrorCodes["USER_HAS_NOT_ACCEPTED_LATEST_TERMS_OF_USE"] = "USER_HAS_NOT_ACCEPTED_LATEST_TERMS_OF_USE";
-    AssertCustomerUserCanBookServicesErrorCodes["BILLING_ADDRESS_IS_NOT_VALID"] = "BILLING_ADDRESS_IS_NOT_VALID";
-    AssertCustomerUserCanBookServicesErrorCodes["LEGAL_ADDRESS_IS_NOT_VALID"] = "LEGAL_ADDRESS_IS_NOT_VALID";
-    AssertCustomerUserCanBookServicesErrorCodes["USER_ONBOARDING_NOT_COMPLETED"] = "USER_ONBOARDING_NOT_COMPLETED";
-})(AssertCustomerUserCanBookServicesErrorCodes || (exports.AssertCustomerUserCanBookServicesErrorCodes = AssertCustomerUserCanBookServicesErrorCodes = {}));

package/dist/firebase/firestore/utils/users/errors/enums/index.d.ts

@@ -1 +0,0 @@
-export * from "./AssertCustomerUserCanBookServicesErrorCodes.enum";

package/dist/firebase/firestore/utils/users/errors/enums/index.js

@@ -1,17 +0,0 @@
-"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("./AssertCustomerUserCanBookServicesErrorCodes.enum"), exports);

package/dist/firebase/firestore/utils/users/errors/index.d.ts

@@ -1 +0,0 @@
-export * from "./enums";

package/dist/firebase/firestore/utils/users/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./assertCustomerUserCanBookServices";
-export * from "./assertProfessionalUserIsBookable.util";
-export * from "./errors";
-export * from "./types";

package/dist/firebase/firestore/utils/users/types/BookableProfessionalUserDocument.type.d.ts

@@ -1,35 +0,0 @@
-import type { FirestoreTimestamp, FirestoreUserDocument, FirestoreUserDocumentProfessionalInfos } from "../../../types";
-export type BookablePaymentEnabledProfessionalUserDocument = FirestoreUserDocument & {
-    isTest: false;
-    professionalInfos: FirestoreUserDocumentProfessionalInfos & {
-        privacyPolicyPro: {
-            acceptedAt: FirestoreTimestamp;
-            version: string;
-        };
-        termsOfService: {
-            acceptedAt: FirestoreTimestamp;
-            version: string;
-        };
-        stripe: {
-            accountId: string;
-            chargesEnabled: boolean;
-            payoutsEnabled: boolean;
-            detailsSubmitted: boolean;
-        };
-    };
-};
-export type BookablePaymentBypassedProfessionalUserDocument = FirestoreUserDocument & {
-    isTest: true;
-    professionalInfos: FirestoreUserDocumentProfessionalInfos & {
-        privacyPolicyPro: {
-            acceptedAt: FirestoreTimestamp;
-            version: string;
-        };
-        termsOfService: {
-            acceptedAt: FirestoreTimestamp;
-            version: string;
-        };
-        stripe?: never;
-    };
-};
-export type BookableProfessionalUserDocument = BookablePaymentEnabledProfessionalUserDocument | BookablePaymentBypassedProfessionalUserDocument;

package/dist/firebase/firestore/utils/users/types/BookingReadyCustomerUserDocument.type.d.ts

@@ -1,13 +0,0 @@
-import type { FirestoreTimestamp, FirestoreUserDocument, FirestoreUserDocumentCustomerInfos } from "../../../types";
-export type BookingReadyCustomerUserDocument = FirestoreUserDocument & {
-    customerInfos: FirestoreUserDocumentCustomerInfos & {
-        privacyPolicy: {
-            acceptedAt: FirestoreTimestamp;
-            version: string;
-        };
-        termsOfUse: {
-            acceptedAt: FirestoreTimestamp;
-            version: string;
-        };
-    };
-};

package/dist/firebase/firestore/utils/users/types/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./BookableProfessionalUserDocument.type";
-export * from "./BookingReadyCustomerUserDocument.type";

package/dist/firebase/storage/enums/FirebaseStorageProfessionalUsersPublicSubPaths.enum.d.ts

@@ -1,3 +0,0 @@
-export declare enum FirebaseStorageProfessionalUsersPublicSubPaths {
-    PROFESSIONAL_PROFILE_PICTURES = "profile-pictures/professional-profile-pictures"
-}

package/dist/firebase/storage/enums/FirebaseStorageProfessionalUsersPublicSubPaths.enum.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FirebaseStorageProfessionalUsersPublicSubPaths = void 0;
-var FirebaseStorageProfessionalUsersPublicSubPaths;
-(function (FirebaseStorageProfessionalUsersPublicSubPaths) {
-    FirebaseStorageProfessionalUsersPublicSubPaths["PROFESSIONAL_PROFILE_PICTURES"] = "profile-pictures/professional-profile-pictures";
-})(FirebaseStorageProfessionalUsersPublicSubPaths || (exports.FirebaseStorageProfessionalUsersPublicSubPaths = FirebaseStorageProfessionalUsersPublicSubPaths = {}));

package/dist/gcp/cloudTask/types/OnTaskRecomputeProfessionalBookabilityEnvelope.type.d.ts

@@ -1,4 +0,0 @@
-import type { OnTaskEnvelope } from "./OnTaskEnvelope.type";
-export type OnTaskRecomputeProfessionalBookabilityEnvelope = OnTaskEnvelope<{
-    professionalUserId: string;
-}>;

package/dist/gcp/cloudTask/utils/stubs/onTaskRecomputeProfessionalBookabilityEnvelopeStub.d.ts

@@ -1,2 +0,0 @@
-import type { OnTaskRecomputeProfessionalBookabilityEnvelope } from "../../types";
-export declare function onTaskRecomputeProfessionalBookabilityEnvelopeStub(overwrite?: Partial<OnTaskRecomputeProfessionalBookabilityEnvelope>): OnTaskRecomputeProfessionalBookabilityEnvelope;

package/dist/gcp/geocode/utils/getCountryISOCodeFromGoogleGeocodeAddressComponents.util.d.ts

@@ -1,2 +0,0 @@
-import type { GeocodeResponseResultDataAddressComponent } from "../types";
-export declare function getCountryISOCodeFromGoogleGeocodeAddressComponents(addressComponents: GeocodeResponseResultDataAddressComponent[]): string | null;