@voyant-travel/flights-react 0.119.2

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,74 @@
+# @voyant-travel/flights-react
+
+The flights client tier: headless data hooks/clients plus the styled UI
+components and page compositions (formerly `@voyant-travel/flights-ui`).
+
+Headless consumers (storefronts, portals) import from the root, `./hooks`,
+`./client`, or `./query-keys` — these pull no styling peers. Styled surfaces
+live under `./ui`, `./components/*`, `./i18n`, and `./styles.css`, whose
+heavier peers (`@voyant-travel/ui`, `@voyant-travel/relationships-react`, `@voyant-travel/finance-react/checkout-ui`,
+`@tanstack/react-table`) are optional and only needed when you import those
+subpaths.
+
+## Install
+
+```bash
+pnpm add @voyant-travel/flights-react @voyant-travel/flights @voyant-travel/relationships-react @voyant-travel/ui @tanstack/react-query react react-dom
+```
+
+`@voyant-travel/ui` provides the design-system primitives. The root and `./hooks`
+subpaths provide the data-layer hooks. CRM-backed contact and billing pickers
+use `@voyant-travel/relationships-react`.
+
+## Pages
+
+`FlightsPage` renders the search, filter, per-leg round-trip picker, offer
+detail sheet, and booking handoff. The route owns URL validation and navigation:
+
+```tsx
+import { FlightsPage } from "@voyant-travel/flights-react/ui"
+
+<FlightsPage
+  search={search}
+  onSearchChange={(next, options) => updateRouteSearch(next, options)}
+  onBookOffer={({ outboundOfferId, returnOfferId, passengers, cabin }) =>
+    goToBooking({ outboundOfferId, returnOfferId, passengers, cabin })
+  }
+/>
+```
+
+`FlightBookingPage` renders the repricing, ancillaries, seat-map, passenger,
+billing, payment, and confirmation flow around `FlightBookingShell`. The route
+or app supplies booking and navigation callbacks:
+
+```tsx
+import { FlightBookingPage } from "@voyant-travel/flights-react/ui"
+
+<FlightBookingPage
+  outboundOfferId={offerId}
+  returnOfferId={returnOfferId}
+  passengers={{ adults: 1, children: 0, infants: 0 }}
+  paymentCapabilities={{ chargeSavedCard: false, newCard: false }}
+  onBackToSearch={() => navigateToFlights()}
+  onBook={(request) => bookFlight(request)}
+  onBooked={(order) => navigateToBooking(order.orderId)}
+/>
+```
+
+Router behavior, booking submission, payment capabilities, billing-default
+persistence, and contact creation are callbacks or slots so applications keep
+deployment-specific ownership.
+
+## I18n
+
+Components render English by default. To localize them, wrap your UI in
+`FlightsUiMessagesProvider` and import only the locales your app supports.
+
+```tsx
+import { FlightsUiMessagesProvider } from "@voyant-travel/flights-react/ui"
+import { flightsUiEn } from "@voyant-travel/flights-react/i18n/en"
+import { flightsUiRo } from "@voyant-travel/flights-react/i18n/ro"
+```
+
+English-only apps should import only `./i18n/en`. Bilingual apps can import
+`./i18n/en` and `./i18n/ro`.

package/dist/admin/index.d.ts

@@ -0,0 +1,134 @@
+import { type AdminExtension } from "@voyant-travel/admin";
+import type { CabinClass } from "@voyant-travel/flights/contract/types";
+import { z } from "zod";
+/**
+ * Semantic destinations the flights admin surfaces navigate to
+ * (packaged-admin RFC §4.7). `booking.detail` (where the wizard lands after
+ * booking) comes from the bookings-ui augmentation bound above; declared here
+ * are the flights-owned keys plus `person.list`, re-declared shape-locked —
+ * also declared by `@voyant-travel/relationships-react/admin`, and interface merging requires
+ * the member shape to stay identical across packages.
+ */
+declare module "@voyant-travel/admin" {
+    interface AdminDestinations {
+        /** The flight search page (the flights area's landing surface). */
+        "flight.search": Record<string, never>;
+        /**
+         * The flight booking wizard for a picked offer (round-trip carries the
+         * return-leg offer id). NOT route-backed: the resolver constructs the
+         * `return`/`pax_*`/`cabin` search params, which is beyond pure path
+         * interpolation — it stays hand-written in the host map.
+         */
+        "flightBooking.start": {
+            offerId: string;
+            returnOfferId?: string;
+            adults: number;
+            children: number;
+            infants: number;
+            cabin: CabinClass;
+        };
+        /** The CRM people list page (the wizard's "add passenger contact" jump). */
+        "person.list": Record<string, never>;
+    }
+}
+/**
+ * Search contract for the flight search page. Everything the page renders is
+ * derived from this — the form values, the active filters, the page cursor,
+ * the current leg being picked, and (when round-trip) the already-picked
+ * outbound — so URLs are shareable, the back button works, and reload
+ * preserves state.
+ *
+ * The per-leg pick model: round-trip searches show outbound results first;
+ * once the user picks an outbound (`outboundOfferId` set, `leg` flips to
+ * "return"), the page shows return results with the picked outbound pinned
+ * at the top.
+ */
+export declare const flightsIndexSearchSchema: z.ZodObject<{
+    tripType: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+        round_trip: "round_trip";
+        one_way: "one_way";
+    }>>>;
+    from: z.ZodOptional<z.ZodString>;
+    to: z.ZodOptional<z.ZodString>;
+    depart: z.ZodOptional<z.ZodString>;
+    ret: z.ZodOptional<z.ZodString>;
+    leg: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+        outbound: "outbound";
+        return: "return";
+    }>>>;
+    outboundOfferId: z.ZodOptional<z.ZodString>;
+    returnOfferId: z.ZodOptional<z.ZodString>;
+    pax_a: z.ZodOptional<z.ZodDefault<z.ZodCoercedNumber<unknown>>>;
+    pax_c: z.ZodOptional<z.ZodDefault<z.ZodCoercedNumber<unknown>>>;
+    pax_i: z.ZodOptional<z.ZodDefault<z.ZodCoercedNumber<unknown>>>;
+    cabin: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+        economy: "economy";
+        premium_economy: "premium_economy";
+        business: "business";
+        first: "first";
+    }>>>;
+    carriers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    maxStops: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    maxPrice: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    page: z.ZodOptional<z.ZodDefault<z.ZodCoercedNumber<unknown>>>;
+}, z.core.$strip>;
+export type FlightsIndexSearchParams = z.infer<typeof flightsIndexSearchSchema>;
+/**
+ * Search contract for the booking wizard route. Pax counts + cabin live in
+ * the URL so the page survives a refresh. The route's `$offerId` param is the
+ * outbound offer id; the optional `return` search param carries the
+ * return-leg offer id when round-trip. Both offers are read from the
+ * TanStack Query cache populated by the search page; if the cache is cold
+ * the page surfaces an "offer expired" prompt with a back-to-search CTA.
+ */
+export declare const flightsBookSearchSchema: z.ZodObject<{
+    return: z.ZodOptional<z.ZodString>;
+    pax_a: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    pax_c: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    pax_i: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    cabin: z.ZodDefault<z.ZodEnum<{
+        economy: "economy";
+        premium_economy: "premium_economy";
+        business: "business";
+        first: "first";
+    }>>;
+}, z.core.$strip>;
+export type FlightsBookSearchParams = z.infer<typeof flightsBookSearchSchema>;
+export interface CreateFlightsAdminExtensionOptions {
+    /** Mount path of the flights pages inside the admin workspace. Default `/flights`. */
+    basePath?: string;
+    /** Localized page titles. Defaults are the English operator nav labels. */
+    labels?: {
+        flights?: string;
+    };
+}
+/**
+ * The flights admin contribution (packaged-admin RFC Phase 3,
+ * `@voyant-travel/<domain>-ui/admin` convention).
+ *
+ * NAVIGATION: deliberately none. The Flights nav item is part of the BASE
+ * operator navigation — see `createOperatorAdminNavigation` in
+ * `@voyant-travel/admin` — so contributing a nav entry here would duplicate it.
+ * If the base nav ever drops the flights item, this extension is where the
+ * entry moves.
+ *
+ * ROUTES: full implementations (packaged-admin RFC §4.8 endgame) — the
+ * package-owned search contracts ({@link flightsIndexSearchSchema} for the
+ * search page, {@link flightsBookSearchSchema} for the wizard) and lazy
+ * `page` modules; no loaders, because both pages fetch client-side (search
+ * results are interactive POSTs, and the wizard reads its offers from the
+ * query cache the search page populated). The wizard route is a SIBLING of
+ * the search route, not a child: in the operator's old file-based tree it
+ * was `flights_.book.$offerId` (the `_` escape opting out of the `/flights`
+ * section chrome), and the code-assembled tree reproduces that exactly
+ * because every contribution mounts flat under the workspace layout.
+ *
+ * `component:` stays unattached; each contribution carries a lazy `page`
+ * loader instead, so the pages land in their own chunks and the wrappers
+ * read route state off `AdminRoutePageProps`. Cross-route links resolve
+ * through the semantic destinations declared above.
+ *
+ * WIDGETS: none today. No cross-domain flights card is slot-mounted.
+ */
+export declare function createFlightsAdminExtension(options?: CreateFlightsAdminExtensionOptions): AdminExtension;
+//# sourceMappingURL=index.d.ts.map

package/dist/admin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/admin/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAwB,MAAM,sBAAsB,CAAA;AAOhF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uCAAuC,CAAA;AACvE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;;;;GAOG;AACH,OAAO,QAAQ,sBAAsB,CAAC;IACpC,UAAU,iBAAiB;QACzB,mEAAmE;QACnE,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;QACtC;;;;;WAKG;QACH,qBAAqB,EAAE;YACrB,OAAO,EAAE,MAAM,CAAA;YACf,aAAa,CAAC,EAAE,MAAM,CAAA;YACtB,MAAM,EAAE,MAAM,CAAA;YACd,QAAQ,EAAE,MAAM,CAAA;YAChB,OAAO,EAAE,MAAM,CAAA;YACf,KAAK,EAAE,UAAU,CAAA;SAClB,CAAA;QACD,4EAA4E;QAC5E,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;KACrC;CACF;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiCjC,CAAA;AAEJ,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAE/E;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;iBAOlC,CAAA;AAEF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAE7E,MAAM,WAAW,kCAAkC;IACjD,sFAAsF;IACtF,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,2EAA2E;IAC3E,MAAM,CAAC,EAAE;QACP,OAAO,CAAC,EAAE,MAAM,CAAA;KACjB,CAAA;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,GAAE,kCAAuC,GAC/C,cAAc,CA8BhB"}

package/dist/admin/index.js

@@ -0,0 +1,122 @@
+import { defineAdminExtension } from "@voyant-travel/admin";
+import { z } from "zod";
+/**
+ * Search contract for the flight search page. Everything the page renders is
+ * derived from this — the form values, the active filters, the page cursor,
+ * the current leg being picked, and (when round-trip) the already-picked
+ * outbound — so URLs are shareable, the back button works, and reload
+ * preserves state.
+ *
+ * The per-leg pick model: round-trip searches show outbound results first;
+ * once the user picks an outbound (`outboundOfferId` set, `leg` flips to
+ * "return"), the page shows return results with the picked outbound pinned
+ * at the top.
+ */
+export const flightsIndexSearchSchema = z
+    .object({
+    tripType: z.enum(["round_trip", "one_way"]).default("round_trip"),
+    from: z.string().optional(),
+    to: z.string().optional(),
+    depart: z.string().optional(),
+    ret: z.string().optional(),
+    leg: z.enum(["outbound", "return"]).default("outbound"),
+    /** Set once the outbound is picked; drives the return-leg search. */
+    outboundOfferId: z.string().optional(),
+    /**
+     * Set once the return is picked. Both ids set = "ready to book" state —
+     * the page shows a trip summary with a Continue CTA instead of the
+     * search results.
+     */
+    returnOfferId: z.string().optional(),
+    pax_a: z.coerce.number().int().min(1).default(1),
+    pax_c: z.coerce.number().int().min(0).default(0),
+    pax_i: z.coerce.number().int().min(0).default(0),
+    cabin: z.enum(["economy", "premium_economy", "business", "first"]).default("economy"),
+    carriers: z.array(z.string()).optional(),
+    maxStops: z.coerce.number().int().min(0).optional(),
+    maxPrice: z.coerce.number().min(0).optional(),
+    page: z.coerce.number().int().min(1).default(1),
+})
+    .partial({
+    tripType: true,
+    pax_a: true,
+    pax_c: true,
+    pax_i: true,
+    cabin: true,
+    page: true,
+    leg: true,
+});
+/**
+ * Search contract for the booking wizard route. Pax counts + cabin live in
+ * the URL so the page survives a refresh. The route's `$offerId` param is the
+ * outbound offer id; the optional `return` search param carries the
+ * return-leg offer id when round-trip. Both offers are read from the
+ * TanStack Query cache populated by the search page; if the cache is cold
+ * the page surfaces an "offer expired" prompt with a back-to-search CTA.
+ */
+export const flightsBookSearchSchema = z.object({
+    /** Return-leg offer id — present only when the trip is round-trip. */
+    return: z.string().optional(),
+    pax_a: z.coerce.number().int().min(1).default(1),
+    pax_c: z.coerce.number().int().min(0).default(0),
+    pax_i: z.coerce.number().int().min(0).default(0),
+    cabin: z.enum(["economy", "premium_economy", "business", "first"]).default("economy"),
+});
+/**
+ * The flights admin contribution (packaged-admin RFC Phase 3,
+ * `@voyant-travel/<domain>-ui/admin` convention).
+ *
+ * NAVIGATION: deliberately none. The Flights nav item is part of the BASE
+ * operator navigation — see `createOperatorAdminNavigation` in
+ * `@voyant-travel/admin` — so contributing a nav entry here would duplicate it.
+ * If the base nav ever drops the flights item, this extension is where the
+ * entry moves.
+ *
+ * ROUTES: full implementations (packaged-admin RFC §4.8 endgame) — the
+ * package-owned search contracts ({@link flightsIndexSearchSchema} for the
+ * search page, {@link flightsBookSearchSchema} for the wizard) and lazy
+ * `page` modules; no loaders, because both pages fetch client-side (search
+ * results are interactive POSTs, and the wizard reads its offers from the
+ * query cache the search page populated). The wizard route is a SIBLING of
+ * the search route, not a child: in the operator's old file-based tree it
+ * was `flights_.book.$offerId` (the `_` escape opting out of the `/flights`
+ * section chrome), and the code-assembled tree reproduces that exactly
+ * because every contribution mounts flat under the workspace layout.
+ *
+ * `component:` stays unattached; each contribution carries a lazy `page`
+ * loader instead, so the pages land in their own chunks and the wrappers
+ * read route state off `AdminRoutePageProps`. Cross-route links resolve
+ * through the semantic destinations declared above.
+ *
+ * WIDGETS: none today. No cross-domain flights card is slot-mounted.
+ */
+export function createFlightsAdminExtension(options = {}) {
+    const { basePath = "/flights", labels = {} } = options;
+    const { flights = "Flights" } = labels;
+    return defineAdminExtension({
+        id: "flights",
+        routes: [
+            {
+                id: "flights-index",
+                path: basePath,
+                title: flights,
+                // Route-backed destination (RFC §4.7 endgame): the key resolves by
+                // pure path interpolation of this route, so the host's resolver is
+                // generated (`voyant admin generate --destinations`).
+                // `flightBooking.start` is deliberately NOT bound: its resolver
+                // constructs search params, which is beyond path interpolation — it
+                // stays hand-written.
+                destination: "flight.search",
+                validateSearch: (search) => flightsIndexSearchSchema.parse(search),
+                page: () => import("./pages/flights-index-page.js"),
+            },
+            {
+                id: "flights-book",
+                path: `${basePath}/book/$offerId`,
+                title: flights,
+                validateSearch: (search) => flightsBookSearchSchema.parse(search),
+                page: () => import("./pages/flight-book-page.js"),
+            },
+        ],
+    });
+}

package/dist/admin/pages/flight-book-page.d.ts

@@ -0,0 +1,12 @@
+import { type AdminRoutePageProps } from "@voyant-travel/admin";
+/**
+ * Packaged route page for the flight booking wizard: binds the matched
+ * route's `$offerId` param (the outbound offer) and the validated
+ * pax/cabin/`return` search params onto {@link FlightBookingPage}, books
+ * through the package's own mutation hook, and resolves every cross-route
+ * link through semantic destinations — back to `flight.search`, the
+ * passenger-contact jump to `person.list` (new tab), and the post-booking
+ * landing on `booking.detail` (a flight order confirms into a booking).
+ */
+export default function FlightBookRoutePage({ params, search }: AdminRoutePageProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=flight-book-page.d.ts.map

package/dist/admin/pages/flight-book-page.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flight-book-page.d.ts","sourceRoot":"","sources":["../../../src/admin/pages/flight-book-page.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,mBAAmB,EAAkC,MAAM,sBAAsB,CAAA;AAoB/F;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,UAAU,mBAAmB,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,mBAAmB,2CAyBlF"}

package/dist/admin/pages/flight-book-page.js

@@ -0,0 +1,40 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useAdminHref, useAdminNavigate } from "@voyant-travel/admin";
+import { FlightBookingPage } from "../../components/flight-booking-page.js";
+import { useFlightBook } from "../../hooks/use-flight-book.js";
+/** Card charging is not wired for the demo connector — collect details only. */
+const paymentCapabilities = { chargeSavedCard: false, newCard: false };
+/**
+ * Open a resolved destination href in a new tab (keeps the wizard in place).
+ * No-op during SSR and for unresolvable destinations (`"#"` is the
+ * `useAdminHref` fallback — opening it would just clone the current page).
+ */
+function openHrefInNewTab(href) {
+    if (typeof window === "undefined" || href === "#")
+        return;
+    window.open(href, "_blank", "noopener,noreferrer");
+}
+/**
+ * Packaged route page for the flight booking wizard: binds the matched
+ * route's `$offerId` param (the outbound offer) and the validated
+ * pax/cabin/`return` search params onto {@link FlightBookingPage}, books
+ * through the package's own mutation hook, and resolves every cross-route
+ * link through semantic destinations — back to `flight.search`, the
+ * passenger-contact jump to `person.list` (new tab), and the post-booking
+ * landing on `booking.detail` (a flight order confirms into a booking).
+ */
+export default function FlightBookRoutePage({ params, search }) {
+    const navigateTo = useAdminNavigate();
+    const resolveHref = useAdminHref();
+    const bookMutation = useFlightBook();
+    const bookSearch = search;
+    return (_jsx(FlightBookingPage, { outboundOfferId: params.offerId ?? "", returnOfferId: bookSearch.return, passengers: {
+            adults: bookSearch.pax_a ?? 1,
+            children: bookSearch.pax_c ?? 0,
+            infants: bookSearch.pax_i ?? 0,
+        }, paymentCapabilities: paymentCapabilities, onBackToSearch: () => navigateTo("flight.search", {}), onAddPassengerContact: () => openHrefInNewTab(resolveHref("person.list", {})), onBook: async (request) => {
+            const result = await bookMutation.mutateAsync(request);
+            return result.order;
+        }, onBooked: (order) => navigateTo("booking.detail", { bookingId: order.orderId }) }));
+}

package/dist/admin/pages/flights-index-page.d.ts

@@ -0,0 +1,14 @@
+import { type AdminRoutePageProps } from "@voyant-travel/admin";
+/**
+ * Packaged route page for the flight search surface. The contribution's
+ * `validateSearch` ({@link flightsIndexSearchSchema}) already validated
+ * `search`, so the cast onto the page's search contract is sound.
+ *
+ * Search updates default to PUSH (not replace): each leg pick / filter
+ * change is a history entry, which is what makes the back button walk the
+ * outbound → return → ready flow. Booking continues into the wizard through
+ * the `flightBooking.start` destination (host-resolved — its href carries
+ * the pax/cabin search params).
+ */
+export default function FlightsIndexPage({ search, updateSearch }: AdminRoutePageProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=flights-index-page.d.ts.map

package/dist/admin/pages/flights-index-page.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flights-index-page.d.ts","sourceRoot":"","sources":["../../../src/admin/pages/flights-index-page.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,mBAAmB,EAAoB,MAAM,sBAAsB,CAAA;AAKjF;;;;;;;;;;GAUG;AACH,MAAM,CAAC,OAAO,UAAU,gBAAgB,CAAC,EAAE,MAAM,EAAE,YAAY,EAAE,EAAE,mBAAmB,2CAuBrF"}

package/dist/admin/pages/flights-index-page.js

@@ -0,0 +1,28 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useAdminNavigate } from "@voyant-travel/admin";
+import { FlightsPage } from "../../components/flights-page.js";
+/**
+ * Packaged route page for the flight search surface. The contribution's
+ * `validateSearch` ({@link flightsIndexSearchSchema}) already validated
+ * `search`, so the cast onto the page's search contract is sound.
+ *
+ * Search updates default to PUSH (not replace): each leg pick / filter
+ * change is a history entry, which is what makes the back button walk the
+ * outbound → return → ready flow. Booking continues into the wizard through
+ * the `flightBooking.start` destination (host-resolved — its href carries
+ * the pax/cabin search params).
+ */
+export default function FlightsIndexPage({ search, updateSearch }) {
+    const navigateTo = useAdminNavigate();
+    return (_jsx(FlightsPage, { search: search, onSearchChange: (next, options) => updateSearch(() => next, {
+            replace: options?.replace ?? false,
+        }), onBookOffer: ({ outboundOfferId, returnOfferId, passengers, cabin }) => navigateTo("flightBooking.start", {
+            offerId: outboundOfferId,
+            ...(returnOfferId ? { returnOfferId } : {}),
+            adults: passengers.adults,
+            children: passengers.children ?? 0,
+            infants: passengers.infants ?? 0,
+            cabin,
+        }) }));
+}

package/dist/client.d.ts

@@ -0,0 +1,16 @@
+import type { z } from "zod";
+export type VoyantFetcher = (url: string, init?: RequestInit) => Promise<Response>;
+export declare const defaultFetcher: VoyantFetcher;
+export declare class VoyantApiError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(message: string, status: number, body: unknown);
+}
+export interface FetchWithValidationOptions {
+    baseUrl: string;
+    fetcher: VoyantFetcher;
+}
+export declare function fetchWithValidation<TOut>(path: string, schema: z.ZodType<TOut>, options: FetchWithValidationOptions, init?: RequestInit): Promise<TOut>;
+export type QueryParamValue = string | number | boolean | null | undefined | Array<string | number | boolean>;
+export declare function withQueryParams(path: string, params: Record<string, QueryParamValue>): string;
+//# sourceMappingURL=client.d.ts.map