@doctocar/tooling 0.3.1-20 → 0.3.1-22

package/dist/firebase/firestore/enums/ordersIssues/CustomerOrderIssueReason.enum.d.ts

@@ -1,7 +1,7 @@
 export declare enum CustomerOrderIssueReason {
-    PROFESSIONAL_BEHAVIOR_ISSUE = "professional_behavior_issue",
+    SERVICE_PROVIDER_BEHAVIOR_ISSUE = "service_provider_behavior_issue",
     VEHICLE_DAMAGE_OR_THEFT = "vehicle_damage_or_theft",
-    PROFESSIONAL_ABSENT_OR_LATE = "professional_absent_or_late",
+    SERVICE_PROVIDER_ABSENT_OR_LATE = "service_provider_absent_or_late",
     SERVICE_QUALITY_ISSUE = "service_quality_issue",
     PAYMENT_ISSUE = "payment_issue",
     OTHER = "other"

package/dist/firebase/firestore/enums/ordersIssues/CustomerOrderIssueReason.enum.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CustomerOrderIssueReason = void 0;
 var CustomerOrderIssueReason;
 (function (CustomerOrderIssueReason) {
-    CustomerOrderIssueReason["PROFESSIONAL_BEHAVIOR_ISSUE"] = "professional_behavior_issue";
+    CustomerOrderIssueReason["SERVICE_PROVIDER_BEHAVIOR_ISSUE"] = "service_provider_behavior_issue";
     CustomerOrderIssueReason["VEHICLE_DAMAGE_OR_THEFT"] = "vehicle_damage_or_theft";
-    CustomerOrderIssueReason["PROFESSIONAL_ABSENT_OR_LATE"] = "professional_absent_or_late";
+    CustomerOrderIssueReason["SERVICE_PROVIDER_ABSENT_OR_LATE"] = "service_provider_absent_or_late";
     CustomerOrderIssueReason["SERVICE_QUALITY_ISSUE"] = "service_quality_issue";
     CustomerOrderIssueReason["PAYMENT_ISSUE"] = "payment_issue";
     CustomerOrderIssueReason["OTHER"] = "other";

package/dist/firebase/firestore/enums/ordersIssues/ServiceProviderOrderIssueReason.enum.d.ts

@@ -0,0 +1,10 @@
+export declare enum ServiceProviderOrderIssueReason {
+    CUSTOMER_BEHAVIOR_ISSUE = "customer_behavior_issue",
+    SAFETY_OR_SECURITY_ISSUE = "safety_or_security_issue",
+    CUSTOMER_ABSENT_OR_UNRESPONSIVE = "customer_absent_or_unresponsive",
+    LOCATION_ACCESS_ISSUE = "location_access_issue",
+    VEHICLE_NOT_COMPLIANT = "vehicle_not_compliant",
+    PAYMENT_OR_PAYOUT_ISSUE = "payment_or_payout_issue",
+    WEATHER_CONDITIONS_ISSUE = "weather_conditions_issue",
+    OTHER = "other"
+}

package/dist/firebase/firestore/enums/ordersIssues/ServiceProviderOrderIssueReason.enum.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceProviderOrderIssueReason = void 0;
+var ServiceProviderOrderIssueReason;
+(function (ServiceProviderOrderIssueReason) {
+    ServiceProviderOrderIssueReason["CUSTOMER_BEHAVIOR_ISSUE"] = "customer_behavior_issue";
+    ServiceProviderOrderIssueReason["SAFETY_OR_SECURITY_ISSUE"] = "safety_or_security_issue";
+    ServiceProviderOrderIssueReason["CUSTOMER_ABSENT_OR_UNRESPONSIVE"] = "customer_absent_or_unresponsive";
+    ServiceProviderOrderIssueReason["LOCATION_ACCESS_ISSUE"] = "location_access_issue";
+    ServiceProviderOrderIssueReason["VEHICLE_NOT_COMPLIANT"] = "vehicle_not_compliant";
+    ServiceProviderOrderIssueReason["PAYMENT_OR_PAYOUT_ISSUE"] = "payment_or_payout_issue";
+    ServiceProviderOrderIssueReason["WEATHER_CONDITIONS_ISSUE"] = "weather_conditions_issue";
+    ServiceProviderOrderIssueReason["OTHER"] = "other";
+})(ServiceProviderOrderIssueReason || (exports.ServiceProviderOrderIssueReason = ServiceProviderOrderIssueReason = {}));

package/dist/firebase/firestore/enums/ordersIssues/index.d.ts

@@ -1,4 +1,4 @@
 export * from "./OrderIssueStatusTypes.enum";
 export * from "./OrderIssueSeverityLevel.enum";
 export * from "./CustomerOrderIssueReason.enum";
-export * from "./ProfessionalOrderIssueReason.enum";
+export * from "./ServiceProviderOrderIssueReason.enum";

package/dist/firebase/firestore/enums/ordersIssues/index.js

@@ -17,4 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./OrderIssueStatusTypes.enum"), exports);
 __exportStar(require("./OrderIssueSeverityLevel.enum"), exports);
 __exportStar(require("./CustomerOrderIssueReason.enum"), exports);
-__exportStar(require("./ProfessionalOrderIssueReason.enum"), exports);
+__exportStar(require("./ServiceProviderOrderIssueReason.enum"), exports);

package/dist/firebase/firestore/enums/users/professionals/ServiceProviderBadgesTypes.enum.d.ts

@@ -0,0 +1,3 @@
+export declare enum ServiceProviderBadgesTypes {
+    PROFESSIONAL_LIABILITY_INSURANCE = "professional_liability_insurance"
+}

package/dist/firebase/firestore/enums/users/professionals/ServiceProviderBadgesTypes.enum.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceProviderBadgesTypes = void 0;
+var ServiceProviderBadgesTypes;
+(function (ServiceProviderBadgesTypes) {
+    ServiceProviderBadgesTypes["PROFESSIONAL_LIABILITY_INSURANCE"] = "professional_liability_insurance";
+})(ServiceProviderBadgesTypes || (exports.ServiceProviderBadgesTypes = ServiceProviderBadgesTypes = {}));

package/dist/firebase/firestore/enums/users/professionals/index.d.ts

@@ -1,3 +1,3 @@
 export * from "./ProfessionalInsurancesTypes.enum";
 export * from "./ProfessionalDiplomasTypes.enum";
-export * from "./ProfessionalBadgesTypes.enum";
+export * from "./ServiceProviderBadgesTypes.enum";

package/dist/firebase/firestore/enums/users/professionals/index.js

@@ -16,4 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./ProfessionalInsurancesTypes.enum"), exports);
 __exportStar(require("./ProfessionalDiplomasTypes.enum"), exports);
-__exportStar(require("./ProfessionalBadgesTypes.enum"), exports);
+__exportStar(require("./ServiceProviderBadgesTypes.enum"), exports);

package/dist/firebase/firestore/maps/FirestoreCollectionDocumentTypeMap.d.ts

@@ -1,9 +1,9 @@
 import { FirestoreCollections } from "../enums";
-import type { FirestoreBookedSlotDocument, FirestoreDailyMetricsDocument, FirestoreDebugPublicConfigDocument, FirestoreDeviceTokenDocument, FirestoreEmailsBlacklistDocument, FirestoreEmailsSoftBounceDocument, FirestoreEntityDocument, FirestoreEntityMemberDocument, FirestoreEntityMemberInviteDocument, FirestoreEntityUniqueKeyDocument, FirestoreFunctionsDeploymentRunsDocument, FirestoreGlobalMetricsDocument, FirestoreInvoiceCounterDocument, FirestoreMarketplaceFinancialReportsDocument, FirestoreMessageDocument, FirestoreNotificationEventDeliveryStateDocument, FirestoreNotificationEventsPublicConfigDocument, FirestoreOnTaskExecutionStateDocument, FirestoreOrderDocument, FirestoreOrderIssueDocument, FirestoreOrderReviewDocument, FirestoreOrdersPublicConfigDocument, FirestorePaymentIntentDocument, FirestorePlatformPublicConfigDocument, FirestorePricingPublicConfigDocument, FirestoreProfessionalUserPublicDocument, FirestorePromoCodeDocument, FirestoreRateLimitDocument, FirestoreServicesPublicConfigDocument, FirestoreSlotDocument, FirestoreUserDocument, FirestoreUserUploadRateLimitDocument, FirestoreVehicleDocument, FirestoreWalletsDocument, FirestoreWalletsLedgerEntryDocument, FirestoreWalletsWithdrawalIntentsDocument } from "../types";
+import type { FirestoreBookedSlotDocument, FirestoreDailyMetricsDocument, FirestoreDebugPublicConfigDocument, FirestoreDeviceTokenDocument, FirestoreEmailsBlacklistDocument, FirestoreEmailsSoftBounceDocument, FirestoreEntityDocument, FirestoreEntityMemberDocument, FirestoreEntityMemberInviteDocument, FirestoreEntityUniqueKeyDocument, FirestoreFunctionsDeploymentRunsDocument, FirestoreGlobalMetricsDocument, FirestoreInvoiceCounterDocument, FirestoreMarketplaceFinancialReportsDocument, FirestoreMessageDocument, FirestoreNotificationEventDeliveryStateDocument, FirestoreNotificationEventsPublicConfigDocument, FirestoreOnTaskExecutionStateDocument, FirestoreOrderDocument, FirestoreOrderIssueDocument, FirestoreOrderReviewDocument, FirestoreOrdersPublicConfigDocument, FirestorePaymentIntentDocument, FirestorePlatformPublicConfigDocument, FirestorePricingPublicConfigDocument, FirestoreServiceProviderUserPublicDocument, FirestorePromoCodeDocument, FirestoreRateLimitDocument, FirestoreServicesPublicConfigDocument, FirestoreSlotDocument, FirestoreUserDocument, FirestoreUserUploadRateLimitDocument, FirestoreVehicleDocument, FirestoreWalletsDocument, FirestoreWalletsLedgerEntryDocument, FirestoreWalletsWithdrawalIntentsDocument } from "../types";
 type FirestoreCollectionDocumentTypeMapBase = {
     [FirestoreCollections.USERS]: FirestoreUserDocument;
     [FirestoreCollections.DEVICE_TOKENS]: FirestoreDeviceTokenDocument;
-    [FirestoreCollections.PROFESSIONAL_USERS_PUBLIC]: FirestoreProfessionalUserPublicDocument;
+    [FirestoreCollections.SERVICE_PROVIDER_USERS_PUBLIC]: FirestoreServiceProviderUserPublicDocument;
     [FirestoreCollections.WALLETS]: FirestoreWalletsDocument;
     [FirestoreCollections.WALLETS_LEDGER_ENTRIES]: FirestoreWalletsLedgerEntryDocument;
     [FirestoreCollections.WALLETS_WITHDRAWAL_INTENTS]: FirestoreWalletsWithdrawalIntentsDocument;

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

@@ -1,7 +1,7 @@
 export * from "./userDocument";
 export * from "./messages";
 export * from "./services";
-export * from "./userPublicDocument";
+export * from "./serviceProviderUserPublicDocument";
 export * from "./rateLimitDocument";
 export * from "./FirestoreFile.type";
 export * from "./location";

package/dist/firebase/firestore/types/index.js

@@ -17,7 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./userDocument"), exports);
 __exportStar(require("./messages"), exports);
 __exportStar(require("./services"), exports);
-__exportStar(require("./userPublicDocument"), exports);
+__exportStar(require("./serviceProviderUserPublicDocument"), exports);
 __exportStar(require("./rateLimitDocument"), exports);
 __exportStar(require("./FirestoreFile.type"), exports);
 __exportStar(require("./location"), exports);

package/dist/firebase/firestore/types/order/FirestoreOrderCancellationReason.type.d.ts

@@ -1,2 +1,2 @@
-import type { OrderCustomerCancellationReason, OrderPaymentCancellationReason, OrderProfessionalCancellationReason, OrderSystemCancellationReason } from "../../enums";
-export type FirestoreOrderCancellationReason = OrderSystemCancellationReason | OrderCustomerCancellationReason | OrderProfessionalCancellationReason | OrderPaymentCancellationReason;
+import type { OrderCustomerCancellationReason, OrderPaymentCancellationReason, OrderServiceProviderCancellationReason, OrderSystemCancellationReason } from "../../enums";
+export type FirestoreOrderCancellationReason = OrderSystemCancellationReason | OrderCustomerCancellationReason | OrderServiceProviderCancellationReason | OrderPaymentCancellationReason;

package/dist/firebase/firestore/types/ordersIssues/OrderIssueReason.type.d.ts

@@ -1,2 +1,2 @@
-import type { CustomerOrderIssueReason, ProfessionalOrderIssueReason } from "../../enums";
-export type OrderIssueReason = CustomerOrderIssueReason | ProfessionalOrderIssueReason;
+import type { CustomerOrderIssueReason, ServiceProviderOrderIssueReason } from "../../enums";
+export type OrderIssueReason = CustomerOrderIssueReason | ServiceProviderOrderIssueReason;

package/dist/firebase/firestore/types/ordersReviews/FirestoreOrderReviewDocument.type.d.ts

@@ -5,7 +5,7 @@ export type FirestoreOrderReviewDocument = {
     updatedAt: FirestoreTimestamp;
     orderId: string;
     customerId: string;
-    professionalId: string;
+    serviceProviderId: string;
     status: OrderReviewStatusType;
     rating?: number;
     comment?: string;

package/dist/firebase/firestore/types/serviceProviderUserPublicDocument/FirestoreServiceProviderUserPublicDocument.type.d.ts

@@ -0,0 +1,49 @@
+import type { SupportedCountryIsoCodes } from "../../../../enums";
+import type { ServiceProviderBadgesTypes, ServicesTypes } from "../../enums";
+import type { FirestoreTimestamp } from "../FirestoreTimestamp.type";
+import type { FirestoreImageVariantSet } from "../image";
+import type { ProviderService } from "../services/ProviderService.type";
+import type { FirestoreServiceProviderUserPublicDocumentReviewAggregates } from "./FirestoreServiceProviderUserPublicDocumentReviewAggregates.type";
+import type { FirestoreServiceProviderUserPublicDocumentServicesLocation } from "./FirestoreServiceProviderUserPublicDocumentServicesLocation.type";
+export type FirestoreServiceProviderUserPublicDocument = {
+    createdAt: FirestoreTimestamp;
+    updatedAt: FirestoreTimestamp;
+    version: 1;
+    userId: string;
+    entityId: string;
+    entityDisplayName: string;
+    countryIsoCode: SupportedCountryIsoCodes;
+    isVatExempt: boolean;
+    profile?: {
+        photo?: {
+            storagePaths: FirestoreImageVariantSet;
+            updatedAt: FirestoreTimestamp;
+        };
+    };
+    coverPicture?: {
+        storagePaths: FirestoreImageVariantSet;
+        updatedAt: FirestoreTimestamp;
+    };
+    publicDescription?: string;
+    activeServicesVehiclesCombos: string[];
+    services: Partial<{
+        [T in ServicesTypes]: ProviderService<T>;
+    }>;
+    reviewAggregates: FirestoreServiceProviderUserPublicDocumentReviewAggregates;
+    servicesLocation: FirestoreServiceProviderUserPublicDocumentServicesLocation;
+    availability: {
+        horizonStart: FirestoreTimestamp;
+        horizonDays: number;
+        granularityMinutes: number;
+        encodedOpenTimeline: string;
+        encodedBlockedTimeline: string;
+        updatedAt: FirestoreTimestamp;
+    };
+    isBookable: boolean;
+    badges?: Partial<Record<ServiceProviderBadgesTypes, {
+        grantedAt: FirestoreTimestamp;
+        expiredAt?: FirestoreTimestamp;
+        metadata?: Record<string, unknown>;
+    }>>;
+    isTest: boolean;
+};

package/dist/firebase/firestore/types/serviceProviderUserPublicDocument/FirestoreServiceProviderUserPublicDocument.type.js

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

package/dist/firebase/firestore/types/serviceProviderUserPublicDocument/FirestoreServiceProviderUserPublicDocumentReviewAggregates.type.d.ts

@@ -0,0 +1,4 @@
+export type FirestoreServiceProviderUserPublicDocumentReviewAggregates = {
+    reviewCount: number;
+    ratingSum: number;
+};

package/dist/firebase/firestore/types/serviceProviderUserPublicDocument/FirestoreServiceProviderUserPublicDocumentReviewAggregates.type.js

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

package/dist/firebase/firestore/types/serviceProviderUserPublicDocument/FirestoreServiceProviderUserPublicDocumentServicesLocation.type.d.ts

@@ -0,0 +1,4 @@
+import type { DoctoCarLocation } from "../location";
+export type FirestoreServiceProviderUserPublicDocumentServicesLocation = {
+    serviceLocationRadiusInKm: number;
+} & DoctoCarLocation;

package/dist/firebase/firestore/types/serviceProviderUserPublicDocument/FirestoreServiceProviderUserPublicDocumentServicesLocation.type.js

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

package/dist/firebase/firestore/types/serviceProviderUserPublicDocument/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./FirestoreServiceProviderUserPublicDocument.type";
+export * from "./FirestoreServiceProviderUserPublicDocumentServicesLocation.type";
+export * from "./FirestoreServiceProviderUserPublicDocumentReviewAggregates.type";

package/dist/firebase/firestore/types/serviceProviderUserPublicDocument/index.js

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

package/dist/firebase/firestore/types/services/ProviderService.type.d.ts

@@ -0,0 +1,8 @@
+import { ServicesTypes, type VehicleTypes } from "../../enums";
+import type { ServicePricingAndDurationForVehicle } from "./ServicePricingAndDurationForVehicle.type";
+export type ProviderService<T extends ServicesTypes> = {
+    type: T;
+    isActive: boolean;
+    parentsServices?: ServicesTypes[];
+    pricingAndDurationByVehicleType: Partial<Record<VehicleTypes, ServicePricingAndDurationForVehicle>>;
+};

package/dist/firebase/firestore/types/services/ProviderService.type.js

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

package/dist/firebase/firestore/types/services/ServiceProviderService.type.d.ts

@@ -0,0 +1,8 @@
+import { ServicesTypes, type VehicleTypes } from "../../enums";
+import type { ServicePricingAndDurationForVehicle } from "./ServicePricingAndDurationForVehicle.type";
+export type ServiceProviderService<T extends ServicesTypes> = {
+    type: T;
+    isActive: boolean;
+    parentsServices?: ServicesTypes[];
+    pricingAndDurationByVehicleType: Partial<Record<VehicleTypes, ServicePricingAndDurationForVehicle>>;
+};

package/dist/firebase/firestore/types/services/ServiceProviderService.type.js

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

package/dist/firebase/firestore/types/services/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./ProfessionalService.type";
+export * from "./ProviderService.type";
 export * from "./ServicePricingAndDurationForVehicle.type";

package/dist/firebase/firestore/types/services/index.js

@@ -14,5 +14,5 @@ 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("./ProfessionalService.type"), exports);
+__exportStar(require("./ProviderService.type"), exports);
 __exportStar(require("./ServicePricingAndDurationForVehicle.type"), exports);

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

@@ -14,7 +14,7 @@ describe("isValidProfessionalService", () => {
     let isValidServicePricingAndDurationForVehicleReturnValue;
     beforeEach(() => {
         defaultProps = {
-            professionalService: {
+            providerService: {
                 isActive: true,
                 type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
                 pricingAndDurationByVehicleType: {
@@ -46,24 +46,24 @@ describe("isValidProfessionalService", () => {
     });
     describe("Active", () => {
         it("should throw if the active field is not a boolean", async () => {
-            defaultProps.professionalService.isActive = "yes";
+            defaultProps.providerService.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(isValidServicePricingAndDurationForVehicleMock).not.toHaveBeenCalled();
         });
         it("should throw if the active field is not provided", async () => {
-            defaultProps.professionalService.isActive = undefined;
+            defaultProps.providerService.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(isValidServicePricingAndDurationForVehicleMock).not.toHaveBeenCalled();
         });
     });
     describe("Service type", () => {
         it("should throw if the service type is not a valid ServicesTypes", async () => {
-            defaultProps.professionalService.type = "INVALID_TYPE";
+            defaultProps.providerService.type = "INVALID_TYPE";
             await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow();
             expect(isValidServicePricingAndDurationForVehicleMock).not.toHaveBeenCalled();
         });
         it("should throw if the type is not provided", async () => {
-            defaultProps.professionalService.type = undefined;
+            defaultProps.providerService.type = undefined;
             await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).rejects.toThrow();
             expect(isValidServicePricingAndDurationForVehicleMock).not.toHaveBeenCalled();
         });
@@ -82,8 +82,8 @@ describe("isValidProfessionalService", () => {
             await expect((0, isValidProfessionalService_1.isValidProfessionalService)(defaultProps)).resolves.not.toThrow();
             expect(isValidServicePricingAndDurationForVehicleMock).toHaveBeenCalledTimes(1);
             expect(isValidServicePricingAndDurationForVehicleMock).toHaveBeenCalledWith({
-                servicePublicConfig: defaultProps.countryServicePublicConfig[defaultProps.professionalService.type],
-                servicePricingAndDurationForVehicle: defaultProps.professionalService.pricingAndDurationByVehicleType[enums_2.VehicleTypes.SEDAN],
+                servicePublicConfig: defaultProps.countryServicePublicConfig[defaultProps.providerService.type],
+                servicePricingAndDurationForVehicle: defaultProps.providerService.pricingAndDurationByVehicleType[enums_2.VehicleTypes.SEDAN],
             });
         });
         it("Should throw if isValidServicePricingAndDurationForVehicle return false", async () => {
@@ -94,7 +94,7 @@ describe("isValidProfessionalService", () => {
     });
     describe("parentsServices", () => {
         it("Should throw if a service does not have the parents services indicated in the config", async () => {
-            defaultProps.professionalService = {
+            defaultProps.providerService = {
                 isActive: true,
                 type: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
                 parentsServices: [],
@@ -111,7 +111,7 @@ describe("isValidProfessionalService", () => {
             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 = {
+            defaultProps.providerService = {
                 isActive: true,
                 type: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
                 parentsServices: [
@@ -131,7 +131,7 @@ describe("isValidProfessionalService", () => {
             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 = {
+            defaultProps.providerService = {
                 isActive: true,
                 type: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
                 parentsServices: [enums_2.ServicesTypes.INTERIOR_CLEANING],
@@ -148,7 +148,7 @@ describe("isValidProfessionalService", () => {
             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 = {
+            defaultProps.providerService = {
                 isActive: true,
                 type: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
                 parentsServices: [

package/dist/firebase/firestore/utils/dataValidators/services/__tests__/isValidProviderService.test.d.ts

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

package/dist/firebase/firestore/utils/dataValidators/services/__tests__/isValidProviderService.test.js

@@ -0,0 +1,172 @@
+"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 isValidProviderService_1 = require("../isValidProviderService");
+const isValidServicePricingAndDurationForVehicle_1 = require("../isValidServicePricingAndDurationForVehicle");
+jest.mock("../isValidServicePricingAndDurationForVehicle");
+describe("isValidProviderService", () => {
+    let defaultProps;
+    let isValidServicePricingAndDurationForVehicleMock;
+    let isValidServicePricingAndDurationForVehicleReturnValue;
+    beforeEach(() => {
+        defaultProps = {
+            providerService: {
+                isActive: true,
+                type: enums_2.ServicesTypes.EXTERIOR_CLEANING,
+                pricingAndDurationByVehicleType: {
+                    [enums_2.VehicleTypes.SEDAN]: {
+                        isActive: true,
+                        type: enums_2.VehicleTypes.SEDAN,
+                        pricePreTaxInCents: 2000,
+                        currency: enums_1.SupportedIsoCurrency.EUR,
+                        durationInMinutes: 30,
+                    },
+                },
+            },
+            countryServicePublicConfig: (0, stubs_1.countryServicesPublicConfigStub)({
+                [enums_2.ServicesTypes.EXTERIOR_CLEANING]: (0, stubs_1.firestoreServicesPublicConfigStub)({}),
+            }),
+        };
+        isValidServicePricingAndDurationForVehicleMock =
+            isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle;
+        isValidServicePricingAndDurationForVehicleReturnValue = true;
+        isValidServicePricingAndDurationForVehicleMock.mockImplementation(() => {
+            return isValidServicePricingAndDurationForVehicleReturnValue;
+        });
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    it("should not throw if is a valid service with empty pricing and empty subservice", async () => {
+        await expect((0, isValidProviderService_1.isValidProviderService)(defaultProps)).resolves.not.toThrow();
+    });
+    describe("Active", () => {
+        it("should throw if the active field is not a boolean", async () => {
+            defaultProps.providerService.isActive = "yes";
+            await expect((0, isValidProviderService_1.isValidProviderService)(defaultProps)).rejects.toThrow(new errors_1.DoctoCarError("Provider service isActive must be a boolean", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_IS_ACTIVE));
+            expect(isValidServicePricingAndDurationForVehicleMock).not.toHaveBeenCalled();
+        });
+        it("should throw if the active field is not provided", async () => {
+            defaultProps.providerService.isActive = undefined;
+            await expect((0, isValidProviderService_1.isValidProviderService)(defaultProps)).rejects.toThrow(new errors_1.DoctoCarError("Provider service isActive must be a boolean", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_IS_ACTIVE));
+            expect(isValidServicePricingAndDurationForVehicleMock).not.toHaveBeenCalled();
+        });
+    });
+    describe("Service type", () => {
+        it("should throw if the service type is not a valid ServicesTypes", async () => {
+            defaultProps.providerService.type = "INVALID_TYPE";
+            await expect((0, isValidProviderService_1.isValidProviderService)(defaultProps)).rejects.toThrow();
+            expect(isValidServicePricingAndDurationForVehicleMock).not.toHaveBeenCalled();
+        });
+        it("should throw if the type is not provided", async () => {
+            defaultProps.providerService.type = undefined;
+            await expect((0, isValidProviderService_1.isValidProviderService)(defaultProps)).rejects.toThrow();
+            expect(isValidServicePricingAndDurationForVehicleMock).not.toHaveBeenCalled();
+        });
+    });
+    describe("Country services public config", () => {
+        it("should throw if there is no public config entry for the provider service type", async () => {
+            defaultProps.countryServicePublicConfig = {};
+            await expect((0, isValidProviderService_1.isValidProviderService)(defaultProps)).rejects.toThrow(new errors_1.DoctoCarError("Country services public config has no entry for this provider service type", errors_1.DoctoCarValidationErrorCodes.INVALID_SERVICE_TYPE));
+            expect(isValidServicePricingAndDurationForVehicleMock).not.toHaveBeenCalled();
+        });
+    });
+    describe("Price and duration", () => {
+        it("should not throw if isValidServicePricingAndDurationForVehicle return true", async () => {
+            isValidServicePricingAndDurationForVehicleReturnValue = true;
+            isValidServicePricingAndDurationForVehicleMock.mockReturnValue(isValidServicePricingAndDurationForVehicleReturnValue);
+            await expect((0, isValidProviderService_1.isValidProviderService)(defaultProps)).resolves.not.toThrow();
+            expect(isValidServicePricingAndDurationForVehicleMock).toHaveBeenCalledTimes(1);
+            expect(isValidServicePricingAndDurationForVehicleMock).toHaveBeenCalledWith({
+                servicePublicConfig: defaultProps.countryServicePublicConfig[defaultProps.providerService.type],
+                servicePricingAndDurationForVehicle: defaultProps.providerService.pricingAndDurationByVehicleType[enums_2.VehicleTypes.SEDAN],
+            });
+        });
+        it("Should throw if isValidServicePricingAndDurationForVehicle return false", async () => {
+            isValidServicePricingAndDurationForVehicleReturnValue = false;
+            isValidServicePricingAndDurationForVehicleMock.mockReturnValue(isValidServicePricingAndDurationForVehicleReturnValue);
+            await expect((0, isValidProviderService_1.isValidProviderService)(defaultProps)).rejects.toThrow();
+        });
+    });
+    describe("parentsServices", () => {
+        it("Should throw if a service does not have the parents services indicated in the config", async () => {
+            defaultProps.providerService = {
+                isActive: true,
+                type: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
+                parentsServices: [],
+                pricingAndDurationByVehicleType: {},
+            };
+            defaultProps.countryServicePublicConfig = (0, stubs_1.countryServicesPublicConfigStub)({
+                [enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT]: (0, stubs_1.firestoreServicesPublicConfigStub)({
+                    parentsServices: [
+                        enums_2.ServicesTypes.INTERIOR_CLEANING,
+                        enums_2.ServicesTypes.INTERIOR_AND_EXTERIOR_CLEANING,
+                    ],
+                }),
+            });
+            await expect((0, isValidProviderService_1.isValidProviderService)(defaultProps)).rejects.toThrow();
+        });
+        it("Should not throw if a valid service have the parents services indicated in the config", async () => {
+            defaultProps.providerService = {
+                isActive: true,
+                type: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
+                parentsServices: [
+                    enums_2.ServicesTypes.INTERIOR_CLEANING,
+                    enums_2.ServicesTypes.INTERIOR_AND_EXTERIOR_CLEANING,
+                ],
+                pricingAndDurationByVehicleType: {},
+            };
+            defaultProps.countryServicePublicConfig = (0, stubs_1.countryServicesPublicConfigStub)({
+                [enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT]: (0, stubs_1.firestoreServicesPublicConfigStub)({
+                    parentsServices: [
+                        enums_2.ServicesTypes.INTERIOR_CLEANING,
+                        enums_2.ServicesTypes.INTERIOR_AND_EXTERIOR_CLEANING,
+                    ],
+                }),
+            });
+            await expect((0, isValidProviderService_1.isValidProviderService)(defaultProps)).resolves.not.toThrow();
+        });
+        it("Should throw if a valid service have the parents services indicated in the config but miss one", async () => {
+            defaultProps.providerService = {
+                isActive: true,
+                type: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
+                parentsServices: [enums_2.ServicesTypes.INTERIOR_CLEANING],
+                pricingAndDurationByVehicleType: {},
+            };
+            defaultProps.countryServicePublicConfig = (0, stubs_1.countryServicesPublicConfigStub)({
+                [enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT]: (0, stubs_1.firestoreServicesPublicConfigStub)({
+                    parentsServices: [
+                        enums_2.ServicesTypes.INTERIOR_CLEANING,
+                        enums_2.ServicesTypes.INTERIOR_AND_EXTERIOR_CLEANING,
+                    ],
+                }),
+            });
+            await expect((0, isValidProviderService_1.isValidProviderService)(defaultProps)).rejects.toThrow();
+        });
+        it("Should throw if a valid service have the parents services indicated in the config but have one more", async () => {
+            defaultProps.providerService = {
+                isActive: true,
+                type: enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT,
+                parentsServices: [
+                    enums_2.ServicesTypes.INTERIOR_CLEANING,
+                    enums_2.ServicesTypes.INTERIOR_AND_EXTERIOR_CLEANING,
+                    enums_2.ServicesTypes.EXTERIOR_CLEANING,
+                ],
+                pricingAndDurationByVehicleType: {},
+            };
+            defaultProps.countryServicePublicConfig = (0, stubs_1.countryServicesPublicConfigStub)({
+                [enums_2.ServicesTypes.ANIMAL_HAIR_TREATMENT]: (0, stubs_1.firestoreServicesPublicConfigStub)({
+                    parentsServices: [
+                        enums_2.ServicesTypes.INTERIOR_CLEANING,
+                        enums_2.ServicesTypes.INTERIOR_AND_EXTERIOR_CLEANING,
+                    ],
+                }),
+            });
+            await expect((0, isValidProviderService_1.isValidProviderService)(defaultProps)).rejects.toThrow();
+        });
+    });
+});

package/dist/firebase/firestore/utils/dataValidators/services/__tests__/isValidServicePricingAndDurationForVehicle.test.js

@@ -12,11 +12,11 @@ describe("isValidServicePricingAndDurationForVehicle", () => {
     let maximumPriceInCents;
     let durationInMinutes;
     beforeEach(() => {
-        minimumPriceInCents = constants_1.PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS;
+        minimumPriceInCents = constants_1.PROVIDER_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS;
         maximumPriceInCents =
-            constants_1.PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS * 10;
+            constants_1.PROVIDER_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS * 10;
         durationInMinutes =
-            constants_1.PROFESSIONAL_SERVICE_MINIMUM_DURATION_INCREMENT_IN_MINUTES;
+            constants_1.PROVIDER_SERVICE_MINIMUM_DURATION_INCREMENT_IN_MINUTES;
         defaultProps = {
             servicePublicConfig: (0, stubs_1.firestoreServicesPublicConfigStub)({
                 byVehicleType: {
@@ -92,16 +92,16 @@ describe("isValidServicePricingAndDurationForVehicle", () => {
     it("Should return false if pricePreTaxInCents is less than the service minimum", () => {
         defaultProps.servicePricingAndDurationForVehicle.pricePreTaxInCents =
             minimumPriceInCents -
-                constants_1.PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS;
+                constants_1.PROVIDER_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS;
         expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
     });
-    it("Should return false if pricePreTaxInCents is more than PROFESSIONAL_SERVICE_MAXIMUM_PRICE_IN_CENTS", () => {
+    it("Should return false if pricePreTaxInCents is more than the configured maximum price", () => {
         defaultProps.servicePricingAndDurationForVehicle.pricePreTaxInCents =
             maximumPriceInCents +
-                constants_1.PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS;
+                constants_1.PROVIDER_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS;
         expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
     });
-    it("Should return false if pricePreTaxInCents is not a multiple of PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS", () => {
+    it("Should return false if pricePreTaxInCents is not a multiple of PROVIDER_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS", () => {
         defaultProps.servicePricingAndDurationForVehicle.pricePreTaxInCents =
             maximumPriceInCents - 1;
         expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
@@ -119,13 +119,13 @@ describe("isValidServicePricingAndDurationForVehicle", () => {
     it("Should return false if durationInMinutes is less than the duration for the service", () => {
         defaultProps.servicePricingAndDurationForVehicle.durationInMinutes =
             durationInMinutes -
-                constants_1.PROFESSIONAL_SERVICE_MINIMUM_DURATION_INCREMENT_IN_MINUTES;
+                constants_1.PROVIDER_SERVICE_MINIMUM_DURATION_INCREMENT_IN_MINUTES;
         expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
     });
     it("Should return false if durationInMinutes is more than the duration for the service", () => {
         defaultProps.servicePricingAndDurationForVehicle.durationInMinutes =
             durationInMinutes +
-                constants_1.PROFESSIONAL_SERVICE_MINIMUM_DURATION_INCREMENT_IN_MINUTES;
+                constants_1.PROVIDER_SERVICE_MINIMUM_DURATION_INCREMENT_IN_MINUTES;
         expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
     });
     it("Should return false if the type is not a valid vehicle type", () => {

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

@@ -1,2 +1,2 @@
 export * from "./isValidServicePricingAndDurationForVehicle";
-export * from "./isValidProfessionalService";
+export * from "./isValidProviderService";