@voyantjs/storefront 0.44.0 → 0.46.0

package/README.md

@@ -0,0 +1,74 @@
+# @voyantjs/storefront
+
+Public storefront routes and service helpers for checkout-adjacent product, departure,
+offer, and eligibility flows.
+
+## Transport Eligibility
+
+Storefronts can check whether traveler document facts satisfy departure-level
+transport rules before checkout confirmation.
+
+```ts
+import { createStorefrontPublicRoutes } from "@voyantjs/storefront"
+
+createStorefrontPublicRoutes({
+  transportEligibilityRules: [
+    {
+      id: "egypt-passport-validity",
+      label: "Egypt passport validity",
+      productId: "prod_123",
+      destinationCountries: ["EG"],
+      nationalityCountries: ["RO"],
+      requiredDocumentType: "passport",
+      minValidityDaysAfterReturn: 180,
+      visaRequired: true,
+    },
+  ],
+})
+```
+
+Schemas and the standalone evaluator are exported from
+`@voyantjs/storefront/transport-eligibility`.
+
+The public API is available at:
+
+- `POST /departures/:departureId/eligibility`
+- `POST /products/:productId/departures/:departureId/eligibility`
+
+Request bodies contain only eligibility facts:
+
+```json
+{
+  "travelStartsOn": "2026-08-01",
+  "travelEndsOn": "2026-08-08",
+  "travelers": [
+    {
+      "travelerRef": "traveler_1",
+      "nationalityCountry": "RO",
+      "dateOfBirth": "1990-01-01",
+      "documents": [
+        {
+          "type": "passport",
+          "issuingCountry": "RO",
+          "expiresOn": "2027-03-01"
+        }
+      ],
+      "hasVisa": true
+    }
+  ]
+}
+```
+
+Responses return a top-level `eligible` flag plus traveler-specific blocking
+issues and warnings. Supported rule dimensions are product, departure,
+destination country, nationality country, required document type, minimum
+validity after return, age range, visa requirement, minor consent requirement,
+and warning/blocking severity.
+
+Do not send or store raw passport numbers through this surface. The route and
+schemas only model document type, issuing country, expiry date, nationality,
+birth date, and boolean evidence such as `hasVisa`.
+
+This first slice is API-only. Admin CRUD and operator UI for managing transport
+rules should persist normalized rule objects and can call the same public
+eligibility service once added.

package/dist/index.d.ts

@@ -5,8 +5,11 @@ export type { StorefrontPublicRoutes } from "./routes-public.js";
 export { createStorefrontPublicRoutes } from "./routes-public.js";
 export type { StorefrontOfferResolvers, StorefrontRequestContext, StorefrontServiceOptions, } from "./service.js";
 export { createStorefrontService, resolveStorefrontSettings } from "./service.js";
+export { evaluateStorefrontTransportEligibility } from "./service-transport-eligibility.js";
 export type { StorefrontAppliedOffer, StorefrontDepartureListQuery, StorefrontFormField, StorefrontFormFieldInput, StorefrontOfferApplyInput, StorefrontOfferMutationResult, StorefrontOfferRedeemInput, StorefrontPaymentMethod, StorefrontPaymentMethodCode, StorefrontPaymentMethodInput, StorefrontProductAvailabilitySummaryQuery, StorefrontPromotionalOffer, StorefrontSettings, StorefrontSettingsInput, } from "./validation.js";
 export { storefrontAppliedOfferSchema, storefrontDepartureItinerarySchema, storefrontDepartureListQuerySchema, storefrontDepartureListResponseSchema, storefrontDeparturePricePreviewInputSchema, storefrontDeparturePricePreviewSchema, storefrontDepartureSchema, storefrontFormFieldInputSchema, storefrontFormFieldOptionSchema, storefrontFormFieldSchema, storefrontFormFieldTypeSchema, storefrontOfferApplyInputSchema, storefrontOfferAudienceSchema, storefrontOfferConflictSchema, storefrontOfferMutationReasonSchema, storefrontOfferMutationResponseSchema, storefrontOfferMutationResultSchema, storefrontOfferMutationStatusSchema, storefrontOfferRedeemInputSchema, storefrontPaymentMethodCodeSchema, storefrontPaymentMethodInputSchema, storefrontPaymentMethodSchema, storefrontProductAvailabilitySlotSchema, storefrontProductAvailabilityStateSchema, storefrontProductAvailabilitySummaryQuerySchema, storefrontProductAvailabilitySummaryResponseSchema, storefrontProductAvailabilitySummarySchema, storefrontProductExtensionsQuerySchema, storefrontProductExtensionsResponseSchema, storefrontPromotionalOfferListQuerySchema, storefrontPromotionalOfferListResponseSchema, storefrontPromotionalOfferResponseSchema, storefrontPromotionalOfferSchema, storefrontSettingsInputSchema, storefrontSettingsSchema, } from "./validation.js";
+export type { StorefrontTransportEligibilityInput, StorefrontTransportEligibilityIssue, StorefrontTransportEligibilityResult, StorefrontTransportEligibilityRule, StorefrontTransportEligibilityRuleInput, } from "./validation-transport-eligibility.js";
+export { storefrontRequiredDocumentTypeSchema, storefrontTransportEligibilityDocumentInputSchema, storefrontTransportEligibilityInputSchema, storefrontTransportEligibilityIssueCodeSchema, storefrontTransportEligibilityIssueSchema, storefrontTransportEligibilityResultSchema, storefrontTransportEligibilityRuleSchema, storefrontTransportEligibilitySeveritySchema, storefrontTransportEligibilityTravelerInputSchema, storefrontTransportEligibilityTravelerResultSchema, storefrontTravelDocumentTypeSchema, } from "./validation-transport-eligibility.js";
 export declare const storefrontModule: Module;
 export declare function createStorefrontHonoModule(options?: Parameters<typeof createStorefrontPublicRoutes>[0]): HonoModule;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAEvD,OAAO,EAAE,4BAA4B,EAAE,MAAM,oBAAoB,CAAA;AAEjE,YAAY,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAA;AAChE,OAAO,EAAE,4BAA4B,EAAE,MAAM,oBAAoB,CAAA;AACjE,YAAY,EACV,wBAAwB,EACxB,wBAAwB,EACxB,wBAAwB,GACzB,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,uBAAuB,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAA;AACjF,YAAY,EACV,sBAAsB,EACtB,4BAA4B,EAC5B,mBAAmB,EACnB,wBAAwB,EACxB,yBAAyB,EACzB,6BAA6B,EAC7B,0BAA0B,EAC1B,uBAAuB,EACvB,2BAA2B,EAC3B,4BAA4B,EAC5B,yCAAyC,EACzC,0BAA0B,EAC1B,kBAAkB,EAClB,uBAAuB,GACxB,MAAM,iBAAiB,CAAA;AACxB,OAAO,EACL,4BAA4B,EAC5B,kCAAkC,EAClC,kCAAkC,EAClC,qCAAqC,EACrC,0CAA0C,EAC1C,qCAAqC,EACrC,yBAAyB,EACzB,8BAA8B,EAC9B,+BAA+B,EAC/B,yBAAyB,EACzB,6BAA6B,EAC7B,+BAA+B,EAC/B,6BAA6B,EAC7B,6BAA6B,EAC7B,mCAAmC,EACnC,qCAAqC,EACrC,mCAAmC,EACnC,mCAAmC,EACnC,gCAAgC,EAChC,iCAAiC,EACjC,kCAAkC,EAClC,6BAA6B,EAC7B,uCAAuC,EACvC,wCAAwC,EACxC,+CAA+C,EAC/C,kDAAkD,EAClD,0CAA0C,EAC1C,sCAAsC,EACtC,yCAAyC,EACzC,yCAAyC,EACzC,4CAA4C,EAC5C,wCAAwC,EACxC,gCAAgC,EAChC,6BAA6B,EAC7B,wBAAwB,GACzB,MAAM,iBAAiB,CAAA;AAExB,eAAO,MAAM,gBAAgB,EAAE,MAE9B,CAAA;AAED,wBAAgB,0BAA0B,CACxC,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,4BAA4B,CAAC,CAAC,CAAC,CAAC,GAC3D,UAAU,CAMZ"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAEvD,OAAO,EAAE,4BAA4B,EAAE,MAAM,oBAAoB,CAAA;AAEjE,YAAY,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAA;AAChE,OAAO,EAAE,4BAA4B,EAAE,MAAM,oBAAoB,CAAA;AACjE,YAAY,EACV,wBAAwB,EACxB,wBAAwB,EACxB,wBAAwB,GACzB,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,uBAAuB,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAA;AACjF,OAAO,EAAE,sCAAsC,EAAE,MAAM,oCAAoC,CAAA;AAC3F,YAAY,EACV,sBAAsB,EACtB,4BAA4B,EAC5B,mBAAmB,EACnB,wBAAwB,EACxB,yBAAyB,EACzB,6BAA6B,EAC7B,0BAA0B,EAC1B,uBAAuB,EACvB,2BAA2B,EAC3B,4BAA4B,EAC5B,yCAAyC,EACzC,0BAA0B,EAC1B,kBAAkB,EAClB,uBAAuB,GACxB,MAAM,iBAAiB,CAAA;AACxB,OAAO,EACL,4BAA4B,EAC5B,kCAAkC,EAClC,kCAAkC,EAClC,qCAAqC,EACrC,0CAA0C,EAC1C,qCAAqC,EACrC,yBAAyB,EACzB,8BAA8B,EAC9B,+BAA+B,EAC/B,yBAAyB,EACzB,6BAA6B,EAC7B,+BAA+B,EAC/B,6BAA6B,EAC7B,6BAA6B,EAC7B,mCAAmC,EACnC,qCAAqC,EACrC,mCAAmC,EACnC,mCAAmC,EACnC,gCAAgC,EAChC,iCAAiC,EACjC,kCAAkC,EAClC,6BAA6B,EAC7B,uCAAuC,EACvC,wCAAwC,EACxC,+CAA+C,EAC/C,kDAAkD,EAClD,0CAA0C,EAC1C,sCAAsC,EACtC,yCAAyC,EACzC,yCAAyC,EACzC,4CAA4C,EAC5C,wCAAwC,EACxC,gCAAgC,EAChC,6BAA6B,EAC7B,wBAAwB,GACzB,MAAM,iBAAiB,CAAA;AACxB,YAAY,EACV,mCAAmC,EACnC,mCAAmC,EACnC,oCAAoC,EACpC,kCAAkC,EAClC,uCAAuC,GACxC,MAAM,uCAAuC,CAAA;AAC9C,OAAO,EACL,oCAAoC,EACpC,iDAAiD,EACjD,yCAAyC,EACzC,6CAA6C,EAC7C,yCAAyC,EACzC,0CAA0C,EAC1C,wCAAwC,EACxC,4CAA4C,EAC5C,iDAAiD,EACjD,kDAAkD,EAClD,kCAAkC,GACnC,MAAM,uCAAuC,CAAA;AAE9C,eAAO,MAAM,gBAAgB,EAAE,MAE9B,CAAA;AAED,wBAAgB,0BAA0B,CACxC,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,4BAA4B,CAAC,CAAC,CAAC,CAAC,GAC3D,UAAU,CAMZ"}

package/dist/index.js

@@ -1,7 +1,9 @@
 import { createStorefrontPublicRoutes } from "./routes-public.js";
 export { createStorefrontPublicRoutes } from "./routes-public.js";
 export { createStorefrontService, resolveStorefrontSettings } from "./service.js";
+export { evaluateStorefrontTransportEligibility } from "./service-transport-eligibility.js";
 export { storefrontAppliedOfferSchema, storefrontDepartureItinerarySchema, storefrontDepartureListQuerySchema, storefrontDepartureListResponseSchema, storefrontDeparturePricePreviewInputSchema, storefrontDeparturePricePreviewSchema, storefrontDepartureSchema, storefrontFormFieldInputSchema, storefrontFormFieldOptionSchema, storefrontFormFieldSchema, storefrontFormFieldTypeSchema, storefrontOfferApplyInputSchema, storefrontOfferAudienceSchema, storefrontOfferConflictSchema, storefrontOfferMutationReasonSchema, storefrontOfferMutationResponseSchema, storefrontOfferMutationResultSchema, storefrontOfferMutationStatusSchema, storefrontOfferRedeemInputSchema, storefrontPaymentMethodCodeSchema, storefrontPaymentMethodInputSchema, storefrontPaymentMethodSchema, storefrontProductAvailabilitySlotSchema, storefrontProductAvailabilityStateSchema, storefrontProductAvailabilitySummaryQuerySchema, storefrontProductAvailabilitySummaryResponseSchema, storefrontProductAvailabilitySummarySchema, storefrontProductExtensionsQuerySchema, storefrontProductExtensionsResponseSchema, storefrontPromotionalOfferListQuerySchema, storefrontPromotionalOfferListResponseSchema, storefrontPromotionalOfferResponseSchema, storefrontPromotionalOfferSchema, storefrontSettingsInputSchema, storefrontSettingsSchema, } from "./validation.js";
+export { storefrontRequiredDocumentTypeSchema, storefrontTransportEligibilityDocumentInputSchema, storefrontTransportEligibilityInputSchema, storefrontTransportEligibilityIssueCodeSchema, storefrontTransportEligibilityIssueSchema, storefrontTransportEligibilityResultSchema, storefrontTransportEligibilityRuleSchema, storefrontTransportEligibilitySeveritySchema, storefrontTransportEligibilityTravelerInputSchema, storefrontTransportEligibilityTravelerResultSchema, storefrontTravelDocumentTypeSchema, } from "./validation-transport-eligibility.js";
 export const storefrontModule = {
     name: "storefront",
 };

package/dist/routes-public.d.ts

@@ -243,6 +243,132 @@ export declare function createStorefrontPublicRoutes(options?: StorefrontService
             status: 404;
         };
     };
+} & {
+    "/departures/:departureId/eligibility": {
+        $post: {
+            input: {
+                param: {
+                    departureId: string;
+                };
+            };
+            output: {
+                data: {
+                    departureId: string;
+                    productId: string | null;
+                    travelStartsOn: string | null;
+                    travelEndsOn: string | null;
+                    eligible: boolean;
+                    blockingIssues: {
+                        code: "date_of_birth_required" | "document_required" | "document_expiry_required" | "document_validity" | "nationality_required" | "visa_required" | "minor_consent_required" | "travel_dates_required";
+                        severity: "warning" | "blocking";
+                        message: string;
+                        travelerRef: string;
+                        ruleId: string;
+                        destinationCountries: string[];
+                        requiredDocumentType: "passport" | "none" | "id_card" | "passport_or_id_card";
+                    }[];
+                    warnings: {
+                        code: "date_of_birth_required" | "document_required" | "document_expiry_required" | "document_validity" | "nationality_required" | "visa_required" | "minor_consent_required" | "travel_dates_required";
+                        severity: "warning" | "blocking";
+                        message: string;
+                        travelerRef: string;
+                        ruleId: string;
+                        destinationCountries: string[];
+                        requiredDocumentType: "passport" | "none" | "id_card" | "passport_or_id_card";
+                    }[];
+                    travelers: {
+                        travelerRef: string;
+                        eligible: boolean;
+                        matchedRuleIds: string[];
+                        blockingIssues: {
+                            code: "date_of_birth_required" | "document_required" | "document_expiry_required" | "document_validity" | "nationality_required" | "visa_required" | "minor_consent_required" | "travel_dates_required";
+                            severity: "warning" | "blocking";
+                            message: string;
+                            travelerRef: string;
+                            ruleId: string;
+                            destinationCountries: string[];
+                            requiredDocumentType: "passport" | "none" | "id_card" | "passport_or_id_card";
+                        }[];
+                        warnings: {
+                            code: "date_of_birth_required" | "document_required" | "document_expiry_required" | "document_validity" | "nationality_required" | "visa_required" | "minor_consent_required" | "travel_dates_required";
+                            severity: "warning" | "blocking";
+                            message: string;
+                            travelerRef: string;
+                            ruleId: string;
+                            destinationCountries: string[];
+                            requiredDocumentType: "passport" | "none" | "id_card" | "passport_or_id_card";
+                        }[];
+                    }[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/products/:productId/departures/:departureId/eligibility": {
+        $post: {
+            input: {
+                param: {
+                    departureId: string;
+                } & {
+                    productId: string;
+                };
+            };
+            output: {
+                data: {
+                    departureId: string;
+                    productId: string | null;
+                    travelStartsOn: string | null;
+                    travelEndsOn: string | null;
+                    eligible: boolean;
+                    blockingIssues: {
+                        code: "date_of_birth_required" | "document_required" | "document_expiry_required" | "document_validity" | "nationality_required" | "visa_required" | "minor_consent_required" | "travel_dates_required";
+                        severity: "warning" | "blocking";
+                        message: string;
+                        travelerRef: string;
+                        ruleId: string;
+                        destinationCountries: string[];
+                        requiredDocumentType: "passport" | "none" | "id_card" | "passport_or_id_card";
+                    }[];
+                    warnings: {
+                        code: "date_of_birth_required" | "document_required" | "document_expiry_required" | "document_validity" | "nationality_required" | "visa_required" | "minor_consent_required" | "travel_dates_required";
+                        severity: "warning" | "blocking";
+                        message: string;
+                        travelerRef: string;
+                        ruleId: string;
+                        destinationCountries: string[];
+                        requiredDocumentType: "passport" | "none" | "id_card" | "passport_or_id_card";
+                    }[];
+                    travelers: {
+                        travelerRef: string;
+                        eligible: boolean;
+                        matchedRuleIds: string[];
+                        blockingIssues: {
+                            code: "date_of_birth_required" | "document_required" | "document_expiry_required" | "document_validity" | "nationality_required" | "visa_required" | "minor_consent_required" | "travel_dates_required";
+                            severity: "warning" | "blocking";
+                            message: string;
+                            travelerRef: string;
+                            ruleId: string;
+                            destinationCountries: string[];
+                            requiredDocumentType: "passport" | "none" | "id_card" | "passport_or_id_card";
+                        }[];
+                        warnings: {
+                            code: "date_of_birth_required" | "document_required" | "document_expiry_required" | "document_validity" | "nationality_required" | "visa_required" | "minor_consent_required" | "travel_dates_required";
+                            severity: "warning" | "blocking";
+                            message: string;
+                            travelerRef: string;
+                            ruleId: string;
+                            destinationCountries: string[];
+                            requiredDocumentType: "passport" | "none" | "id_card" | "passport_or_id_card";
+                        }[];
+                    }[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
 } & {
     "/products/:productId/extensions": {
         $get: {

package/dist/routes-public.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"routes-public.d.ts","sourceRoot":"","sources":["../src/routes-public.ts"],"names":[],"mappings":"AAIA,OAAO,EAGL,KAAK,wBAAwB,EAC9B,MAAM,cAAc,CAAA;AAWrB,KAAK,GAAG,GAAG;IACT,SAAS,EAAE;QACT,EAAE,EAAE,OAAO,CAAA;KACZ,CAAA;CACF,CAAA;AAED,wBAAgB,4BAA4B,CAAC,OAAO,CAAC,EAAE,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAsH9E;AAED,MAAM,MAAM,sBAAsB,GAAG,UAAU,CAAC,OAAO,4BAA4B,CAAC,CAAA"}
+{"version":3,"file":"routes-public.d.ts","sourceRoot":"","sources":["../src/routes-public.ts"],"names":[],"mappings":"AAIA,OAAO,EAGL,KAAK,wBAAwB,EAC9B,MAAM,cAAc,CAAA;AAYrB,KAAK,GAAG,GAAG;IACT,SAAS,EAAE;QACT,EAAE,EAAE,OAAO,CAAA;KACZ,CAAA;CACF,CAAA;AAED,wBAAgB,4BAA4B,CAAC,OAAO,CAAC,EAAE,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAyI9E;AAED,MAAM,MAAM,sBAAsB,GAAG,UAAU,CAAC,OAAO,4BAA4B,CAAC,CAAA"}

package/dist/routes-public.js

@@ -2,6 +2,7 @@ import { parseJsonBody, parseQuery } from "@voyantjs/hono";
 import { Hono } from "hono";
 import { createStorefrontService, } from "./service.js";
 import { storefrontDepartureListQuerySchema, storefrontDeparturePricePreviewInputSchema, storefrontOfferApplyInputSchema, storefrontOfferRedeemInputSchema, storefrontProductAvailabilitySummaryQuerySchema, storefrontProductExtensionsQuerySchema, storefrontPromotionalOfferListQuerySchema, } from "./validation.js";
+import { storefrontTransportEligibilityInputSchema } from "./validation-transport-eligibility.js";
 export function createStorefrontPublicRoutes(options) {
     const storefrontService = createStorefrontService(options);
     function getRequestContext(c) {
@@ -29,6 +30,25 @@ export function createStorefrontPublicRoutes(options) {
         return preview
             ? c.json({ data: preview })
             : c.json({ error: "Storefront departure not found" }, 404);
+    })
+        .post("/departures/:departureId/eligibility", async (c) => {
+        return c.json({
+            data: await storefrontService.checkDepartureTransportEligibility({
+                departureId: c.req.param("departureId"),
+                body: await parseJsonBody(c, storefrontTransportEligibilityInputSchema),
+                context: getRequestContext(c),
+            }),
+        });
+    })
+        .post("/products/:productId/departures/:departureId/eligibility", async (c) => {
+        return c.json({
+            data: await storefrontService.checkDepartureTransportEligibility({
+                departureId: c.req.param("departureId"),
+                productId: c.req.param("productId"),
+                body: await parseJsonBody(c, storefrontTransportEligibilityInputSchema),
+                context: getRequestContext(c),
+            }),
+        });
     })
         .get("/products/:productId/extensions", async (c) => {
         const query = await parseQuery(c, storefrontProductExtensionsQuerySchema);

package/dist/service-transport-eligibility.d.ts

@@ -0,0 +1,10 @@
+import type { StorefrontTransportEligibilityInput, StorefrontTransportEligibilityResult, StorefrontTransportEligibilityRuleInput } from "./validation-transport-eligibility.js";
+export declare function evaluateStorefrontTransportEligibility(input: {
+    departureId: string;
+    productId?: string | null;
+    travelStartsOn?: string | null;
+    travelEndsOn?: string | null;
+    travelers: StorefrontTransportEligibilityInput["travelers"];
+    rules: StorefrontTransportEligibilityRuleInput[];
+}): StorefrontTransportEligibilityResult;
+//# sourceMappingURL=service-transport-eligibility.d.ts.map

package/dist/service-transport-eligibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-transport-eligibility.d.ts","sourceRoot":"","sources":["../src/service-transport-eligibility.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mCAAmC,EAEnC,oCAAoC,EAEpC,uCAAuC,EACxC,MAAM,uCAAuC,CAAA;AAoR9C,wBAAgB,sCAAsC,CAAC,KAAK,EAAE;IAC5D,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC9B,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,SAAS,EAAE,mCAAmC,CAAC,WAAW,CAAC,CAAA;IAC3D,KAAK,EAAE,uCAAuC,EAAE,CAAA;CACjD,GAAG,oCAAoC,CA0CvC"}

package/dist/service-transport-eligibility.js

@@ -0,0 +1,198 @@
+import { storefrontTransportEligibilityRuleSchema } from "./validation-transport-eligibility.js";
+function parseDate(value) {
+    if (!value)
+        return null;
+    const date = new Date(`${value}T00:00:00.000Z`);
+    return Number.isNaN(date.getTime()) ? null : date;
+}
+function addDays(value, days) {
+    const date = parseDate(value);
+    if (!date)
+        return value;
+    date.setUTCDate(date.getUTCDate() + days);
+    return date.toISOString().slice(0, 10);
+}
+function getAgeOn(dateOfBirth, onDate) {
+    const birth = parseDate(dateOfBirth);
+    const reference = parseDate(onDate);
+    if (!birth || !reference)
+        return null;
+    let age = reference.getUTCFullYear() - birth.getUTCFullYear();
+    const birthdayThisYear = Date.UTC(reference.getUTCFullYear(), birth.getUTCMonth(), birth.getUTCDate());
+    if (reference.getTime() < birthdayThisYear) {
+        age -= 1;
+    }
+    return age;
+}
+function isBeforeDate(left, right) {
+    const leftDate = parseDate(left);
+    const rightDate = parseDate(right);
+    if (!leftDate || !rightDate)
+        return false;
+    return leftDate.getTime() < rightDate.getTime();
+}
+function findDocuments(traveler, rule) {
+    if (rule.requiredDocumentType === "none")
+        return [];
+    if (rule.requiredDocumentType === "passport_or_id_card") {
+        return traveler.documents.filter((document) => document.type === "passport" || document.type === "id_card");
+    }
+    return traveler.documents.filter((document) => document.type === rule.requiredDocumentType);
+}
+function documentTypeLabel(rule) {
+    switch (rule.requiredDocumentType) {
+        case "passport_or_id_card":
+            return "passport or ID card";
+        case "id_card":
+            return "ID card";
+        case "passport":
+            return "passport";
+        case "none":
+            return "travel document";
+    }
+}
+function buildIssue(code, traveler, rule, message) {
+    return {
+        code,
+        severity: rule.severity,
+        message: rule.message ?? message,
+        travelerRef: traveler.travelerRef,
+        ruleId: rule.id,
+        destinationCountries: rule.destinationCountries,
+        requiredDocumentType: rule.requiredDocumentType,
+    };
+}
+function pushIssue(target, issue) {
+    if (issue.severity === "warning") {
+        target.warnings.push(issue);
+    }
+    else {
+        target.blockingIssues.push(issue);
+    }
+}
+function appliesToTarget(rule, target) {
+    if (rule.productId && rule.productId !== target.productId)
+        return false;
+    if (rule.departureId && rule.departureId !== target.departureId)
+        return false;
+    return true;
+}
+function appliesToTraveler(rule, traveler, travelStartsOn) {
+    if (rule.nationalityCountries.length > 0) {
+        if (!traveler.nationalityCountry)
+            return "missing_nationality";
+        if (!rule.nationalityCountries.includes(traveler.nationalityCountry))
+            return false;
+    }
+    if (rule.minAge == null && rule.maxAge == null)
+        return true;
+    if (!traveler.dateOfBirth || !travelStartsOn)
+        return "missing_age_basis";
+    const age = getAgeOn(traveler.dateOfBirth, travelStartsOn);
+    if (age == null)
+        return "missing_age_basis";
+    if (rule.minAge != null && age < rule.minAge)
+        return false;
+    if (rule.maxAge != null && age > rule.maxAge)
+        return false;
+    return true;
+}
+function evaluateTravelerRule(traveler, rule, target) {
+    const blockingIssues = [];
+    const warnings = [];
+    const resultTarget = { blockingIssues, warnings };
+    const travelerApplicability = appliesToTraveler(rule, traveler, target.travelStartsOn);
+    if (travelerApplicability === false) {
+        return null;
+    }
+    if (travelerApplicability === "missing_nationality") {
+        pushIssue(resultTarget, buildIssue("nationality_required", traveler, rule, "Traveler nationality is required to evaluate destination document rules."));
+    }
+    if (travelerApplicability === "missing_age_basis") {
+        pushIssue(resultTarget, buildIssue("date_of_birth_required", traveler, rule, "Traveler date of birth and travel start date are required to evaluate age rules."));
+    }
+    const documents = findDocuments(traveler, rule);
+    if (rule.requiredDocumentType !== "none" && documents.length === 0) {
+        pushIssue(resultTarget, buildIssue("document_required", traveler, rule, `Traveler needs a ${documentTypeLabel(rule)} for this destination.`));
+    }
+    if (rule.minValidityDaysAfterReturn > 0) {
+        if (!target.travelEndsOn) {
+            pushIssue(resultTarget, buildIssue("travel_dates_required", traveler, rule, "Travel end date is required to evaluate document validity after return."));
+        }
+        else if (documents.length === 0) {
+            // Missing documents are already reported through document_required.
+        }
+        else {
+            const requiredValidUntil = addDays(target.travelEndsOn, rule.minValidityDaysAfterReturn);
+            const documentsWithExpiry = documents.filter((document) => typeof document.expiresOn === "string");
+            const hasValidDocument = documentsWithExpiry.some((document) => !isBeforeDate(document.expiresOn, requiredValidUntil));
+            if (hasValidDocument) {
+                // Any acceptable document can satisfy a passport-or-ID-card validity rule.
+            }
+            else if (documentsWithExpiry.length > 0) {
+                pushIssue(resultTarget, buildIssue("document_validity", traveler, rule, `Traveler ${documentTypeLabel(rule)} must be valid until at least ${requiredValidUntil}.`));
+            }
+            else {
+                pushIssue(resultTarget, buildIssue("document_expiry_required", traveler, rule, `Traveler ${documentTypeLabel(rule)} expiry date is required.`));
+            }
+        }
+    }
+    if (rule.visaRequired) {
+        const hasVisa = traveler.hasVisa || traveler.documents.some((document) => document.type === "visa");
+        if (!hasVisa) {
+            pushIssue(resultTarget, buildIssue("visa_required", traveler, rule, "Traveler needs a visa for this destination."));
+        }
+    }
+    if (rule.minorConsentRequired) {
+        const age = traveler.dateOfBirth && target.travelStartsOn
+            ? getAgeOn(traveler.dateOfBirth, target.travelStartsOn)
+            : null;
+        const isMinor = age == null ? true : age < 18;
+        const hasConsent = traveler.hasMinorConsent ||
+            traveler.travelingWithGuardian ||
+            traveler.documents.some((document) => document.type === "minor_consent");
+        if (isMinor && !hasConsent) {
+            pushIssue(resultTarget, buildIssue("minor_consent_required", traveler, rule, "Minor traveler needs guardian travel consent for this departure."));
+        }
+    }
+    return { blockingIssues, warnings };
+}
+export function evaluateStorefrontTransportEligibility(input) {
+    const travelStartsOn = input.travelStartsOn ?? null;
+    const travelEndsOn = input.travelEndsOn ?? null;
+    const rules = input.rules
+        .map((rule) => storefrontTransportEligibilityRuleSchema.parse(rule))
+        .filter((rule) => appliesToTarget(rule, input));
+    const travelerResults = input.travelers.map((traveler) => {
+        const blockingIssues = [];
+        const warnings = [];
+        const matchedRuleIds = [];
+        for (const rule of rules) {
+            const result = evaluateTravelerRule(traveler, rule, { travelStartsOn, travelEndsOn });
+            if (!result)
+                continue;
+            matchedRuleIds.push(rule.id);
+            blockingIssues.push(...result.blockingIssues);
+            warnings.push(...result.warnings);
+        }
+        return {
+            travelerRef: traveler.travelerRef,
+            eligible: blockingIssues.length === 0,
+            matchedRuleIds,
+            blockingIssues,
+            warnings,
+        };
+    });
+    const blockingIssues = travelerResults.flatMap((traveler) => traveler.blockingIssues);
+    const warnings = travelerResults.flatMap((traveler) => traveler.warnings);
+    return {
+        departureId: input.departureId,
+        productId: input.productId ?? null,
+        travelStartsOn,
+        travelEndsOn,
+        eligible: blockingIssues.length === 0,
+        blockingIssues,
+        warnings,
+        travelers: travelerResults,
+    };
+}

package/dist/service.d.ts

@@ -1,10 +1,18 @@
 import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
 import { type StorefrontDepartureListQuery, type StorefrontDeparturePricePreviewInput, type StorefrontOfferApplyInput, type StorefrontOfferMutationResult, type StorefrontOfferRedeemInput, type StorefrontProductAvailabilitySummaryQuery, type StorefrontPromotionalOffer, type StorefrontSettings, type StorefrontSettingsInput } from "./validation.js";
+import type { StorefrontTransportEligibilityInput, StorefrontTransportEligibilityResult, StorefrontTransportEligibilityRuleInput } from "./validation-transport-eligibility.js";
 export interface StorefrontServiceOptions {
     settings?: StorefrontSettingsInput;
     resolveSettings?: (context: StorefrontRequestContext) => Promise<StorefrontSettingsInput> | StorefrontSettingsInput;
     offers?: StorefrontOfferResolvers;
     resolveOffers?: (context: StorefrontRequestContext) => Promise<StorefrontOfferResolvers | null | undefined> | StorefrontOfferResolvers | null | undefined;
+    transportEligibilityRules?: StorefrontTransportEligibilityRuleInput[];
+    resolveTransportEligibilityRules?: (input: {
+        departureId: string;
+        productId?: string | null;
+        travelStartsOn?: string | null;
+        travelEndsOn?: string | null;
+    } & StorefrontRequestContext) => Promise<StorefrontTransportEligibilityRuleInput[]> | StorefrontTransportEligibilityRuleInput[];
 }
 export interface StorefrontRequestContext {
     db?: PostgresJsDatabase;
@@ -296,6 +304,12 @@ export declare function createStorefrontService(options?: StorefrontServiceOptio
             }[];
         }[];
     } | null>;
+    checkDepartureTransportEligibility(input: {
+        departureId: string;
+        productId?: string | null;
+        body: StorefrontTransportEligibilityInput;
+        context?: StorefrontRequestContext;
+    }): Promise<StorefrontTransportEligibilityResult>;
     listApplicableOffers(input: {
         productId: string;
         departureId?: string;

package/dist/service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"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"}

package/dist/service.js

@@ -1,4 +1,5 @@
 import { getStorefrontDeparture, getStorefrontDepartureItinerary, getStorefrontProductAvailabilitySummary, getStorefrontProductExtensions, listStorefrontProductDepartures, previewStorefrontDeparturePrice, } from "./service-departures.js";
+import { evaluateStorefrontTransportEligibility } from "./service-transport-eligibility.js";
 import { storefrontSettingsInputSchema, storefrontSettingsSchema, } from "./validation.js";
 const defaultPaymentLabels = {
     card: "Card",
@@ -68,6 +69,11 @@ export function createStorefrontService(options) {
     async function resolveOffers(context = {}) {
         return (await options?.resolveOffers?.(context)) ?? options?.offers;
     }
+    async function resolveTransportEligibilityRules(input) {
+        return ((await options?.resolveTransportEligibilityRules?.(input)) ??
+            options?.transportEligibilityRules ??
+            []);
+    }
     return {
         getSettings() {
             return settings;
@@ -91,6 +97,29 @@ export function createStorefrontService(options) {
         getDepartureItinerary(db, input) {
             return getStorefrontDepartureItinerary(db, input);
         },
+        async checkDepartureTransportEligibility(input) {
+            const { context, body, departureId } = input;
+            const needsDeparture = context?.db && (!input.productId || !body.travelStartsOn || !body.travelEndsOn);
+            const departure = needsDeparture && context?.db ? await getStorefrontDeparture(context.db, departureId) : null;
+            const productId = input.productId ?? departure?.productId ?? null;
+            const travelStartsOn = body.travelStartsOn ?? departure?.dateLocal ?? departure?.startAt?.slice(0, 10) ?? null;
+            const travelEndsOn = body.travelEndsOn ?? departure?.endAt?.slice(0, 10) ?? departure?.dateLocal ?? null;
+            const rules = await resolveTransportEligibilityRules({
+                ...(context ?? {}),
+                departureId,
+                productId,
+                travelStartsOn,
+                travelEndsOn,
+            });
+            return evaluateStorefrontTransportEligibility({
+                departureId,
+                productId,
+                travelStartsOn,
+                travelEndsOn,
+                travelers: body.travelers,
+                rules,
+            });
+        },
         async listApplicableOffers(input) {
             const { context, ...offerInput } = input;
             const offers = await resolveOffers(context)?.then((resolvers) => resolvers?.listApplicableOffers?.({ ...offerInput, ...(context ?? {}) }));

package/dist/transport-eligibility.d.ts

@@ -0,0 +1,4 @@
+export { evaluateStorefrontTransportEligibility } from "./service-transport-eligibility.js";
+export type { StorefrontTransportEligibilityInput, StorefrontTransportEligibilityIssue, StorefrontTransportEligibilityResult, StorefrontTransportEligibilityRule, StorefrontTransportEligibilityRuleInput, } from "./validation-transport-eligibility.js";
+export { storefrontRequiredDocumentTypeSchema, storefrontTransportEligibilityDocumentInputSchema, storefrontTransportEligibilityInputSchema, storefrontTransportEligibilityIssueCodeSchema, storefrontTransportEligibilityIssueSchema, storefrontTransportEligibilityResultSchema, storefrontTransportEligibilityRuleSchema, storefrontTransportEligibilitySeveritySchema, storefrontTransportEligibilityTravelerInputSchema, storefrontTransportEligibilityTravelerResultSchema, storefrontTravelDocumentTypeSchema, } from "./validation-transport-eligibility.js";
+//# sourceMappingURL=transport-eligibility.d.ts.map

package/dist/transport-eligibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport-eligibility.d.ts","sourceRoot":"","sources":["../src/transport-eligibility.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sCAAsC,EAAE,MAAM,oCAAoC,CAAA;AAC3F,YAAY,EACV,mCAAmC,EACnC,mCAAmC,EACnC,oCAAoC,EACpC,kCAAkC,EAClC,uCAAuC,GACxC,MAAM,uCAAuC,CAAA;AAC9C,OAAO,EACL,oCAAoC,EACpC,iDAAiD,EACjD,yCAAyC,EACzC,6CAA6C,EAC7C,yCAAyC,EACzC,0CAA0C,EAC1C,wCAAwC,EACxC,4CAA4C,EAC5C,iDAAiD,EACjD,kDAAkD,EAClD,kCAAkC,GACnC,MAAM,uCAAuC,CAAA"}

package/dist/transport-eligibility.js

@@ -0,0 +1,2 @@
+export { evaluateStorefrontTransportEligibility } from "./service-transport-eligibility.js";
+export { storefrontRequiredDocumentTypeSchema, storefrontTransportEligibilityDocumentInputSchema, storefrontTransportEligibilityInputSchema, storefrontTransportEligibilityIssueCodeSchema, storefrontTransportEligibilityIssueSchema, storefrontTransportEligibilityResultSchema, storefrontTransportEligibilityRuleSchema, storefrontTransportEligibilitySeveritySchema, storefrontTransportEligibilityTravelerInputSchema, storefrontTransportEligibilityTravelerResultSchema, storefrontTravelDocumentTypeSchema, } from "./validation-transport-eligibility.js";

package/dist/validation-transport-eligibility.d.ts

@@ -0,0 +1,314 @@
+import { z } from "zod";
+export declare const storefrontTravelDocumentTypeSchema: z.ZodEnum<{
+    passport: "passport";
+    visa: "visa";
+    other: "other";
+    id_card: "id_card";
+    residence_permit: "residence_permit";
+    minor_consent: "minor_consent";
+}>;
+export declare const storefrontRequiredDocumentTypeSchema: z.ZodEnum<{
+    passport: "passport";
+    none: "none";
+    id_card: "id_card";
+    passport_or_id_card: "passport_or_id_card";
+}>;
+export declare const storefrontTransportEligibilitySeveritySchema: z.ZodEnum<{
+    warning: "warning";
+    blocking: "blocking";
+}>;
+export declare const storefrontTransportEligibilityRuleSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    productId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    departureId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    destinationCountries: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+    nationalityCountries: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+    requiredDocumentType: z.ZodDefault<z.ZodEnum<{
+        passport: "passport";
+        none: "none";
+        id_card: "id_card";
+        passport_or_id_card: "passport_or_id_card";
+    }>>;
+    minValidityDaysAfterReturn: z.ZodDefault<z.ZodNumber>;
+    minAge: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    maxAge: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    visaRequired: z.ZodDefault<z.ZodBoolean>;
+    minorConsentRequired: z.ZodDefault<z.ZodBoolean>;
+    severity: z.ZodDefault<z.ZodEnum<{
+        warning: "warning";
+        blocking: "blocking";
+    }>>;
+    message: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+export declare const storefrontTransportEligibilityDocumentInputSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        passport: "passport";
+        visa: "visa";
+        other: "other";
+        id_card: "id_card";
+        residence_permit: "residence_permit";
+        minor_consent: "minor_consent";
+    }>;
+    issuingCountry: z.ZodNullable<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+    expiresOn: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+export declare const storefrontTransportEligibilityTravelerInputSchema: z.ZodObject<{
+    travelerRef: z.ZodString;
+    nationalityCountry: z.ZodNullable<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+    dateOfBirth: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    documents: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            passport: "passport";
+            visa: "visa";
+            other: "other";
+            id_card: "id_card";
+            residence_permit: "residence_permit";
+            minor_consent: "minor_consent";
+        }>;
+        issuingCountry: z.ZodNullable<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+        expiresOn: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    }, z.core.$strip>>>;
+    hasVisa: z.ZodDefault<z.ZodBoolean>;
+    travelingWithGuardian: z.ZodDefault<z.ZodBoolean>;
+    hasMinorConsent: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const storefrontTransportEligibilityInputSchema: z.ZodObject<{
+    travelStartsOn: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    travelEndsOn: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    travelers: z.ZodArray<z.ZodObject<{
+        travelerRef: z.ZodString;
+        nationalityCountry: z.ZodNullable<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+        dateOfBirth: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        documents: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<{
+                passport: "passport";
+                visa: "visa";
+                other: "other";
+                id_card: "id_card";
+                residence_permit: "residence_permit";
+                minor_consent: "minor_consent";
+            }>;
+            issuingCountry: z.ZodNullable<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+            expiresOn: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        }, z.core.$strip>>>;
+        hasVisa: z.ZodDefault<z.ZodBoolean>;
+        travelingWithGuardian: z.ZodDefault<z.ZodBoolean>;
+        hasMinorConsent: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const storefrontTransportEligibilityIssueCodeSchema: z.ZodEnum<{
+    date_of_birth_required: "date_of_birth_required";
+    document_required: "document_required";
+    document_expiry_required: "document_expiry_required";
+    document_validity: "document_validity";
+    nationality_required: "nationality_required";
+    visa_required: "visa_required";
+    minor_consent_required: "minor_consent_required";
+    travel_dates_required: "travel_dates_required";
+}>;
+export declare const storefrontTransportEligibilityIssueSchema: z.ZodObject<{
+    code: z.ZodEnum<{
+        date_of_birth_required: "date_of_birth_required";
+        document_required: "document_required";
+        document_expiry_required: "document_expiry_required";
+        document_validity: "document_validity";
+        nationality_required: "nationality_required";
+        visa_required: "visa_required";
+        minor_consent_required: "minor_consent_required";
+        travel_dates_required: "travel_dates_required";
+    }>;
+    severity: z.ZodEnum<{
+        warning: "warning";
+        blocking: "blocking";
+    }>;
+    message: z.ZodString;
+    travelerRef: z.ZodString;
+    ruleId: z.ZodString;
+    destinationCountries: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+    requiredDocumentType: z.ZodEnum<{
+        passport: "passport";
+        none: "none";
+        id_card: "id_card";
+        passport_or_id_card: "passport_or_id_card";
+    }>;
+}, z.core.$strip>;
+export declare const storefrontTransportEligibilityTravelerResultSchema: z.ZodObject<{
+    travelerRef: z.ZodString;
+    eligible: z.ZodBoolean;
+    matchedRuleIds: z.ZodArray<z.ZodString>;
+    blockingIssues: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            date_of_birth_required: "date_of_birth_required";
+            document_required: "document_required";
+            document_expiry_required: "document_expiry_required";
+            document_validity: "document_validity";
+            nationality_required: "nationality_required";
+            visa_required: "visa_required";
+            minor_consent_required: "minor_consent_required";
+            travel_dates_required: "travel_dates_required";
+        }>;
+        severity: z.ZodEnum<{
+            warning: "warning";
+            blocking: "blocking";
+        }>;
+        message: z.ZodString;
+        travelerRef: z.ZodString;
+        ruleId: z.ZodString;
+        destinationCountries: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        requiredDocumentType: z.ZodEnum<{
+            passport: "passport";
+            none: "none";
+            id_card: "id_card";
+            passport_or_id_card: "passport_or_id_card";
+        }>;
+    }, z.core.$strip>>;
+    warnings: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            date_of_birth_required: "date_of_birth_required";
+            document_required: "document_required";
+            document_expiry_required: "document_expiry_required";
+            document_validity: "document_validity";
+            nationality_required: "nationality_required";
+            visa_required: "visa_required";
+            minor_consent_required: "minor_consent_required";
+            travel_dates_required: "travel_dates_required";
+        }>;
+        severity: z.ZodEnum<{
+            warning: "warning";
+            blocking: "blocking";
+        }>;
+        message: z.ZodString;
+        travelerRef: z.ZodString;
+        ruleId: z.ZodString;
+        destinationCountries: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        requiredDocumentType: z.ZodEnum<{
+            passport: "passport";
+            none: "none";
+            id_card: "id_card";
+            passport_or_id_card: "passport_or_id_card";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const storefrontTransportEligibilityResultSchema: z.ZodObject<{
+    departureId: z.ZodString;
+    productId: z.ZodNullable<z.ZodString>;
+    travelStartsOn: z.ZodNullable<z.ZodString>;
+    travelEndsOn: z.ZodNullable<z.ZodString>;
+    eligible: z.ZodBoolean;
+    blockingIssues: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            date_of_birth_required: "date_of_birth_required";
+            document_required: "document_required";
+            document_expiry_required: "document_expiry_required";
+            document_validity: "document_validity";
+            nationality_required: "nationality_required";
+            visa_required: "visa_required";
+            minor_consent_required: "minor_consent_required";
+            travel_dates_required: "travel_dates_required";
+        }>;
+        severity: z.ZodEnum<{
+            warning: "warning";
+            blocking: "blocking";
+        }>;
+        message: z.ZodString;
+        travelerRef: z.ZodString;
+        ruleId: z.ZodString;
+        destinationCountries: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        requiredDocumentType: z.ZodEnum<{
+            passport: "passport";
+            none: "none";
+            id_card: "id_card";
+            passport_or_id_card: "passport_or_id_card";
+        }>;
+    }, z.core.$strip>>;
+    warnings: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            date_of_birth_required: "date_of_birth_required";
+            document_required: "document_required";
+            document_expiry_required: "document_expiry_required";
+            document_validity: "document_validity";
+            nationality_required: "nationality_required";
+            visa_required: "visa_required";
+            minor_consent_required: "minor_consent_required";
+            travel_dates_required: "travel_dates_required";
+        }>;
+        severity: z.ZodEnum<{
+            warning: "warning";
+            blocking: "blocking";
+        }>;
+        message: z.ZodString;
+        travelerRef: z.ZodString;
+        ruleId: z.ZodString;
+        destinationCountries: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        requiredDocumentType: z.ZodEnum<{
+            passport: "passport";
+            none: "none";
+            id_card: "id_card";
+            passport_or_id_card: "passport_or_id_card";
+        }>;
+    }, z.core.$strip>>;
+    travelers: z.ZodArray<z.ZodObject<{
+        travelerRef: z.ZodString;
+        eligible: z.ZodBoolean;
+        matchedRuleIds: z.ZodArray<z.ZodString>;
+        blockingIssues: z.ZodArray<z.ZodObject<{
+            code: z.ZodEnum<{
+                date_of_birth_required: "date_of_birth_required";
+                document_required: "document_required";
+                document_expiry_required: "document_expiry_required";
+                document_validity: "document_validity";
+                nationality_required: "nationality_required";
+                visa_required: "visa_required";
+                minor_consent_required: "minor_consent_required";
+                travel_dates_required: "travel_dates_required";
+            }>;
+            severity: z.ZodEnum<{
+                warning: "warning";
+                blocking: "blocking";
+            }>;
+            message: z.ZodString;
+            travelerRef: z.ZodString;
+            ruleId: z.ZodString;
+            destinationCountries: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+            requiredDocumentType: z.ZodEnum<{
+                passport: "passport";
+                none: "none";
+                id_card: "id_card";
+                passport_or_id_card: "passport_or_id_card";
+            }>;
+        }, z.core.$strip>>;
+        warnings: z.ZodArray<z.ZodObject<{
+            code: z.ZodEnum<{
+                date_of_birth_required: "date_of_birth_required";
+                document_required: "document_required";
+                document_expiry_required: "document_expiry_required";
+                document_validity: "document_validity";
+                nationality_required: "nationality_required";
+                visa_required: "visa_required";
+                minor_consent_required: "minor_consent_required";
+                travel_dates_required: "travel_dates_required";
+            }>;
+            severity: z.ZodEnum<{
+                warning: "warning";
+                blocking: "blocking";
+            }>;
+            message: z.ZodString;
+            travelerRef: z.ZodString;
+            ruleId: z.ZodString;
+            destinationCountries: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+            requiredDocumentType: z.ZodEnum<{
+                passport: "passport";
+                none: "none";
+                id_card: "id_card";
+                passport_or_id_card: "passport_or_id_card";
+            }>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type StorefrontTransportEligibilityInput = z.infer<typeof storefrontTransportEligibilityInputSchema>;
+export type StorefrontTransportEligibilityRule = z.infer<typeof storefrontTransportEligibilityRuleSchema>;
+export type StorefrontTransportEligibilityRuleInput = z.input<typeof storefrontTransportEligibilityRuleSchema>;
+export type StorefrontTransportEligibilityIssue = z.infer<typeof storefrontTransportEligibilityIssueSchema>;
+export type StorefrontTransportEligibilityResult = z.infer<typeof storefrontTransportEligibilityResultSchema>;
+//# sourceMappingURL=validation-transport-eligibility.d.ts.map

package/dist/validation-transport-eligibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation-transport-eligibility.d.ts","sourceRoot":"","sources":["../src/validation-transport-eligibility.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAQvB,eAAO,MAAM,kCAAkC;;;;;;;EAO7C,CAAA;AAEF,eAAO,MAAM,oCAAoC;;;;;EAK/C,CAAA;AAEF,eAAO,MAAM,4CAA4C;;;EAAkC,CAAA;AAE3F,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;iBAoBjD,CAAA;AAEJ,eAAO,MAAM,iDAAiD;;;;;;;;;;;iBAI5D,CAAA;AAEF,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;iBAQ5D,CAAA;AAEF,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;iBAIpD,CAAA;AAEF,eAAO,MAAM,6CAA6C;;;;;;;;;EASxD,CAAA;AAEF,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;iBAQpD,CAAA;AAEF,eAAO,MAAM,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAM7D,CAAA;AAEF,eAAO,MAAM,0CAA0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBASrD,CAAA;AAEF,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,yCAAyC,CACjD,CAAA;AACD,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CACtD,OAAO,wCAAwC,CAChD,CAAA;AACD,MAAM,MAAM,uCAAuC,GAAG,CAAC,CAAC,KAAK,CAC3D,OAAO,wCAAwC,CAChD,CAAA;AACD,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,yCAAyC,CACjD,CAAA;AACD,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,KAAK,CACxD,OAAO,0CAA0C,CAClD,CAAA"}

package/dist/validation-transport-eligibility.js

@@ -0,0 +1,97 @@
+import { z } from "zod";
+const countryCodeSchema = z
+    .string()
+    .trim()
+    .length(2)
+    .transform((value) => value.toUpperCase());
+export const storefrontTravelDocumentTypeSchema = z.enum([
+    "passport",
+    "id_card",
+    "residence_permit",
+    "visa",
+    "minor_consent",
+    "other",
+]);
+export const storefrontRequiredDocumentTypeSchema = z.enum([
+    "none",
+    "passport",
+    "id_card",
+    "passport_or_id_card",
+]);
+export const storefrontTransportEligibilitySeveritySchema = z.enum(["blocking", "warning"]);
+export const storefrontTransportEligibilityRuleSchema = z
+    .object({
+    id: z.string().trim().min(1),
+    label: z.string().trim().min(1),
+    productId: z.string().trim().min(1).optional().nullable(),
+    departureId: z.string().trim().min(1).optional().nullable(),
+    destinationCountries: z.array(countryCodeSchema).min(1),
+    nationalityCountries: z.array(countryCodeSchema).default([]),
+    requiredDocumentType: storefrontRequiredDocumentTypeSchema.default("passport"),
+    minValidityDaysAfterReturn: z.number().int().min(0).default(0),
+    minAge: z.number().int().min(0).optional().nullable(),
+    maxAge: z.number().int().min(0).optional().nullable(),
+    visaRequired: z.boolean().default(false),
+    minorConsentRequired: z.boolean().default(false),
+    severity: storefrontTransportEligibilitySeveritySchema.default("blocking"),
+    message: z.string().trim().min(1).optional().nullable(),
+})
+    .refine((rule) => rule.minAge == null || rule.maxAge == null || rule.minAge <= rule.maxAge, {
+    message: "minAge must be less than or equal to maxAge",
+    path: ["maxAge"],
+});
+export const storefrontTransportEligibilityDocumentInputSchema = z.object({
+    type: storefrontTravelDocumentTypeSchema,
+    issuingCountry: countryCodeSchema.optional().nullable(),
+    expiresOn: z.string().date().optional().nullable(),
+});
+export const storefrontTransportEligibilityTravelerInputSchema = z.object({
+    travelerRef: z.string().trim().min(1),
+    nationalityCountry: countryCodeSchema.optional().nullable(),
+    dateOfBirth: z.string().date().optional().nullable(),
+    documents: z.array(storefrontTransportEligibilityDocumentInputSchema).default([]),
+    hasVisa: z.boolean().default(false),
+    travelingWithGuardian: z.boolean().default(false),
+    hasMinorConsent: z.boolean().default(false),
+});
+export const storefrontTransportEligibilityInputSchema = z.object({
+    travelStartsOn: z.string().date().optional().nullable(),
+    travelEndsOn: z.string().date().optional().nullable(),
+    travelers: z.array(storefrontTransportEligibilityTravelerInputSchema).min(1),
+});
+export const storefrontTransportEligibilityIssueCodeSchema = z.enum([
+    "date_of_birth_required",
+    "document_required",
+    "document_expiry_required",
+    "document_validity",
+    "nationality_required",
+    "visa_required",
+    "minor_consent_required",
+    "travel_dates_required",
+]);
+export const storefrontTransportEligibilityIssueSchema = z.object({
+    code: storefrontTransportEligibilityIssueCodeSchema,
+    severity: storefrontTransportEligibilitySeveritySchema,
+    message: z.string(),
+    travelerRef: z.string(),
+    ruleId: z.string(),
+    destinationCountries: z.array(countryCodeSchema),
+    requiredDocumentType: storefrontRequiredDocumentTypeSchema,
+});
+export const storefrontTransportEligibilityTravelerResultSchema = z.object({
+    travelerRef: z.string(),
+    eligible: z.boolean(),
+    matchedRuleIds: z.array(z.string()),
+    blockingIssues: z.array(storefrontTransportEligibilityIssueSchema),
+    warnings: z.array(storefrontTransportEligibilityIssueSchema),
+});
+export const storefrontTransportEligibilityResultSchema = z.object({
+    departureId: z.string(),
+    productId: z.string().nullable(),
+    travelStartsOn: z.string().nullable(),
+    travelEndsOn: z.string().nullable(),
+    eligible: z.boolean(),
+    blockingIssues: z.array(storefrontTransportEligibilityIssueSchema),
+    warnings: z.array(storefrontTransportEligibilityIssueSchema),
+    travelers: z.array(storefrontTransportEligibilityTravelerResultSchema),
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voyantjs/storefront",
-  "version": "0.44.0",
+  "version": "0.46.0",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {
@@ -19,6 +19,11 @@
       "import": "./dist/service.js",
       "default": "./dist/service.js"
     },
+    "./transport-eligibility": {
+      "types": "./dist/transport-eligibility.d.ts",
+      "import": "./dist/transport-eligibility.js",
+      "default": "./dist/transport-eligibility.js"
+    },
     "./validation": {
       "types": "./dist/validation.d.ts",
       "import": "./dist/validation.js",
@@ -29,18 +34,18 @@
     "drizzle-orm": "^0.45.2",
     "hono": "^4.12.10",
     "zod": "^4.3.6",
-    "@voyantjs/availability": "0.44.0",
-    "@voyantjs/core": "0.44.0",
-    "@voyantjs/extras": "0.44.0",
-    "@voyantjs/hono": "0.44.0",
-    "@voyantjs/pricing": "0.44.0",
-    "@voyantjs/products": "0.44.0",
-    "@voyantjs/sellability": "0.44.0"
+    "@voyantjs/availability": "0.46.0",
+    "@voyantjs/core": "0.46.0",
+    "@voyantjs/extras": "0.46.0",
+    "@voyantjs/hono": "0.46.0",
+    "@voyantjs/pricing": "0.46.0",
+    "@voyantjs/products": "0.46.0",
+    "@voyantjs/sellability": "0.46.0"
   },
   "devDependencies": {
     "typescript": "^6.0.2",
     "vitest": "^4.1.2",
-    "@voyantjs/db": "0.44.0",
+    "@voyantjs/db": "0.46.0",
     "@voyantjs/voyant-typescript-config": "0.1.0"
   },
   "files": [