@doctocar/tooling 0.3.1-6 → 0.3.1-8

package/dist/firebase/firestore/utils/dataValidators/{professionalService/__tests__/isValidProfessionalServicePricingAndDurationForVehicle.test.js → services/__tests__/isValidServicePricingAndDurationForVehicle.test.js}

@@ -5,8 +5,8 @@ const enums_1 = require("../../../../../../enums");
 const constants_1 = require("../../../../constants");
 const enums_2 = require("../../../../enums");
 const stubs_1 = require("../../../stubs");
-const isValidProfessionalServicePricingAndDurationForVehicle_1 = require("../isValidProfessionalServicePricingAndDurationForVehicle");
-describe("isValidProfessionalServicePricingAndDurationForVehicle", () => {
+const isValidServicePricingAndDurationForVehicle_1 = require("../isValidServicePricingAndDurationForVehicle");
+describe("isValidServicePricingAndDurationForVehicle", () => {
     let defaultProps;
     let minimumPriceInCents;
     let maximumPriceInCents;
@@ -18,7 +18,7 @@ describe("isValidProfessionalServicePricingAndDurationForVehicle", () => {
         durationInMinutes =
             constants_1.PROFESSIONAL_SERVICE_MINIMUM_DURATION_INCREMENT_IN_MINUTES;
         defaultProps = {
-            professionalServicePublicConfig: (0, stubs_1.firestoreServicesPublicConfigStub)({
+            servicePublicConfig: (0, stubs_1.firestoreServicesPublicConfigStub)({
                 byVehicleType: {
                     [enums_2.VehicleTypes.CITY_CAR]: {
                         durationInMinutes: durationInMinutes,
@@ -57,9 +57,8 @@ describe("isValidProfessionalServicePricingAndDurationForVehicle", () => {
                         recommendedPriceInCents: maximumPriceInCents,
                     },
                 },
-                allowedVehicles: [enums_2.VehicleTypes.CITY_CAR],
             }),
-            servicePricingAndDuration: {
+            servicePricingAndDurationForVehicle: {
                 isActive: true,
                 type: enums_2.VehicleTypes.CITY_CAR,
                 pricePreTaxInCents: minimumPriceInCents,
@@ -72,58 +71,66 @@ describe("isValidProfessionalServicePricingAndDurationForVehicle", () => {
         jest.clearAllMocks();
     });
     it("should return true if pricing is valid for service", () => {
-        expect((0, isValidProfessionalServicePricingAndDurationForVehicle_1.isValidProfessionalServicePricingAndDurationForVehicle)(defaultProps)).toBe(true);
+        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(true);
     });
     it("Should return false if active is not a boolean", () => {
-        defaultProps.servicePricingAndDuration.isActive = "Not a boolean";
-        expect((0, isValidProfessionalServicePricingAndDurationForVehicle_1.isValidProfessionalServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+        defaultProps.servicePricingAndDurationForVehicle.isActive =
+            "Not a boolean";
+        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+    });
+    it("Should return false if service public config is not defined for the vehicle type", () => {
+        defaultProps.servicePublicConfig.byVehicleType = {
+            [enums_2.VehicleTypes.CITY_CAR]: undefined,
+        };
+        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
     });
     it("Should return false if pricePreTaxInCents is not a number", () => {
-        defaultProps.servicePricingAndDuration.pricePreTaxInCents =
+        defaultProps.servicePricingAndDurationForVehicle.pricePreTaxInCents =
             "Not a number";
-        expect((0, isValidProfessionalServicePricingAndDurationForVehicle_1.isValidProfessionalServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
     });
     it("Should return false if pricePreTaxInCents is less than the service minimum", () => {
-        defaultProps.servicePricingAndDuration.pricePreTaxInCents =
+        defaultProps.servicePricingAndDurationForVehicle.pricePreTaxInCents =
             minimumPriceInCents -
                 constants_1.PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS;
-        expect((0, isValidProfessionalServicePricingAndDurationForVehicle_1.isValidProfessionalServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
     });
     it("Should return false if pricePreTaxInCents is more than PROFESSIONAL_SERVICE_MAXIMUM_PRICE_IN_CENTS", () => {
-        defaultProps.servicePricingAndDuration.pricePreTaxInCents =
+        defaultProps.servicePricingAndDurationForVehicle.pricePreTaxInCents =
             maximumPriceInCents +
                 constants_1.PROFESSIONAL_SERVICE_MINIMUM_PRICE_INCREMENT_IN_CENTS;
-        expect((0, isValidProfessionalServicePricingAndDurationForVehicle_1.isValidProfessionalServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+        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", () => {
-        defaultProps.servicePricingAndDuration.pricePreTaxInCents =
+        defaultProps.servicePricingAndDurationForVehicle.pricePreTaxInCents =
             maximumPriceInCents - 1;
-        expect((0, isValidProfessionalServicePricingAndDurationForVehicle_1.isValidProfessionalServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
     });
     it("Should return false if SupportedIsoCurrency is not a valid currency", () => {
-        defaultProps.servicePricingAndDuration.currency =
+        defaultProps.servicePricingAndDurationForVehicle.currency =
             "Not a valid currency";
-        expect((0, isValidProfessionalServicePricingAndDurationForVehicle_1.isValidProfessionalServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
     });
     it("Should return false if durationInMinutes is not a number", () => {
-        defaultProps.servicePricingAndDuration.durationInMinutes =
+        defaultProps.servicePricingAndDurationForVehicle.durationInMinutes =
             "Not a number";
-        expect((0, isValidProfessionalServicePricingAndDurationForVehicle_1.isValidProfessionalServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
     });
     it("Should return false if durationInMinutes is less than the duration for the service", () => {
-        defaultProps.servicePricingAndDuration.durationInMinutes =
+        defaultProps.servicePricingAndDurationForVehicle.durationInMinutes =
             durationInMinutes -
                 constants_1.PROFESSIONAL_SERVICE_MINIMUM_DURATION_INCREMENT_IN_MINUTES;
-        expect((0, isValidProfessionalServicePricingAndDurationForVehicle_1.isValidProfessionalServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
     });
     it("Should return false if durationInMinutes is more than the duration for the service", () => {
-        defaultProps.servicePricingAndDuration.durationInMinutes =
+        defaultProps.servicePricingAndDurationForVehicle.durationInMinutes =
             durationInMinutes +
                 constants_1.PROFESSIONAL_SERVICE_MINIMUM_DURATION_INCREMENT_IN_MINUTES;
-        expect((0, isValidProfessionalServicePricingAndDurationForVehicle_1.isValidProfessionalServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
     });
     it("Should return false if the type is not a valid vehicle type", () => {
-        defaultProps.servicePricingAndDuration.type = "Not a vehicle type";
-        expect((0, isValidProfessionalServicePricingAndDurationForVehicle_1.isValidProfessionalServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
+        defaultProps.servicePricingAndDurationForVehicle.type =
+            "Not a vehicle type";
+        expect((0, isValidServicePricingAndDurationForVehicle_1.isValidServicePricingAndDurationForVehicle)(defaultProps)).toBe(false);
     });
 });

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

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

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

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

package/dist/firebase/firestore/utils/dataValidators/{professionalService → services}/isValidProfessionalService.d.ts

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

package/dist/firebase/firestore/utils/dataValidators/{professionalService → services}/isValidProfessionalService.js

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

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

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

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

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

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

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

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

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

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

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

package/dist/firebase/firestore/utils/{users → dataValidators/services}/types/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("./BookableProfessionalUserDocument.type"), exports);
-__exportStar(require("./BookingReadyCustomerUserDocument.type"), exports);
+__exportStar(require("./IsValidServicePricingAndDurationForVehicleParams.type"), exports);
+__exportStar(require("./IsValidProfessionalServiceParams.type"), exports);

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const enums_1 = require("../../../enums");
+const stubs_1 = require("../../stubs");
+const isEntityLegalDetailsVatVerified_1 = require("../isEntityLegalDetailsVatVerified");
+describe("isEntityLegalDetailsVatVerified", () => {
+    let defaultVatDetails;
+    beforeEach(() => {
+        defaultVatDetails = (0, stubs_1.entityVatDetailsStub)({
+            isVatExempt: false,
+            vatNumber: "12345678901",
+        });
+    });
+    it("should return true when vatDetails is VERIFIED", () => {
+        const vatDetails = (0, stubs_1.entityVatDetailsStub)({
+            ...defaultVatDetails,
+            vatNumberVerificationStatus: enums_1.VatVerificationStatus.VERIFIED,
+        });
+        expect((0, isEntityLegalDetailsVatVerified_1.isEntityLegalDetailsVatVerified)({ vatDetails })).toBe(true);
+    });
+    it("should return false when vatDetails is PENDING", () => {
+        const vatDetails = (0, stubs_1.entityVatDetailsStub)({
+            ...defaultVatDetails,
+            vatNumberVerificationStatus: enums_1.VatVerificationStatus.PENDING,
+        });
+        expect((0, isEntityLegalDetailsVatVerified_1.isEntityLegalDetailsVatVerified)({ vatDetails })).toBe(false);
+    });
+    it("should return false when vatDetails is REJECTED", () => {
+        const vatDetails = (0, stubs_1.entityVatDetailsStub)({
+            ...defaultVatDetails,
+            vatNumberVerificationStatus: enums_1.VatVerificationStatus.REJECTED,
+        });
+        expect((0, isEntityLegalDetailsVatVerified_1.isEntityLegalDetailsVatVerified)({ vatDetails })).toBe(false);
+    });
+    it("should return false when vatDetails is EXPIRED", () => {
+        const vatDetails = (0, stubs_1.entityVatDetailsStub)({
+            ...defaultVatDetails,
+            vatNumberVerificationStatus: enums_1.VatVerificationStatus.EXPIRED,
+        });
+        expect((0, isEntityLegalDetailsVatVerified_1.isEntityLegalDetailsVatVerified)({ vatDetails })).toBe(false);
+    });
+    it("should return false when vatDetails is not set", () => {
+        expect((0, isEntityLegalDetailsVatVerified_1.isEntityLegalDetailsVatVerified)({ vatDetails: undefined })).toBe(false);
+    });
+    it("should return true when vatDetails is isVatExempt is true", () => {
+        const vatDetails = (0, stubs_1.entityVatDetailsStub)({
+            ...defaultVatDetails,
+            isVatExempt: true,
+            vatNumberVerificationStatus: enums_1.VatVerificationStatus.EXPIRED, // Should not be set but to test the flow
+        });
+        expect((0, isEntityLegalDetailsVatVerified_1.isEntityLegalDetailsVatVerified)({ vatDetails })).toBe(true);
+    });
+    it("should return false when vatDetails is vatNumber is not set", () => {
+        const vatDetails = (0, stubs_1.entityVatDetailsStub)({
+            ...defaultVatDetails,
+            vatNumber: undefined,
+            vatNumberVerificationStatus: enums_1.VatVerificationStatus.VERIFIED, // Should not be set but to test the flow
+        });
+        expect((0, isEntityLegalDetailsVatVerified_1.isEntityLegalDetailsVatVerified)({ vatDetails })).toBe(false);
+    });
+});

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

@@ -1 +1,2 @@
 export * from "./isEntityMemberAuthorized";
+export * from "./isEntityLegalDetailsVatVerified";

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

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./isEntityMemberAuthorized"), exports);
+__exportStar(require("./isEntityLegalDetailsVatVerified"), exports);

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

@@ -0,0 +1,2 @@
+import type { IsEntityLegalDetailsVatVerifiedParams } from "./types";
+export declare function isEntityLegalDetailsVatVerified({ vatDetails, }: IsEntityLegalDetailsVatVerifiedParams): boolean;

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEntityLegalDetailsVatVerified = isEntityLegalDetailsVatVerified;
+const enums_1 = require("../../enums");
+function isEntityLegalDetailsVatVerified({ vatDetails, }) {
+    if (!vatDetails)
+        return false;
+    if (vatDetails.isVatExempt)
+        return true;
+    if (!vatDetails.vatNumber)
+        return false;
+    if (!vatDetails.vatNumberVerificationStatus)
+        return false;
+    if (vatDetails.vatNumberVerificationStatus === enums_1.VatVerificationStatus.VERIFIED)
+        return true;
+    return false;
+}

package/dist/firebase/firestore/utils/entities/types/IsEntityLegalDetailsVatVerifiedParams.type.d.ts

@@ -0,0 +1,4 @@
+import type { EntityVatDetails } from "../../../types";
+export type IsEntityLegalDetailsVatVerifiedParams = {
+    vatDetails?: EntityVatDetails;
+};

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

@@ -1 +1,2 @@
 export * from "./IsEntityMemberAuthorizedParams.type";
+export * from "./IsEntityLegalDetailsVatVerifiedParams.type";

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

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./IsEntityMemberAuthorizedParams.type"), exports);
+__exportStar(require("./IsEntityLegalDetailsVatVerifiedParams.type"), exports);

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

@@ -3,10 +3,10 @@ export * from "./stubs";
 export * from "./services";
 export * from "./reviews";
 export * from "./order";
-export * from "./users";
 export * from "./normalizers";
 export * from "./counters";
-export * from "./company";
 export * from "./document";
 export * from "./wallets";
 export * from "./entities";
+export * from "./address";
+export * from "./configs";

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

@@ -19,10 +19,10 @@ __exportStar(require("./stubs"), exports);
 __exportStar(require("./services"), exports);
 __exportStar(require("./reviews"), exports);
 __exportStar(require("./order"), exports);
-__exportStar(require("./users"), exports);
 __exportStar(require("./normalizers"), exports);
 __exportStar(require("./counters"), exports);
-__exportStar(require("./company"), exports);
 __exportStar(require("./document"), exports);
 __exportStar(require("./wallets"), exports);
 __exportStar(require("./entities"), exports);
+__exportStar(require("./address"), exports);
+__exportStar(require("./configs"), exports);