@doctocar/tooling 0.3.1-5 → 0.3.1-7

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

@@ -1,219 +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 stubs_1 = require("../../../stubs");
-const isValidProfessionalService_1 = require("../isValidProfessionalService");
-const isValidProfessionalServicePricingAndDurationForVehicle_1 = require("../isValidProfessionalServicePricingAndDurationForVehicle");
-const isValidVehicleForProfessionalService_1 = require("../isValidVehicleForProfessionalService");
-jest.mock("../isValidVehicleForProfessionalService");
-jest.mock("../isValidProfessionalServicePricingAndDurationForVehicle");
-describe("isValidProfessionalService", () => {
-    let defaultProps;
-    let isValidVehicleForProfessionalServiceMock;
-    let isValidVehicleForProfessionalServiceReturnValue;
-    let isValidProfessionalServicePricingAndDurationForVehicleMock;
-    let isValidProfessionalServicePricingAndDurationForVehicleReturnValue;
-    beforeEach(() => {
-        defaultProps = {
-            professionalService: {
-                isActive: true,
-                type: enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING,
-                pricingAndDurationByVehicleType: {
-                    [enums_2.VehicleTypes.SEDAN]: {
-                        isActive: true,
-                        type: enums_2.VehicleTypes.SEDAN,
-                        pricePreTaxInCents: 2000,
-                        currency: enums_1.SupportedIsoCurrency.EUR,
-                        durationInMinutes: 30,
-                    },
-                },
-            },
-            countryProfessionalServicePublicConfig: (0, stubs_1.countryServicesPublicConfigStub)({
-                [enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.firestoreServicesPublicConfigStub)({}),
-            }),
-        };
-        isValidVehicleForProfessionalServiceMock =
-            isValidVehicleForProfessionalService_1.isValidVehicleForProfessionalService;
-        isValidVehicleForProfessionalServiceReturnValue = true;
-        isValidVehicleForProfessionalServiceMock.mockImplementation(() => {
-            return isValidVehicleForProfessionalServiceReturnValue;
-        });
-        isValidProfessionalServicePricingAndDurationForVehicleMock =
-            isValidProfessionalServicePricingAndDurationForVehicle_1.isValidProfessionalServicePricingAndDurationForVehicle;
-        isValidProfessionalServicePricingAndDurationForVehicleReturnValue = true;
-        isValidProfessionalServicePricingAndDurationForVehicleMock.mockImplementation(() => {
-            return isValidProfessionalServicePricingAndDurationForVehicleReturnValue;
-        });
-    });
-    afterEach(() => {
-        jest.clearAllMocks();
-    });
-    it("should not throw if is a valid service with empty pricing and empty subservice", async () => {
-        await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).resolves.not.toThrow();
-    });
-    describe("Active", () => {
-        it("should throw if the active field is not a boolean", async () => {
-            defaultProps.professionalService.isActive = "yes";
-            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow(new errors_1.DoctoCarError("Professional service is active is required and must be a boolean", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_IS_ACTIVE));
-            expect(isValidProfessionalServicePricingAndDurationForVehicleMock).not.toHaveBeenCalled();
-            expect(isValidVehicleForProfessionalServiceMock).not.toHaveBeenCalled();
-        });
-        it("should throw if the active field is not provided", async () => {
-            defaultProps.professionalService.isActive = undefined;
-            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow(new errors_1.DoctoCarError("Professional service is active is required and must be a boolean", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_IS_ACTIVE));
-            expect(isValidProfessionalServicePricingAndDurationForVehicleMock).not.toHaveBeenCalled();
-            expect(isValidVehicleForProfessionalServiceMock).not.toHaveBeenCalled();
-        });
-    });
-    describe("Service type", () => {
-        it("should throw if the service type is not a valid ProfessionalServicesTypes", async () => {
-            defaultProps.professionalService.type = "INVALID_TYPE";
-            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow();
-            expect(isValidProfessionalServicePricingAndDurationForVehicleMock).not.toHaveBeenCalled();
-            expect(isValidVehicleForProfessionalServiceMock).not.toHaveBeenCalled();
-        });
-        it("should throw if the type is not provided", async () => {
-            defaultProps.professionalService.type = undefined;
-            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow();
-            expect(isValidProfessionalServicePricingAndDurationForVehicleMock).not.toHaveBeenCalled();
-            expect(isValidVehicleForProfessionalServiceMock).not.toHaveBeenCalled();
-        });
-    });
-    describe("Professional service public config", () => {
-        it("should throw if the professional service public config is not defined for the professional service type", async () => {
-            defaultProps.countryProfessionalServicePublicConfig = {};
-            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow(new errors_1.DoctoCarError("Professional service public config is not defined for the professional service type", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_TYPE));
-            expect(isValidProfessionalServicePricingAndDurationForVehicleMock).not.toHaveBeenCalled();
-            expect(isValidVehicleForProfessionalServiceMock).not.toHaveBeenCalled();
-        });
-    });
-    describe("Vehicle type", () => {
-        it("should throw if isValidVehicleForProfessionalService return false", async () => {
-            isValidVehicleForProfessionalServiceReturnValue = false;
-            isValidVehicleForProfessionalServiceMock.mockReturnValue(isValidVehicleForProfessionalServiceReturnValue);
-            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow();
-            expect(isValidVehicleForProfessionalServiceMock).toHaveBeenCalledTimes(1);
-            expect(isValidVehicleForProfessionalServiceMock).toHaveBeenCalledWith({
-                vehicleType: enums_2.VehicleTypes.SEDAN,
-                professionalServicePublicConfig: defaultProps.countryProfessionalServicePublicConfig[defaultProps.professionalService.type],
-            });
-            expect(isValidProfessionalServicePricingAndDurationForVehicleMock).not.toHaveBeenCalled();
-        });
-        it("should not throw if isValidVehicleForProfessionalService return true", async () => {
-            isValidVehicleForProfessionalServiceReturnValue = true;
-            isValidVehicleForProfessionalServiceMock.mockReturnValue(isValidVehicleForProfessionalServiceReturnValue);
-            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).resolves.not.toThrow();
-            expect(isValidVehicleForProfessionalServiceMock).toHaveBeenCalledTimes(1);
-            expect(isValidVehicleForProfessionalServiceMock).toHaveBeenCalledWith({
-                vehicleType: enums_2.VehicleTypes.SEDAN,
-                professionalServicePublicConfig: defaultProps.countryProfessionalServicePublicConfig[defaultProps.professionalService.type],
-            });
-            expect(isValidProfessionalServicePricingAndDurationForVehicleMock).toHaveBeenCalledTimes(1);
-        });
-    });
-    describe("Price and duration", () => {
-        it("should not throw if isValidProfessionalServicePricingAndDurationForVehicle return true", async () => {
-            isValidProfessionalServicePricingAndDurationForVehicleReturnValue = true;
-            isValidProfessionalServicePricingAndDurationForVehicleMock.mockReturnValue(isValidProfessionalServicePricingAndDurationForVehicleReturnValue);
-            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).resolves.not.toThrow();
-            expect(isValidProfessionalServicePricingAndDurationForVehicleMock).toHaveBeenCalledTimes(1);
-            expect(isValidProfessionalServicePricingAndDurationForVehicleMock).toHaveBeenCalledWith({
-                professionalServicePublicConfig: defaultProps.countryProfessionalServicePublicConfig[defaultProps.professionalService.type],
-                servicePricingAndDuration: defaultProps.professionalService.pricingAndDurationByVehicleType[enums_2.VehicleTypes.SEDAN],
-            });
-        });
-        it("Should throw if isValidProfessionalServicePricingAndDurationForVehicle return false", async () => {
-            isValidProfessionalServicePricingAndDurationForVehicleReturnValue = false;
-            isValidProfessionalServicePricingAndDurationForVehicleMock.mockReturnValue(isValidProfessionalServicePricingAndDurationForVehicleReturnValue);
-            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow();
-        });
-    });
-    describe("parentsServices", () => {
-        it("Should throw if a service does not have the parents services indicated in the config", async () => {
-            defaultProps.professionalService = {
-                isActive: true,
-                type: enums_2.ProfessionalServicesTypes.ANIMAL_HAIR_TREATMENT,
-                parentsServices: [],
-                pricingAndDurationByVehicleType: {},
-            };
-            defaultProps.countryProfessionalServicePublicConfig =
-                (0, stubs_1.countryServicesPublicConfigStub)({
-                    [enums_2.ProfessionalServicesTypes.ANIMAL_HAIR_TREATMENT]: (0, stubs_1.firestoreServicesPublicConfigStub)({
-                        allowedVehicles: [enums_2.VehicleTypes.SEDAN, enums_2.VehicleTypes.SUV],
-                        parentsServices: [
-                            enums_2.ProfessionalServicesTypes.INTERIOR_CLEANING,
-                            enums_2.ProfessionalServicesTypes.INTERIOR_AND_EXTERIOR_CLEANING,
-                        ],
-                    }),
-                });
-            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow();
-        });
-        it("Should not throw if a valid service have the parents services indicated in the config", async () => {
-            defaultProps.professionalService = {
-                isActive: true,
-                type: enums_2.ProfessionalServicesTypes.ANIMAL_HAIR_TREATMENT,
-                parentsServices: [
-                    enums_2.ProfessionalServicesTypes.INTERIOR_CLEANING,
-                    enums_2.ProfessionalServicesTypes.INTERIOR_AND_EXTERIOR_CLEANING,
-                ],
-                pricingAndDurationByVehicleType: {},
-            };
-            defaultProps.countryProfessionalServicePublicConfig =
-                (0, stubs_1.countryServicesPublicConfigStub)({
-                    [enums_2.ProfessionalServicesTypes.ANIMAL_HAIR_TREATMENT]: (0, stubs_1.firestoreServicesPublicConfigStub)({
-                        allowedVehicles: [enums_2.VehicleTypes.SEDAN, enums_2.VehicleTypes.SUV],
-                        parentsServices: [
-                            enums_2.ProfessionalServicesTypes.INTERIOR_CLEANING,
-                            enums_2.ProfessionalServicesTypes.INTERIOR_AND_EXTERIOR_CLEANING,
-                        ],
-                    }),
-                });
-            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).resolves.not.toThrow();
-        });
-        it("Should throw if a valid service have the parents services indicated in the config but miss one", async () => {
-            defaultProps.professionalService = {
-                isActive: true,
-                type: enums_2.ProfessionalServicesTypes.ANIMAL_HAIR_TREATMENT,
-                parentsServices: [enums_2.ProfessionalServicesTypes.INTERIOR_CLEANING],
-                pricingAndDurationByVehicleType: {},
-            };
-            defaultProps.countryProfessionalServicePublicConfig =
-                (0, stubs_1.countryServicesPublicConfigStub)({
-                    [enums_2.ProfessionalServicesTypes.ANIMAL_HAIR_TREATMENT]: (0, stubs_1.firestoreServicesPublicConfigStub)({
-                        allowedVehicles: [enums_2.VehicleTypes.SEDAN, enums_2.VehicleTypes.SUV],
-                        parentsServices: [
-                            enums_2.ProfessionalServicesTypes.INTERIOR_CLEANING,
-                            enums_2.ProfessionalServicesTypes.INTERIOR_AND_EXTERIOR_CLEANING,
-                        ],
-                    }),
-                });
-            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow();
-        });
-        it("Should throw if a valid service have the parents services indicated in the config but have one more", async () => {
-            defaultProps.professionalService = {
-                isActive: true,
-                type: enums_2.ProfessionalServicesTypes.ANIMAL_HAIR_TREATMENT,
-                parentsServices: [
-                    enums_2.ProfessionalServicesTypes.INTERIOR_CLEANING,
-                    enums_2.ProfessionalServicesTypes.INTERIOR_AND_EXTERIOR_CLEANING,
-                    enums_2.ProfessionalServicesTypes.EXTERIOR_CLEANING,
-                ],
-                pricingAndDurationByVehicleType: {},
-            };
-            defaultProps.countryProfessionalServicePublicConfig =
-                (0, stubs_1.countryServicesPublicConfigStub)({
-                    [enums_2.ProfessionalServicesTypes.ANIMAL_HAIR_TREATMENT]: (0, stubs_1.firestoreServicesPublicConfigStub)({
-                        allowedVehicles: [enums_2.VehicleTypes.SEDAN, enums_2.VehicleTypes.SUV],
-                        parentsServices: [
-                            enums_2.ProfessionalServicesTypes.INTERIOR_CLEANING,
-                            enums_2.ProfessionalServicesTypes.INTERIOR_AND_EXTERIOR_CLEANING,
-                        ],
-                    }),
-                });
-            await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow();
-        });
-    });
-});

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

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable @typescript-eslint/no-explicit-any */
-const enums_1 = require("../../../../enums");
-const isValidProfessionalServiceType_1 = require("../isValidProfessionalServiceType");
-describe("isValidProfessionalServiceType", () => {
-    describe.each(Object.values(enums_1.ProfessionalServicesTypes))("when the service type is %p", (serviceType) => {
-        it("should return true", () => {
-            expect((0, isValidProfessionalServiceType_1.isValidProfessionalServiceType)(serviceType)).toBe(true);
-        });
-    });
-    it("should return false when the service type is unknown", () => {
-        expect((0, isValidProfessionalServiceType_1.isValidProfessionalServiceType)("UNKNOWN_SERVICE_TYPE")).toBe(false);
-    });
-});

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

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable @typescript-eslint/no-explicit-any */
-const enums_1 = require("../../../../enums");
-const stubs_1 = require("../../../stubs");
-const isValidVehicleForProfessionalService_1 = require("../isValidVehicleForProfessionalService");
-describe("isValidVehicleForProfessionalService", () => {
-    it("should return true if is a valid vehicle for the service", () => {
-        expect((0, isValidVehicleForProfessionalService_1.isValidVehicleForProfessionalService)({
-            professionalServicePublicConfig: (0, stubs_1.firestoreServicesPublicConfigStub)({
-                allowedVehicles: [enums_1.VehicleTypes.CITY_CAR, enums_1.VehicleTypes.SEDAN],
-            }),
-            vehicleType: enums_1.VehicleTypes.CITY_CAR,
-        })).toBe(true);
-    });
-    it("should return false if is a valid vehicle but not allowed for the service", () => {
-        expect((0, isValidVehicleForProfessionalService_1.isValidVehicleForProfessionalService)({
-            professionalServicePublicConfig: (0, stubs_1.firestoreServicesPublicConfigStub)({
-                allowedVehicles: [enums_1.VehicleTypes.CITY_CAR, enums_1.VehicleTypes.SEDAN],
-            }),
-            vehicleType: enums_1.VehicleTypes.MOTORCYCLE,
-        })).toBe(false);
-    });
-    it("should return false if is an unknown vehicle", () => {
-        expect((0, isValidVehicleForProfessionalService_1.isValidVehicleForProfessionalService)({
-            professionalServicePublicConfig: (0, stubs_1.firestoreServicesPublicConfigStub)({
-                allowedVehicles: [enums_1.VehicleTypes.CITY_CAR, enums_1.VehicleTypes.SEDAN],
-            }),
-            vehicleType: "UNKNOWN_VEHICLE",
-        })).toBe(false);
-    });
-});

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

@@ -1,4 +0,0 @@
-export * from "./isValidProfessionalServicePricingAndDurationForVehicle";
-export * from "./isValidProfessionalService";
-export * from "./isValidVehicleForProfessionalService";
-export * from "./isValidProfessionalServiceType";

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

@@ -1,20 +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("./isValidProfessionalServicePricingAndDurationForVehicle"), exports);
-__exportStar(require("./isValidProfessionalService"), exports);
-__exportStar(require("./isValidVehicleForProfessionalService"), exports);
-__exportStar(require("./isValidProfessionalServiceType"), exports);

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

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

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

@@ -1,25 +0,0 @@
-"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

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

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

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

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

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

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

@@ -1,11 +0,0 @@
-"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

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

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

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

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

@@ -1,6 +0,0 @@
-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/index.d.ts

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

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

@@ -1,19 +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("./IsValidProfessionalServiceParams.type"), exports);
-__exportStar(require("./IsValidProfessionalServicePricingAndDurationForVehicleParams.type"), exports);
-__exportStar(require("./IsValidVehicleForProfessionalServiceParams.type"), exports);