@voyant-travel/storefront 0.120.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for describing the origin of the Work and
+      reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may accept and charge a
+      fee for, the acceptance of support, warranty, indemnity, or
+      other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 PixelMakers Studio SRL
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,231 @@
+# @voyant-travel/storefront
+
+Public storefront routes and service helpers for checkout-adjacent product, departure,
+offer, and eligibility flows.
+
+## Composite Price Preview
+
+`POST /departures/:departureId/price` preserves the original quote fields
+(`basePrice`, `taxAmount`, `total`, `notes`, and `lineItems`) and now also
+returns the context needed to render a checkout price card in one request:
+
+- `allocation` describes the resolved public departure slot, capacity state,
+  requested traveler mix, requested units, and selected rooms.
+- `units` and `rooms` expose customer-facing pricing rows for per-person,
+  per-unit, or room-based products.
+- `extras` lists active product extensions with selection/applicability,
+  quantity, unit price, and price impact.
+- `offers` lists applicable public offers, selected/applied discounts,
+  requested manual offer/code results, and conflict policy.
+- `totals` carries base, extras, subtotal, discount, tax, final total,
+  per-person, and per-booking amounts in the selected currency.
+
+Request bodies remain compatible with simple price preview calls:
+
+```json
+{
+  "pax": { "adults": 2, "children": 0, "infants": 0 },
+  "rooms": [{ "unitId": "ount_room", "occupancy": 2, "quantity": 1 }],
+  "extras": [{ "extraId": "pext_transfer", "quantity": 1 }],
+  "offers": [{ "slug": "early-booking" }],
+  "offerCode": "SPRING25",
+  "locale": "en",
+  "market": "default"
+}
+```
+
+Offer resolution is optional and host-owned. Wire the storefront module with
+`offers` or `resolveOffers` resolvers to populate offer applicability and manual
+offer/code impacts. Without resolvers, the route still returns allocation,
+units, rooms, extras, and final totals with an empty `offers` block.
+
+## Public Intake
+
+Storefront can accept public CRM intake at the public root:
+
+- `POST /leads`
+- `POST /newsletter/subscribe`
+
+When mounted through `createStorefrontHonoModule`, these become
+`/v1/public/leads` and `/v1/public/newsletter/subscribe`.
+
+Both routes create a CRM person and a CRM customer signal. Lead intake accepts
+the CRM signal `kind`, `source`, product/option references, bounded payload
+metadata, and consent metadata. Newsletter intake records a `notify` signal and
+uses `sourceSubmissionId` for idempotency; when omitted, the email address is
+used to derive a stable newsletter submission key.
+
+```ts
+import { createStorefrontHonoModule } from "@voyant-travel/storefront"
+
+createStorefrontHonoModule({
+  intake: {
+    guard({ body, context }) {
+      // Install host-owned rate-limit, captcha, signature, or abuse checks.
+      if (!isCaptchaValid(body, context)) {
+        return { allowed: false, status: 429, error: "Captcha required" }
+      }
+    },
+    async requestNewsletterDoubleOptIn({ email, signalId }) {
+      await sendDoubleOptInEmail(email, { signalId })
+    },
+  },
+})
+```
+
+Accepted intake emits `customer.signal.created` on the app event bus with
+`metadata.category: "domain"` and an `intake` payload describing whether the
+signal came from `lead` or `newsletter` intake. Notification adapters can
+subscribe to that event to send CRM email, Slack, or other operator alerts.
+
+## Verification
+
+Storefront owns public email and SMS verification challenges for customer-facing
+checkout and account flows.
+
+```ts
+import { createStorefrontVerificationHonoModule } from "@voyant-travel/storefront/verification"
+
+const storefrontVerification = createStorefrontVerificationHonoModule({
+  resolveProviders: (bindings) => [
+    // return notification-compatible providers for email and/or sms
+  ],
+  email: {
+    subject: "Your verification code",
+  },
+})
+```
+
+Mount the returned module in the same app that exposes the public route:
+
+```ts
+createApp({
+  publicPaths: ["/v1/public/storefront-verification"],
+  modules: [storefrontVerification],
+})
+```
+
+The route module serves:
+
+- `POST /v1/public/storefront-verification/email/start`
+- `POST /v1/public/storefront-verification/email/confirm`
+- `POST /v1/public/storefront-verification/sms/start`
+- `POST /v1/public/storefront-verification/sms/confirm`
+
+The verification schema lives at
+`@voyant-travel/storefront/verification/schema` and stores challenge rows in
+`storefront_verification_challenges`. Apps that maintain an explicit Drizzle
+schema array must include:
+
+```ts
+export default defineConfig({
+  schema: [
+    "../../packages/db/src/schema/index.ts",
+    "../../packages/storefront/src/verification/schema.ts",
+  ],
+})
+```
+
+For package-based tooling, `@voyant-travel/storefront` declares its schema as
+`./verification/schema` with `@voyant-travel/db` as the required base schema.
+
+## Guest Booking Lookup
+
+Use the bookings public guest lookup endpoint before rendering booking overview
+or payment pages for guests:
+
+- `POST /v1/public/bookings/guest-lookup` with `bookingCode` and `email`
+- `GET /v1/public/bookings/overview?bookingCode=...` with the issued guest
+  access cookie or `X-Voyant-Guest-Booking-Access` header
+
+The lookup endpoint verifies the email against booking participants, issues a
+short-lived `voyant_guest_booking` HttpOnly cookie, and returns the same scoped
+token for non-browser clients. When `RATE_LIMIT` KV is bound, lookups are
+throttled per client IP and booking code.
+
+```ts
+import { createGuestBookingGuard } from "@voyant-travel/storefront"
+
+const guestBooking = createGuestBookingGuard()
+
+if (!guestBooking.hasAccess(request)) {
+  return fetch(guestBooking.lookupPath, guestBooking.createLookupRequest({
+    bookingCode: form.bookingCode,
+    email: form.email,
+  }))
+}
+
+return fetch(guestBooking.overviewUrl(form.bookingCode), {
+  headers: { Cookie: request.headers.get("Cookie") ?? "" },
+})
+```
+
+## Transport Eligibility
+
+Storefronts can check whether traveler document facts satisfy departure-level
+transport rules before checkout confirmation.
+
+```ts
+import { createStorefrontPublicRoutes } from "@voyant-travel/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
+`@voyant-travel/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/booking-intents.d.ts

@@ -0,0 +1,42 @@
+import type { EventBus, EventHandler } from "@voyant-travel/core";
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import { type StorefrontRequestContext, type StorefrontServiceOptions } from "./service.js";
+/**
+ * Async booking-session bootstrap over the queued write pipeline (RFC
+ * voyant#1687 Phase 3.2).
+ *
+ * Flow: the public route validates the body, stores a `write_intents`
+ * row, durably emits {@link BOOKING_BOOTSTRAP_INTENT_EVENT} (outbox),
+ * and answers 202 + a status URL. This handler — registered on the
+ * app's event bus by the deployment — executes the SAME bootstrap
+ * service the sync route uses and settles the intent. The outbox owns
+ * delivery: immediate attempt at emit time, retries with backoff on
+ * infra failure, dead-letter backstopped by the stale-intent sweep.
+ *
+ * Outcome semantics: business conclusions (capacity conflict, stale
+ * quote, departure gone) settle the intent as `failed` WITH the
+ * conflict detail and are never retried — retrying "sold out" doesn't
+ * un-sell it. Unexpected errors re-throw so the outbox redelivers
+ * (`settleWriteIntent` only transitions pending rows, so at-least-once
+ * redelivery after a success is a no-op).
+ */
+export declare const BOOKING_BOOTSTRAP_INTENT_KIND = "storefront.booking.bootstrap";
+export declare const BOOKING_BOOTSTRAP_INTENT_EVENT = "storefront.booking.bootstrap.requested";
+export interface BookingBootstrapIntentPayload {
+    input: unknown;
+    userId?: string;
+}
+export interface BookingBootstrapIntentDeps {
+    /** Per-invocation db (the operator passes its capability resolver). */
+    resolveDb: () => PostgresJsDatabase;
+    /**
+     * The APP bus (e.g. `app.eventBus`) so booking events emitted by the
+     * reserve flow (booking.created, availability.slot.changed, …) reach
+     * the same subscribers as a sync bootstrap.
+     */
+    eventBus?: EventBus;
+    env?: StorefrontRequestContext["env"];
+    serviceOptions?: StorefrontServiceOptions;
+}
+export declare function createBookingBootstrapIntentHandler(deps: BookingBootstrapIntentDeps): EventHandler;
+//# sourceMappingURL=booking-intents.d.ts.map

package/dist/booking-intents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"booking-intents.d.ts","sourceRoot":"","sources":["../src/booking-intents.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAEjE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAEjE,OAAO,EAEL,KAAK,wBAAwB,EAC7B,KAAK,wBAAwB,EAC9B,MAAM,cAAc,CAAA;AAGrB;;;;;;;;;;;;;;;;;;GAkBG;AAEH,eAAO,MAAM,6BAA6B,iCAAiC,CAAA;AAC3E,eAAO,MAAM,8BAA8B,2CAA2C,CAAA;AAEtF,MAAM,WAAW,6BAA6B;IAC5C,KAAK,EAAE,OAAO,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAaD,MAAM,WAAW,0BAA0B;IACzC,uEAAuE;IACvE,SAAS,EAAE,MAAM,kBAAkB,CAAA;IACnC;;;;OAIG;IACH,QAAQ,CAAC,EAAE,QAAQ,CAAA;IACnB,GAAG,CAAC,EAAE,wBAAwB,CAAC,KAAK,CAAC,CAAA;IACrC,cAAc,CAAC,EAAE,wBAAwB,CAAA;CAC1C;AAED,wBAAgB,mCAAmC,CACjD,IAAI,EAAE,0BAA0B,GAC/B,YAAY,CAyDd"}

package/dist/booking-intents.js

@@ -0,0 +1,83 @@
+import { getWriteIntent, settleWriteIntent } from "@voyant-travel/db/write-intents";
+import { createStorefrontService, } from "./service.js";
+import { storefrontBookingSessionBootstrapInputSchema } from "./validation.js";
+/**
+ * Async booking-session bootstrap over the queued write pipeline (RFC
+ * voyant#1687 Phase 3.2).
+ *
+ * Flow: the public route validates the body, stores a `write_intents`
+ * row, durably emits {@link BOOKING_BOOTSTRAP_INTENT_EVENT} (outbox),
+ * and answers 202 + a status URL. This handler — registered on the
+ * app's event bus by the deployment — executes the SAME bootstrap
+ * service the sync route uses and settles the intent. The outbox owns
+ * delivery: immediate attempt at emit time, retries with backoff on
+ * infra failure, dead-letter backstopped by the stale-intent sweep.
+ *
+ * Outcome semantics: business conclusions (capacity conflict, stale
+ * quote, departure gone) settle the intent as `failed` WITH the
+ * conflict detail and are never retried — retrying "sold out" doesn't
+ * un-sell it. Unexpected errors re-throw so the outbox redelivers
+ * (`settleWriteIntent` only transitions pending rows, so at-least-once
+ * redelivery after a success is a no-op).
+ */
+export const BOOKING_BOOTSTRAP_INTENT_KIND = "storefront.booking.bootstrap";
+export const BOOKING_BOOTSTRAP_INTENT_EVENT = "storefront.booking.bootstrap.requested";
+/** Final business outcomes → the HTTP status the sync route would return. */
+const FINAL_CONFLICT_STATUS = {
+    departure_not_found: 404,
+    slot_not_found: 404,
+    invalid_slot: 400,
+    insufficient_capacity: 409,
+    slot_unavailable: 409,
+    pricing_unavailable: 409,
+    stale_quote: 409,
+};
+export function createBookingBootstrapIntentHandler(deps) {
+    const storefrontService = createStorefrontService(deps.serviceOptions);
+    return async (envelope) => {
+        const intentId = envelope.data?.intentId;
+        if (!intentId)
+            return;
+        const db = deps.resolveDb();
+        const intent = await getWriteIntent(db, intentId);
+        if (!intent || intent.kind !== BOOKING_BOOTSTRAP_INTENT_KIND || intent.status !== "pending") {
+            return;
+        }
+        const payload = intent.payload;
+        const parsed = storefrontBookingSessionBootstrapInputSchema.safeParse(payload.input);
+        if (!parsed.success) {
+            // Should be unreachable (the route validated before enqueueing) —
+            // settle rather than retry a permanently-invalid payload.
+            await settleWriteIntent(db, intentId, {
+                status: "failed",
+                error: `invalid intent payload: ${parsed.error.message.slice(0, 500)}`,
+            });
+            return;
+        }
+        // Unexpected throws propagate → the outbox retries the delivery.
+        const result = await storefrontService.bootstrapBookingSession({
+            db,
+            eventBus: deps.eventBus,
+            env: deps.env,
+        }, parsed.data, payload.userId);
+        if (result.status === "ok" && "bootstrap" in result) {
+            await settleWriteIntent(db, intentId, {
+                status: "succeeded",
+                result: { bootstrap: result.bootstrap },
+            });
+            return;
+        }
+        const httpStatus = FINAL_CONFLICT_STATUS[result.status] ?? 409;
+        await settleWriteIntent(db, intentId, {
+            status: "failed",
+            error: result.status,
+            result: {
+                conflict: result.status,
+                httpStatus,
+                ...(result.status === "stale_quote" && "repricing" in result
+                    ? { repricing: result.repricing }
+                    : {}),
+            },
+        });
+    };
+}

package/dist/customer-portal/index.d.ts

@@ -0,0 +1,16 @@
+import type { Module } from "@voyant-travel/core";
+import type { HonoModule } from "@voyant-travel/hono/module";
+import { type PublicCustomerPortalRouteOptions } from "./routes-public.js";
+export type { CustomerPortalRoutes } from "./routes.js";
+export { customerPortalRoutes } from "./routes.js";
+export type { PublicCustomerPortalRoutes } from "./routes-public.js";
+export { createPublicCustomerPortalRoutes, publicCustomerPortalRoutes } from "./routes-public.js";
+export { publicCustomerPortalService } from "./service-public.js";
+export type { BootstrapCustomerPortalInput, BootstrapCustomerPortalResult, CreateCustomerPortalCompanionInput, CreateCustomerPortalProfileDocumentInput, CustomerPortalAddress, CustomerPortalBookingBillingContact, CustomerPortalBookingDetail, CustomerPortalBookingDocument, CustomerPortalBookingFinancialDocument, CustomerPortalBookingFinancials, CustomerPortalBookingPayment, CustomerPortalBookingSummary, CustomerPortalBootstrapCandidate, CustomerPortalCompanion, CustomerPortalContactExistsQuery, CustomerPortalContactExistsResult, CustomerPortalPhoneContactExistsQuery, CustomerPortalPhoneContactExistsResult, CustomerPortalProfile, CustomerPortalProfileDocument, ImportCustomerPortalBookingParticipantsInput, ImportCustomerPortalBookingParticipantsResult, ImportCustomerPortalBookingTravelersInput, ImportCustomerPortalBookingTravelersResult, UpdateCustomerPortalAddressInput, UpdateCustomerPortalCompanionInput, UpdateCustomerPortalProfileDocumentInput, UpdateCustomerPortalProfileInput, } from "./validation-public.js";
+export { bootstrapCustomerPortalResultSchema, bootstrapCustomerPortalSchema, createCustomerPortalCompanionSchema, createCustomerPortalProfileDocumentSchema, customerPortalAddressSchema, customerPortalBookingBillingContactSchema, customerPortalBookingDetailSchema, customerPortalBookingDocumentSchema, customerPortalBookingFinancialDocumentSchema, customerPortalBookingFinancialsSchema, customerPortalBookingPaymentSchema, customerPortalBookingSummarySchema, customerPortalBootstrapCandidateSchema, customerPortalCompanionSchema, customerPortalContactExistsQuerySchema, customerPortalContactExistsResultSchema, customerPortalPhoneContactExistsQuerySchema, customerPortalPhoneContactExistsResultSchema, customerPortalProfileDocumentSchema, customerPortalProfileSchema, importCustomerPortalBookingParticipantsResultSchema, importCustomerPortalBookingParticipantsSchema, importCustomerPortalBookingTravelersResultSchema, importCustomerPortalBookingTravelersSchema, updateCustomerPortalAddressSchema, updateCustomerPortalCompanionSchema, updateCustomerPortalProfileDocumentSchema, updateCustomerPortalProfileSchema, } from "./validation-public.js";
+export declare const customerPortalModule: Module;
+export declare function createCustomerPortalHonoModule(options?: PublicCustomerPortalRouteOptions): HonoModule;
+export declare const customerPortalHonoModule: HonoModule;
+export type { CustomerPortalRouteRuntime, PublicCustomerPortalRouteRuntime, PublicCustomerPortalRuntimeOptions, } from "./route-runtime.js";
+export { buildCustomerPortalRouteRuntime, buildPublicCustomerPortalRouteRuntime, CUSTOMER_PORTAL_ROUTE_RUNTIME_CONTAINER_KEY, } from "./route-runtime.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/customer-portal/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/customer-portal/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AACjD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AAM5D,OAAO,EAEL,KAAK,gCAAgC,EACtC,MAAM,oBAAoB,CAAA;AAE3B,YAAY,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AACvD,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AAClD,YAAY,EAAE,0BAA0B,EAAE,MAAM,oBAAoB,CAAA;AACpE,OAAO,EAAE,gCAAgC,EAAE,0BAA0B,EAAE,MAAM,oBAAoB,CAAA;AACjG,OAAO,EAAE,2BAA2B,EAAE,MAAM,qBAAqB,CAAA;AACjE,YAAY,EACV,4BAA4B,EAC5B,6BAA6B,EAC7B,kCAAkC,EAClC,wCAAwC,EACxC,qBAAqB,EACrB,mCAAmC,EACnC,2BAA2B,EAC3B,6BAA6B,EAC7B,sCAAsC,EACtC,+BAA+B,EAC/B,4BAA4B,EAC5B,4BAA4B,EAC5B,gCAAgC,EAChC,uBAAuB,EACvB,gCAAgC,EAChC,iCAAiC,EACjC,qCAAqC,EACrC,sCAAsC,EACtC,qBAAqB,EACrB,6BAA6B,EAC7B,4CAA4C,EAC5C,6CAA6C,EAC7C,yCAAyC,EACzC,0CAA0C,EAC1C,gCAAgC,EAChC,kCAAkC,EAClC,wCAAwC,EACxC,gCAAgC,GACjC,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EACL,mCAAmC,EACnC,6BAA6B,EAC7B,mCAAmC,EACnC,yCAAyC,EACzC,2BAA2B,EAC3B,yCAAyC,EACzC,iCAAiC,EACjC,mCAAmC,EACnC,4CAA4C,EAC5C,qCAAqC,EACrC,kCAAkC,EAClC,kCAAkC,EAClC,sCAAsC,EACtC,6BAA6B,EAC7B,sCAAsC,EACtC,uCAAuC,EACvC,2CAA2C,EAC3C,4CAA4C,EAC5C,mCAAmC,EACnC,2BAA2B,EAC3B,mDAAmD,EACnD,6CAA6C,EAC7C,gDAAgD,EAChD,0CAA0C,EAC1C,iCAAiC,EACjC,mCAAmC,EACnC,yCAAyC,EACzC,iCAAiC,GAClC,MAAM,wBAAwB,CAAA;AAE/B,eAAO,MAAM,oBAAoB,EAAE,MAElC,CAAA;AAED,wBAAgB,8BAA8B,CAC5C,OAAO,GAAE,gCAAqC,GAC7C,UAAU,CAeZ;AAED,eAAO,MAAM,wBAAwB,EAAE,UAA6C,CAAA;AAEpF,YAAY,EACV,0BAA0B,EAC1B,gCAAgC,EAChC,kCAAkC,GACnC,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EACL,+BAA+B,EAC/B,qCAAqC,EACrC,2CAA2C,GAC5C,MAAM,oBAAoB,CAAA"}

package/dist/customer-portal/index.js

@@ -0,0 +1,23 @@
+import { buildPublicCustomerPortalRouteRuntime, CUSTOMER_PORTAL_ROUTE_RUNTIME_CONTAINER_KEY, } from "./route-runtime.js";
+import { createPublicCustomerPortalRoutes, } from "./routes-public.js";
+export { customerPortalRoutes } from "./routes.js";
+export { createPublicCustomerPortalRoutes, publicCustomerPortalRoutes } from "./routes-public.js";
+export { publicCustomerPortalService } from "./service-public.js";
+export { bootstrapCustomerPortalResultSchema, bootstrapCustomerPortalSchema, createCustomerPortalCompanionSchema, createCustomerPortalProfileDocumentSchema, customerPortalAddressSchema, customerPortalBookingBillingContactSchema, customerPortalBookingDetailSchema, customerPortalBookingDocumentSchema, customerPortalBookingFinancialDocumentSchema, customerPortalBookingFinancialsSchema, customerPortalBookingPaymentSchema, customerPortalBookingSummarySchema, customerPortalBootstrapCandidateSchema, customerPortalCompanionSchema, customerPortalContactExistsQuerySchema, customerPortalContactExistsResultSchema, customerPortalPhoneContactExistsQuerySchema, customerPortalPhoneContactExistsResultSchema, customerPortalProfileDocumentSchema, customerPortalProfileSchema, importCustomerPortalBookingParticipantsResultSchema, importCustomerPortalBookingParticipantsSchema, importCustomerPortalBookingTravelersResultSchema, importCustomerPortalBookingTravelersSchema, updateCustomerPortalAddressSchema, updateCustomerPortalCompanionSchema, updateCustomerPortalProfileDocumentSchema, updateCustomerPortalProfileSchema, } from "./validation-public.js";
+export const customerPortalModule = {
+    name: "customer-portal",
+};
+export function createCustomerPortalHonoModule(options = {}) {
+    const module = {
+        ...customerPortalModule,
+        bootstrap: ({ bindings, container }) => {
+            container.register(CUSTOMER_PORTAL_ROUTE_RUNTIME_CONTAINER_KEY, buildPublicCustomerPortalRouteRuntime(bindings, options));
+        },
+    };
+    return {
+        module,
+        publicRoutes: createPublicCustomerPortalRoutes(options),
+    };
+}
+export const customerPortalHonoModule = createCustomerPortalHonoModule();
+export { buildCustomerPortalRouteRuntime, buildPublicCustomerPortalRouteRuntime, CUSTOMER_PORTAL_ROUTE_RUNTIME_CONTAINER_KEY, } from "./route-runtime.js";

package/dist/customer-portal/route-runtime.d.ts

@@ -0,0 +1,16 @@
+import { type KmsProvider } from "@voyant-travel/utils";
+export interface CustomerPortalRouteRuntime {
+    getOptionalKmsProvider(): KmsProvider | null;
+}
+export interface PublicCustomerPortalRouteRuntime extends CustomerPortalRouteRuntime {
+    resolveDocumentDownloadUrl?: (storageKey: string) => Promise<string | null> | string | null;
+}
+export declare const CUSTOMER_PORTAL_ROUTE_RUNTIME_CONTAINER_KEY = "providers.customerPortal.public.runtime";
+export interface PublicCustomerPortalRuntimeOptions {
+    resolveDocumentDownloadUrl?: (bindings: unknown, storageKey: string) => Promise<string | null> | string | null;
+}
+type RuntimeBindings = Record<string, unknown>;
+export declare function buildPublicCustomerPortalRouteRuntime(bindings: RuntimeBindings, options?: PublicCustomerPortalRuntimeOptions): PublicCustomerPortalRouteRuntime;
+export declare const buildCustomerPortalRouteRuntime: typeof buildPublicCustomerPortalRouteRuntime;
+export {};
+//# sourceMappingURL=route-runtime.d.ts.map

package/dist/customer-portal/route-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-runtime.d.ts","sourceRoot":"","sources":["../../src/customer-portal/route-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4B,KAAK,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAEjF,MAAM,WAAW,0BAA0B;IACzC,sBAAsB,IAAI,WAAW,GAAG,IAAI,CAAA;CAC7C;AAED,MAAM,WAAW,gCAAiC,SAAQ,0BAA0B;IAClF,0BAA0B,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,MAAM,GAAG,IAAI,CAAA;CAC5F;AAED,eAAO,MAAM,2CAA2C,4CAA4C,CAAA;AAEpG,MAAM,WAAW,kCAAkC;IACjD,0BAA0B,CAAC,EAAE,CAC3B,QAAQ,EAAE,OAAO,EACjB,UAAU,EAAE,MAAM,KACf,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,MAAM,GAAG,IAAI,CAAA;CAC5C;AAED,KAAK,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAgB9C,wBAAgB,qCAAqC,CACnD,QAAQ,EAAE,eAAe,EACzB,OAAO,GAAE,kCAAuC,GAC/C,gCAAgC,CAiBlC;AAED,eAAO,MAAM,+BAA+B,8CAAwC,CAAA"}

package/dist/customer-portal/route-runtime.js

@@ -0,0 +1,27 @@
+import { createKmsProviderFromEnv } from "@voyant-travel/utils";
+export const CUSTOMER_PORTAL_ROUTE_RUNTIME_CONTAINER_KEY = "providers.customerPortal.public.runtime";
+function buildRuntimeEnv(bindings) {
+    const processEnv = globalThis.process?.env ?? {};
+    return {
+        ...processEnv,
+        ...(bindings ?? {}),
+    };
+}
+export function buildPublicCustomerPortalRouteRuntime(bindings, options = {}) {
+    const runtimeEnv = buildRuntimeEnv(bindings);
+    const resolveDocumentDownloadUrl = options.resolveDocumentDownloadUrl
+        ? (storageKey) => options.resolveDocumentDownloadUrl?.(bindings, storageKey) ?? null
+        : undefined;
+    return {
+        getOptionalKmsProvider() {
+            try {
+                return createKmsProviderFromEnv(runtimeEnv);
+            }
+            catch {
+                return null;
+            }
+        },
+        resolveDocumentDownloadUrl,
+    };
+}
+export const buildCustomerPortalRouteRuntime = buildPublicCustomerPortalRouteRuntime;