@doctocar/tooling 0.3.1-16 → 0.3.1-17

package/dist/firebase/firestore/utils/services/__tests__/getAvailableServiceProviderServicesForVehicleType.test.js

@@ -0,0 +1,295 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const __1 = require("../../../../..");
+const enums_1 = require("../../../enums");
+const configs_1 = require("../../configs");
+const stubs_1 = require("../../stubs");
+const getAvailableServiceProviderServicesTypesForVehicleType_1 = require("../getAvailableServiceProviderServicesTypesForVehicleType");
+jest.mock("../../configs", () => ({
+    getAvailableServicesPublicConfigForVehicleType: jest.fn(),
+}));
+describe("getAvailableServiceProviderServicesTypesForVehicleType", () => {
+    let getAvailableServicesPublicConfigForVehicleTypeMock;
+    let getAvailableServicesPublicConfigForVehicleTypeReturn;
+    let serviceProviderUserPublicDocument;
+    beforeEach(() => {
+        getAvailableServicesPublicConfigForVehicleTypeMock =
+            configs_1.getAvailableServicesPublicConfigForVehicleType;
+        getAvailableServicesPublicConfigForVehicleTypeReturn = {
+            mainServicesPublicConfigList: [],
+            subServicesPublicConfigList: [],
+        };
+        getAvailableServicesPublicConfigForVehicleTypeMock.mockReturnValue(getAvailableServicesPublicConfigForVehicleTypeReturn);
+        serviceProviderUserPublicDocument =
+            (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
+                professionalServices: {
+                    [enums_1.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                        isActive: true,
+                        pricingAndDurationByVehicleType: {
+                            [enums_1.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                                type: enums_1.VehicleTypes.SEDAN,
+                                isActive: true,
+                                pricePreTaxInCents: 2_000,
+                                durationInMinutes: 30,
+                                currency: __1.SupportedIsoCurrency.EUR,
+                            }),
+                        },
+                    }),
+                },
+            });
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    it("delegates service config filtering by vehicle type", () => {
+        (0, getAvailableServiceProviderServicesTypesForVehicleType_1.getAvailableServiceProviderServicesTypesForVehicleType)({
+            countryServicesPublicConfig: {},
+            professionalUserPublicDocument: serviceProviderUserPublicDocument,
+            vehicleType: enums_1.VehicleTypes.SEDAN,
+        });
+        expect(getAvailableServicesPublicConfigForVehicleTypeMock).toHaveBeenCalledWith({
+            countryServicesPublicConfig: {},
+            vehicleType: enums_1.VehicleTypes.SEDAN,
+        });
+    });
+    it("returns empty arrays when config helper returns no services", () => {
+        const result = (0, getAvailableServiceProviderServicesTypesForVehicleType_1.getAvailableServiceProviderServicesTypesForVehicleType)({
+            countryServicesPublicConfig: {},
+            professionalUserPublicDocument: serviceProviderUserPublicDocument,
+            vehicleType: enums_1.VehicleTypes.SEDAN,
+        });
+        expect(result).toEqual({
+            mainAvailableServicesTypes: [],
+            subAvailableServicesTypes: [],
+        });
+    });
+    it("keeps matching active main and sub services", () => {
+        const exteriorCleaning = (0, stubs_1.firestoreServicesPublicConfigStub)({
+            type: enums_1.ServicesTypes.EXTERIOR_CLEANING,
+            parentsServices: [],
+        });
+        const carpetShampoo = (0, stubs_1.firestoreServicesPublicConfigStub)({
+            type: enums_1.ServicesTypes.CARPET_SHAMPOO,
+            parentsServices: [enums_1.ServicesTypes.INTERIOR_CLEANING],
+        });
+        getAvailableServicesPublicConfigForVehicleTypeReturn = {
+            mainServicesPublicConfigList: [exteriorCleaning],
+            subServicesPublicConfigList: [carpetShampoo],
+        };
+        getAvailableServicesPublicConfigForVehicleTypeMock.mockReturnValue(getAvailableServicesPublicConfigForVehicleTypeReturn);
+        serviceProviderUserPublicDocument =
+            (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
+                professionalServices: {
+                    [enums_1.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                        isActive: true,
+                        pricingAndDurationByVehicleType: {
+                            [enums_1.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                                isActive: true,
+                            }),
+                        },
+                    }),
+                    [enums_1.ServicesTypes.CARPET_SHAMPOO]: (0, stubs_1.professionalServiceStub)({
+                        isActive: true,
+                        pricingAndDurationByVehicleType: {
+                            [enums_1.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                                isActive: true,
+                            }),
+                        },
+                    }),
+                },
+            });
+        const result = (0, getAvailableServiceProviderServicesTypesForVehicleType_1.getAvailableServiceProviderServicesTypesForVehicleType)({
+            countryServicesPublicConfig: {},
+            professionalUserPublicDocument: serviceProviderUserPublicDocument,
+            vehicleType: enums_1.VehicleTypes.SEDAN,
+        });
+        expect(result.mainAvailableServicesTypes).toEqual([
+            enums_1.ServicesTypes.EXTERIOR_CLEANING,
+        ]);
+        expect(result.subAvailableServicesTypes).toEqual([
+            enums_1.ServicesTypes.CARPET_SHAMPOO,
+        ]);
+    });
+    it("filters out services not offered by the service provider", () => {
+        const unavailableForServiceProvider = (0, stubs_1.firestoreServicesPublicConfigStub)({
+            type: enums_1.ServicesTypes.ANIMAL_HAIR_TREATMENT,
+        });
+        getAvailableServicesPublicConfigForVehicleTypeReturn = {
+            mainServicesPublicConfigList: [unavailableForServiceProvider],
+            subServicesPublicConfigList: [],
+        };
+        getAvailableServicesPublicConfigForVehicleTypeMock.mockReturnValue(getAvailableServicesPublicConfigForVehicleTypeReturn);
+        const result = (0, getAvailableServiceProviderServicesTypesForVehicleType_1.getAvailableServiceProviderServicesTypesForVehicleType)({
+            countryServicesPublicConfig: {},
+            professionalUserPublicDocument: serviceProviderUserPublicDocument,
+            vehicleType: enums_1.VehicleTypes.SEDAN,
+        });
+        expect(result.mainAvailableServicesTypes).toEqual([]);
+    });
+    it("filters out services disabled at service provider level", () => {
+        const exteriorCleaning = (0, stubs_1.firestoreServicesPublicConfigStub)({
+            type: enums_1.ServicesTypes.EXTERIOR_CLEANING,
+        });
+        getAvailableServicesPublicConfigForVehicleTypeReturn = {
+            mainServicesPublicConfigList: [exteriorCleaning],
+            subServicesPublicConfigList: [],
+        };
+        getAvailableServicesPublicConfigForVehicleTypeMock.mockReturnValue(getAvailableServicesPublicConfigForVehicleTypeReturn);
+        serviceProviderUserPublicDocument =
+            (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
+                professionalServices: {
+                    [enums_1.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                        isActive: false,
+                    }),
+                },
+            });
+        const result = (0, getAvailableServiceProviderServicesTypesForVehicleType_1.getAvailableServiceProviderServicesTypesForVehicleType)({
+            countryServicesPublicConfig: {},
+            professionalUserPublicDocument: serviceProviderUserPublicDocument,
+            vehicleType: enums_1.VehicleTypes.SEDAN,
+        });
+        expect(result.mainAvailableServicesTypes).toEqual([]);
+    });
+    it("filters out services with missing pricing for the requested vehicle type", () => {
+        const exteriorCleaning = (0, stubs_1.firestoreServicesPublicConfigStub)({
+            type: enums_1.ServicesTypes.EXTERIOR_CLEANING,
+        });
+        getAvailableServicesPublicConfigForVehicleTypeReturn = {
+            mainServicesPublicConfigList: [exteriorCleaning],
+            subServicesPublicConfigList: [],
+        };
+        getAvailableServicesPublicConfigForVehicleTypeMock.mockReturnValue(getAvailableServicesPublicConfigForVehicleTypeReturn);
+        serviceProviderUserPublicDocument =
+            (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
+                professionalServices: {
+                    [enums_1.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                        isActive: true,
+                        pricingAndDurationByVehicleType: {
+                            [enums_1.VehicleTypes.SUV]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                                type: enums_1.VehicleTypes.SUV,
+                                isActive: true,
+                            }),
+                        },
+                    }),
+                },
+            });
+        const result = (0, getAvailableServiceProviderServicesTypesForVehicleType_1.getAvailableServiceProviderServicesTypesForVehicleType)({
+            countryServicesPublicConfig: {},
+            professionalUserPublicDocument: serviceProviderUserPublicDocument,
+            vehicleType: enums_1.VehicleTypes.SEDAN,
+        });
+        expect(result.mainAvailableServicesTypes).toEqual([]);
+    });
+    it("filters out services with inactive pricing for the requested vehicle type", () => {
+        const exteriorCleaning = (0, stubs_1.firestoreServicesPublicConfigStub)({
+            type: enums_1.ServicesTypes.EXTERIOR_CLEANING,
+        });
+        getAvailableServicesPublicConfigForVehicleTypeReturn = {
+            mainServicesPublicConfigList: [exteriorCleaning],
+            subServicesPublicConfigList: [],
+        };
+        getAvailableServicesPublicConfigForVehicleTypeMock.mockReturnValue(getAvailableServicesPublicConfigForVehicleTypeReturn);
+        serviceProviderUserPublicDocument =
+            (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
+                professionalServices: {
+                    [enums_1.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                        isActive: true,
+                        pricingAndDurationByVehicleType: {
+                            [enums_1.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                                type: enums_1.VehicleTypes.SEDAN,
+                                isActive: false,
+                            }),
+                        },
+                    }),
+                },
+            });
+        const result = (0, getAvailableServiceProviderServicesTypesForVehicleType_1.getAvailableServiceProviderServicesTypesForVehicleType)({
+            countryServicesPublicConfig: {},
+            professionalUserPublicDocument: serviceProviderUserPublicDocument,
+            vehicleType: enums_1.VehicleTypes.SEDAN,
+        });
+        expect(result.mainAvailableServicesTypes).toEqual([]);
+    });
+    it("preserves service order from vehicle-filtered configuration", () => {
+        const firstService = (0, stubs_1.firestoreServicesPublicConfigStub)({
+            type: enums_1.ServicesTypes.EXTERIOR_CLEANING,
+        });
+        const secondService = (0, stubs_1.firestoreServicesPublicConfigStub)({
+            type: enums_1.ServicesTypes.INTERIOR_CLEANING,
+        });
+        getAvailableServicesPublicConfigForVehicleTypeReturn = {
+            mainServicesPublicConfigList: [firstService, secondService],
+            subServicesPublicConfigList: [],
+        };
+        getAvailableServicesPublicConfigForVehicleTypeMock.mockReturnValue(getAvailableServicesPublicConfigForVehicleTypeReturn);
+        serviceProviderUserPublicDocument =
+            (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
+                professionalServices: {
+                    [enums_1.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                        isActive: true,
+                        pricingAndDurationByVehicleType: {
+                            [enums_1.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                                isActive: true,
+                            }),
+                        },
+                    }),
+                    [enums_1.ServicesTypes.INTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                        isActive: true,
+                        pricingAndDurationByVehicleType: {
+                            [enums_1.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                                isActive: true,
+                            }),
+                        },
+                    }),
+                },
+            });
+        const result = (0, getAvailableServiceProviderServicesTypesForVehicleType_1.getAvailableServiceProviderServicesTypesForVehicleType)({
+            countryServicesPublicConfig: {},
+            professionalUserPublicDocument: serviceProviderUserPublicDocument,
+            vehicleType: enums_1.VehicleTypes.SEDAN,
+        });
+        expect(result.mainAvailableServicesTypes).toEqual([
+            enums_1.ServicesTypes.EXTERIOR_CLEANING,
+            enums_1.ServicesTypes.INTERIOR_CLEANING,
+        ]);
+    });
+    it("does not include extra professional services not present in filtered config", () => {
+        const exteriorCleaning = (0, stubs_1.firestoreServicesPublicConfigStub)({
+            type: enums_1.ServicesTypes.EXTERIOR_CLEANING,
+        });
+        getAvailableServicesPublicConfigForVehicleTypeReturn = {
+            mainServicesPublicConfigList: [exteriorCleaning],
+            subServicesPublicConfigList: [],
+        };
+        getAvailableServicesPublicConfigForVehicleTypeMock.mockReturnValue(getAvailableServicesPublicConfigForVehicleTypeReturn);
+        serviceProviderUserPublicDocument =
+            (0, stubs_1.firestoreProfessionalUserPublicDocumentStub)({
+                professionalServices: {
+                    [enums_1.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.professionalServiceStub)({
+                        isActive: true,
+                        pricingAndDurationByVehicleType: {
+                            [enums_1.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                                isActive: true,
+                            }),
+                        },
+                    }),
+                    [enums_1.ServicesTypes.CARPET_SHAMPOO]: (0, stubs_1.professionalServiceStub)({
+                        isActive: true,
+                        pricingAndDurationByVehicleType: {
+                            [enums_1.VehicleTypes.SEDAN]: (0, stubs_1.pricingAndDurationForVehicleStub)({
+                                isActive: true,
+                            }),
+                        },
+                    }),
+                },
+            });
+        const result = (0, getAvailableServiceProviderServicesTypesForVehicleType_1.getAvailableServiceProviderServicesTypesForVehicleType)({
+            countryServicesPublicConfig: {},
+            professionalUserPublicDocument: serviceProviderUserPublicDocument,
+            vehicleType: enums_1.VehicleTypes.SEDAN,
+        });
+        expect(result.mainAvailableServicesTypes).toEqual([
+            enums_1.ServicesTypes.EXTERIOR_CLEANING,
+        ]);
+    });
+});

package/dist/firebase/firestore/utils/services/areAllRequestedProfessionalUserServicesActiveForVehicleType.d.ts

@@ -0,0 +1,2 @@
+import type { AreAllRequestedProfessionalUserServicesActiveForVehicleTypeArgs } from "./types";
+export declare function areAllRequestedProfessionalUserServicesActiveForVehicleType({ servicesTypes, professionalServices, vehicleType, }: AreAllRequestedProfessionalUserServicesActiveForVehicleTypeArgs): boolean;

package/dist/firebase/firestore/utils/services/areAllRequestedProfessionalUserServicesActiveForVehicleType.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.areAllRequestedProfessionalUserServicesActiveForVehicleType = areAllRequestedProfessionalUserServicesActiveForVehicleType;
+function areAllRequestedProfessionalUserServicesActiveForVehicleType({ servicesTypes, professionalServices, vehicleType, }) {
+    for (const serviceType of new Set(servicesTypes)) {
+        const professionalService = professionalServices?.[serviceType];
+        if (professionalService?.isActive !== true)
+            return false;
+        const perVehicule = professionalService.pricingAndDurationByVehicleType?.[vehicleType];
+        if (perVehicule?.isActive !== true)
+            return false;
+    }
+    return true;
+}

package/dist/firebase/firestore/utils/services/areAllRequestedProfessionalUserServicesActiveForVehicleType.util.d.ts

@@ -0,0 +1,2 @@
+import type { AreAllRequestedProfessionalUserServicesActiveForVehicleTypeArgs } from "./types";
+export declare function areAllRequestedProfessionalUserServicesActiveForVehicleType({ servicesTypes, professionalServices, vehicleType, }: AreAllRequestedProfessionalUserServicesActiveForVehicleTypeArgs): boolean;

package/dist/firebase/firestore/utils/services/areAllRequestedProfessionalUserServicesActiveForVehicleType.util.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.areAllRequestedProfessionalUserServicesActiveForVehicleType = areAllRequestedProfessionalUserServicesActiveForVehicleType;
+function areAllRequestedProfessionalUserServicesActiveForVehicleType({ servicesTypes, professionalServices, vehicleType, }) {
+    for (const serviceType of new Set(servicesTypes)) {
+        const professionalService = professionalServices?.[serviceType];
+        if (professionalService?.isActive !== true)
+            return false;
+        const perVehicule = professionalService.pricingAndDurationByVehicleType?.[vehicleType];
+        if (perVehicule?.isActive !== true)
+            return false;
+    }
+    return true;
+}

package/dist/firebase/firestore/utils/services/computeTotalProfessionalServiceDurationInMinutesForVehicleType.util.d.ts

@@ -0,0 +1,2 @@
+import type { ComputeTotalProfessionalServiceDurationInMinutesForVehicleTypeArgs } from "./types";
+export declare function computeTotalProfessionalServiceDurationInMinutesForVehicleType({ servicesTypes, professionalServices, vehicleType, }: ComputeTotalProfessionalServiceDurationInMinutesForVehicleTypeArgs): number;

package/dist/firebase/firestore/utils/services/computeTotalProfessionalServiceDurationInMinutesForVehicleType.util.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeTotalProfessionalServiceDurationInMinutesForVehicleType = computeTotalProfessionalServiceDurationInMinutesForVehicleType;
+function computeTotalProfessionalServiceDurationInMinutesForVehicleType({ servicesTypes, professionalServices, vehicleType, }) {
+    let totalServiceDurationInMinutes = 0;
+    for (const serviceType of servicesTypes) {
+        if (!professionalServices?.[serviceType]?.pricingAndDurationByVehicleType?.[vehicleType]?.durationInMinutes) {
+            throw new Error(`computeTotalProfessionalServiceDurationInMinutes: Service type ${serviceType} not found for vehicle type ${vehicleType}`);
+        }
+        else {
+            totalServiceDurationInMinutes +=
+                professionalServices[serviceType].pricingAndDurationByVehicleType[vehicleType].durationInMinutes;
+        }
+    }
+    return totalServiceDurationInMinutes;
+}

package/dist/firebase/firestore/utils/services/createProfessionalServiceVehicleComboKey.d.ts

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

package/dist/firebase/firestore/utils/services/createProfessionalServiceVehicleComboKey.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProfessionalServiceVehicleComboKey = createProfessionalServiceVehicleComboKey;
+function createProfessionalServiceVehicleComboKey(professionalServiceType, vehicleType) {
+    return `${professionalServiceType}_${vehicleType}`;
+}

package/dist/firebase/firestore/utils/services/createProfessionalServiceVehicleComboKey.util.d.ts

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

package/dist/firebase/firestore/utils/services/createProfessionalServiceVehicleComboKey.util.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProfessionalServiceVehicleComboKey = createProfessionalServiceVehicleComboKey;
+function createProfessionalServiceVehicleComboKey(professionalServiceType, vehicleType) {
+    return `${professionalServiceType}_${vehicleType}`;
+}

package/dist/firebase/firestore/utils/services/getActiveProfessionalServicePricingAndDurationForVehicleOrThrow.d.ts

@@ -0,0 +1,3 @@
+import type { ServicePricingAndDurationForVehicle } from "../../types";
+import type { GetActiveProfessionalServicePricingAndDurationForVehicleOrThrowParams } from "./types";
+export declare function getActiveProfessionalServicePricingAndDurationForVehicleOrThrow({ professionalUserPublicDocument, professionalServiceType, vehicleType, }: GetActiveProfessionalServicePricingAndDurationForVehicleOrThrowParams): ServicePricingAndDurationForVehicle;

package/dist/firebase/firestore/utils/services/getActiveProfessionalServicePricingAndDurationForVehicleOrThrow.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getActiveProfessionalServicePricingAndDurationForVehicleOrThrow = getActiveProfessionalServicePricingAndDurationForVehicleOrThrow;
+function getActiveProfessionalServicePricingAndDurationForVehicleOrThrow({ professionalUserPublicDocument, professionalServiceType, vehicleType, }) {
+    const professionalService = professionalUserPublicDocument.professionalServices?.[professionalServiceType];
+    if (!professionalService || !professionalService.isActive) {
+        throw new Error(`Service “${professionalServiceType}” is not offered by this professional.`);
+    }
+    const pricingAndDurationForVehicle = professionalService.pricingAndDurationByVehicleType?.[vehicleType];
+    if (!pricingAndDurationForVehicle ||
+        !pricingAndDurationForVehicle.isActive ||
+        !pricingAndDurationForVehicle.type ||
+        !pricingAndDurationForVehicle.pricePreTaxInCents ||
+        !pricingAndDurationForVehicle.durationInMinutes ||
+        !pricingAndDurationForVehicle.currency) {
+        throw new Error(`Service “${professionalServiceType}” is not available for vehicle type “${vehicleType}”.`);
+    }
+    return pricingAndDurationForVehicle;
+}

package/dist/firebase/firestore/utils/services/getActiveServicePricingAndDurationForVehicleOrThrow.d.ts

@@ -0,0 +1,3 @@
+import type { ServicePricingAndDurationForVehicle } from "../../types";
+import type { GetActiveServicePricingAndDurationForVehicleOrThrowParams } from "./types";
+export declare function getActiveServicePricingAndDurationForVehicleOrThrow({ professionalUserPublicDocument, serviceType, vehicleType, }: GetActiveServicePricingAndDurationForVehicleOrThrowParams): ServicePricingAndDurationForVehicle;

package/dist/firebase/firestore/utils/services/getActiveServicePricingAndDurationForVehicleOrThrow.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getActiveServicePricingAndDurationForVehicleOrThrow = getActiveServicePricingAndDurationForVehicleOrThrow;
+function getActiveServicePricingAndDurationForVehicleOrThrow({ professionalUserPublicDocument, serviceType, vehicleType, }) {
+    const service = professionalUserPublicDocument.professionalServices?.[serviceType];
+    if (!service || !service.isActive) {
+        throw new Error(`Service “${serviceType}” is not offered by this professional.`);
+    }
+    const pricingAndDurationForVehicle = service.pricingAndDurationByVehicleType?.[vehicleType];
+    if (!pricingAndDurationForVehicle ||
+        !pricingAndDurationForVehicle.isActive ||
+        !pricingAndDurationForVehicle.type ||
+        !pricingAndDurationForVehicle.pricePreTaxInCents ||
+        !pricingAndDurationForVehicle.durationInMinutes ||
+        !pricingAndDurationForVehicle.currency) {
+        throw new Error(`Service “${serviceType}” is not available for vehicle type “${vehicleType}”.`);
+    }
+    return pricingAndDurationForVehicle;
+}

package/dist/firebase/firestore/utils/services/getActiveServiceProviderServicePricingAndDurationForVehicleOrThrow.d.ts

@@ -0,0 +1,3 @@
+import type { ServicePricingAndDurationForVehicle } from "../../types";
+import type { GetActiveServiceProviderServicePricingAndDurationForVehicleOrThrowParams } from "./types";
+export declare function getActiveServiceProviderServicePricingAndDurationForVehicleOrThrow({ professionalUserPublicDocument, serviceType, vehicleType, }: GetActiveServiceProviderServicePricingAndDurationForVehicleOrThrowParams): ServicePricingAndDurationForVehicle;

package/dist/firebase/firestore/utils/services/getActiveServiceProviderServicePricingAndDurationForVehicleOrThrow.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getActiveServiceProviderServicePricingAndDurationForVehicleOrThrow = getActiveServiceProviderServicePricingAndDurationForVehicleOrThrow;
+function getActiveServiceProviderServicePricingAndDurationForVehicleOrThrow({ professionalUserPublicDocument, serviceType, vehicleType, }) {
+    const professionalService = professionalUserPublicDocument.professionalServices?.[serviceType];
+    if (!professionalService || !professionalService.isActive) {
+        throw new Error(`Service “${serviceType}” is not offered by this professional.`);
+    }
+    const pricingAndDurationForVehicle = professionalService.pricingAndDurationByVehicleType?.[vehicleType];
+    if (!pricingAndDurationForVehicle ||
+        !pricingAndDurationForVehicle.isActive ||
+        !pricingAndDurationForVehicle.type ||
+        !pricingAndDurationForVehicle.pricePreTaxInCents ||
+        !pricingAndDurationForVehicle.durationInMinutes ||
+        !pricingAndDurationForVehicle.currency) {
+        throw new Error(`Service “${serviceType}” is not available for vehicle type “${vehicleType}”.`);
+    }
+    return pricingAndDurationForVehicle;
+}

package/dist/firebase/firestore/utils/services/getAvailableServiceProviderServicesForVehicleType.d.ts

@@ -0,0 +1,6 @@
+import type { FirestoreServicesPublicConfig } from "../../types";
+import type { GetAvailableServiceProviderServicesForVehicleTypeParams } from "./types";
+export declare function getAvailableServiceProviderServicesForVehicleType({ countryServicesPublicConfig, professionalUserPublicDocument, vehicleType, }: GetAvailableServiceProviderServicesForVehicleTypeParams): {
+    mainServices: FirestoreServicesPublicConfig[];
+    subServices: FirestoreServicesPublicConfig[];
+};

package/dist/firebase/firestore/utils/services/getAvailableServiceProviderServicesForVehicleType.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAvailableServiceProviderServicesForVehicleType = getAvailableServiceProviderServicesForVehicleType;
+const configs_1 = require("../configs");
+function getAvailableServiceProviderServicesForVehicleType({ countryServicesPublicConfig, professionalUserPublicDocument, vehicleType, }) {
+    const { mainServicesPublicConfig, subServicesPublicConfig } = (0, configs_1.getAvailableServicesPublicConfigForVehicleType)({
+        countryServicesPublicConfig,
+        vehicleType,
+    });
+    const filterByServiceProviderActiveServices = (servicesPublicConfig) => {
+        return servicesPublicConfig.filter((servicePublicConfig) => {
+            const professionalService = professionalUserPublicDocument.professionalServices[servicePublicConfig.type];
+            if (!professionalService)
+                return false;
+            if (!professionalService.isActive)
+                return false;
+            const pricingAndDurationForVehicle = professionalService.pricingAndDurationByVehicleType[vehicleType];
+            if (!pricingAndDurationForVehicle)
+                return false;
+            if (!pricingAndDurationForVehicle.isActive)
+                return false;
+            return true;
+        });
+    };
+    return {
+        mainServices: filterByServiceProviderActiveServices(mainServicesPublicConfig),
+        subServices: filterByServiceProviderActiveServices(subServicesPublicConfig),
+    };
+}

package/dist/firebase/firestore/utils/services/getAvailableServiceProviderServicesTypesForVehicleType.d.ts

@@ -0,0 +1,6 @@
+import type { ServicesTypes } from "../../../..";
+import type { GetAvailableServiceProviderServicesTypesForVehicleTypeParams } from "./types";
+export declare function getAvailableServiceProviderServicesTypesForVehicleType({ countryServicesPublicConfig, professionalUserPublicDocument, vehicleType, }: GetAvailableServiceProviderServicesTypesForVehicleTypeParams): {
+    mainAvailableServicesTypes: ServicesTypes[];
+    subAvailableServicesTypes: ServicesTypes[];
+};

package/dist/firebase/firestore/utils/services/getAvailableServiceProviderServicesTypesForVehicleType.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAvailableServiceProviderServicesTypesForVehicleType = getAvailableServiceProviderServicesTypesForVehicleType;
+const configs_1 = require("../configs");
+function getAvailableServiceProviderServicesTypesForVehicleType({ countryServicesPublicConfig, professionalUserPublicDocument, vehicleType, }) {
+    const { mainServicesPublicConfigList, subServicesPublicConfigList } = (0, configs_1.getAvailableServicesPublicConfigForVehicleType)({
+        countryServicesPublicConfig,
+        vehicleType,
+    });
+    const configMainAvailableServicesTypes = mainServicesPublicConfigList.map((servicePublicConfig) => servicePublicConfig.type);
+    const configSubAvailableServicesTypes = subServicesPublicConfigList.map((servicePublicConfig) => servicePublicConfig.type);
+    const filterByServiceProviderActiveServices = (servicesTypes) => {
+        return servicesTypes.filter((serviceType) => {
+            const professionalService = professionalUserPublicDocument.professionalServices[serviceType];
+            if (!professionalService)
+                return false;
+            if (!professionalService.isActive)
+                return false;
+            const pricingAndDurationForVehicle = professionalService.pricingAndDurationByVehicleType[vehicleType];
+            if (!pricingAndDurationForVehicle)
+                return false;
+            if (!pricingAndDurationForVehicle.isActive)
+                return false;
+            return true;
+        });
+    };
+    return {
+        mainAvailableServicesTypes: filterByServiceProviderActiveServices(configMainAvailableServicesTypes),
+        subAvailableServicesTypes: filterByServiceProviderActiveServices(configSubAvailableServicesTypes),
+    };
+}

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

@@ -0,0 +1,7 @@
+import type { ServicesTypes, VehicleTypes } from "../../../enums";
+import type { FirestoreProfessionalUserPublicDocument } from "../../../types";
+export type AreAllRequestedProfessionalUserServicesActiveForVehicleTypeArgs = {
+    professionalServices: FirestoreProfessionalUserPublicDocument["professionalServices"];
+    servicesTypes: ServicesTypes[];
+    vehicleType: VehicleTypes;
+};

package/dist/firebase/firestore/utils/services/types/AreAllRequestedProfessionalUserServicesActiveForVehicleTypeArgs.type..js

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

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

@@ -0,0 +1,7 @@
+import type { ServicesTypes, VehicleTypes } from "../../../enums";
+import type { FirestoreProfessionalUserPublicDocument } from "../../../types";
+export type GetActiveProfessionalServicePricingAndDurationForVehicleOrThrowParams = {
+    professionalUserPublicDocument: FirestoreProfessionalUserPublicDocument;
+    professionalServiceType: ServicesTypes;
+    vehicleType: VehicleTypes;
+};

package/dist/firebase/firestore/utils/services/types/GetActiveProfessionalServicePricingAndDurationForVehicleOrThrowParams.type.js

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

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

@@ -0,0 +1,7 @@
+import type { ServicesTypes, VehicleTypes } from "../../../enums";
+import type { FirestoreProfessionalUserPublicDocument } from "../../../types";
+export type GetActiveServicePricingAndDurationForVehicleOrThrowParams = {
+    professionalUserPublicDocument: FirestoreProfessionalUserPublicDocument;
+    serviceType: ServicesTypes;
+    vehicleType: VehicleTypes;
+};

package/dist/firebase/firestore/utils/services/types/GetActiveServicePricingAndDurationForVehicleOrThrowParams.type.js

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

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

@@ -0,0 +1,7 @@
+import type { ServicesTypes, VehicleTypes } from "../../../enums";
+import type { FirestoreProfessionalUserPublicDocument } from "../../../types";
+export type GetActiveServiceProviderServicePricingAndDurationForVehicleOrThrowParams = {
+    professionalUserPublicDocument: FirestoreProfessionalUserPublicDocument;
+    serviceType: ServicesTypes;
+    vehicleType: VehicleTypes;
+};

package/dist/firebase/firestore/utils/services/types/GetActiveServiceProviderServicePricingAndDurationForVehicleOrThrowParams.type.js

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

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

@@ -0,0 +1,7 @@
+import type { VehicleTypes } from "../../../enums";
+import type { CountryServicesPublicConfig, FirestoreProfessionalUserPublicDocument } from "../../../types";
+export type GetAvailableServiceProviderServicesForVehicleTypeParams = {
+    countryServicesPublicConfig: CountryServicesPublicConfig;
+    professionalUserPublicDocument: FirestoreProfessionalUserPublicDocument;
+    vehicleType: VehicleTypes;
+};

package/dist/firebase/firestore/utils/services/types/GetAvailableServiceProviderServicesForVehicleTypeParams.type.js

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

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

@@ -0,0 +1,7 @@
+import type { VehicleTypes } from "../../../enums";
+import type { CountryServicesPublicConfig, FirestoreProfessionalUserPublicDocument } from "../../../types";
+export type GetAvailableServiceProviderServicesTypesForVehicleTypeParams = {
+    countryServicesPublicConfig: CountryServicesPublicConfig;
+    professionalUserPublicDocument: FirestoreProfessionalUserPublicDocument;
+    vehicleType: VehicleTypes;
+};

package/dist/firebase/firestore/utils/services/types/GetAvailableServiceProviderServicesTypesForVehicleTypeParams.type.js

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

package/dist/firebase/firestore/utils/stubs/company/customerCompanyDetailsStub.d.ts

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