@voyantjs/flights-react 0.21.0

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

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAE5B,MAAM,MAAM,aAAa,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAA;AAElF,eAAO,MAAM,cAAc,EAAE,aACoB,CAAA;AAEjD,qBAAa,cAAe,SAAQ,KAAK;IACvC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;gBAEV,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO;CAM3D;AAaD,MAAM,WAAW,0BAA0B;IACzC,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,aAAa,CAAA;CACvB;AAED,wBAAsB,mBAAmB,CAAC,IAAI,EAC5C,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,EACvB,OAAO,EAAE,0BAA0B,EACnC,IAAI,CAAC,EAAE,WAAW,GACjB,OAAO,CAAC,IAAI,CAAC,CAgCf;AAkBD,MAAM,MAAM,eAAe,GACvB,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,SAAS,GACT,KAAK,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAA;AAEpC,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,GAAG,MAAM,CAY7F"}

package/dist/client.js

@@ -0,0 +1,75 @@
+export const defaultFetcher = (url, init) => fetch(url, { credentials: "include", ...init });
+export class VoyantApiError extends Error {
+    status;
+    body;
+    constructor(message, status, body) {
+        super(message);
+        this.name = "VoyantApiError";
+        this.status = status;
+        this.body = body;
+    }
+}
+function extractErrorMessage(status, statusText, body) {
+    if (typeof body === "object" && body !== null && "error" in body) {
+        const err = body.error;
+        if (typeof err === "string")
+            return err;
+        if (typeof err === "object" && err !== null && "message" in err) {
+            return String(err.message);
+        }
+    }
+    return `Voyant API error: ${status} ${statusText}`;
+}
+export async function fetchWithValidation(path, schema, options, init) {
+    const url = joinUrl(options.baseUrl, path);
+    const headers = new Headers(init?.headers);
+    if (init?.body !== undefined && !headers.has("Content-Type")) {
+        headers.set("Content-Type", "application/json");
+    }
+    const response = await options.fetcher(url, { ...init, headers });
+    if (!response.ok) {
+        const body = await safeJson(response);
+        throw new VoyantApiError(extractErrorMessage(response.status, response.statusText, body), response.status, body);
+    }
+    if (response.status === 204) {
+        return schema.parse(undefined);
+    }
+    const body = await safeJson(response);
+    const parsed = schema.safeParse(body);
+    if (!parsed.success) {
+        throw new VoyantApiError(`Voyant API response failed validation: ${parsed.error.message}`, response.status, body);
+    }
+    return parsed.data;
+}
+async function safeJson(response) {
+    const text = await response.text();
+    if (!text)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function joinUrl(baseUrl, path) {
+    const trimmedBase = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+    const trimmedPath = path.startsWith("/") ? path : `/${path}`;
+    return `${trimmedBase}${trimmedPath}`;
+}
+export function withQueryParams(path, params) {
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value === undefined || value === null)
+            continue;
+        if (Array.isArray(value)) {
+            for (const v of value)
+                search.append(key, String(v));
+        }
+        else {
+            search.set(key, String(value));
+        }
+    }
+    const qs = search.toString();
+    return qs ? `${path}?${qs}` : path;
+}

package/dist/hooks/index.d.ts

@@ -0,0 +1,13 @@
+export { useAircraft } from "./use-aircraft.js";
+export { useAirlines } from "./use-airlines.js";
+export { type UseAirportSearchOptions, useAirportSearch } from "./use-airport-search.js";
+export { type UseAirportsOptions, useAirports } from "./use-airports.js";
+export { type UseFlightAncillariesOptions, useFlightAncillaries, } from "./use-flight-ancillaries.js";
+export { useFlightBook } from "./use-flight-book.js";
+export { type PriceOfferInput, useFlightOfferPrice } from "./use-flight-offer.js";
+export { type CancelOrderInput, type UseFlightOrderOptions, useFlightOrder, useFlightOrderCancel, } from "./use-flight-order.js";
+export { type UseFlightOrdersOptions, useFlightOrders } from "./use-flight-orders.js";
+export { type UseFlightSearchOptions, useFlightSearch } from "./use-flight-search.js";
+export { type UseFlightSeatMapOptions, useFlightSeatMap, } from "./use-flight-seat-map.js";
+export { type UseSavedPaymentMethodsOptions, useSavedPaymentMethods, } from "./use-saved-payment-methods.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAC/C,OAAO,EAAE,KAAK,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA;AACxF,OAAO,EAAE,KAAK,kBAAkB,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AACxE,OAAO,EACL,KAAK,2BAA2B,EAChC,oBAAoB,GACrB,MAAM,6BAA6B,CAAA;AACpC,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACpD,OAAO,EAAE,KAAK,eAAe,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AACjF,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,qBAAqB,EAC1B,cAAc,EACd,oBAAoB,GACrB,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EAAE,KAAK,sBAAsB,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AACrF,OAAO,EAAE,KAAK,sBAAsB,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AACrF,OAAO,EACL,KAAK,uBAAuB,EAC5B,gBAAgB,GACjB,MAAM,0BAA0B,CAAA;AACjC,OAAO,EACL,KAAK,6BAA6B,EAClC,sBAAsB,GACvB,MAAM,gCAAgC,CAAA"}

package/dist/hooks/index.js

@@ -0,0 +1,12 @@
+export { useAircraft } from "./use-aircraft.js";
+export { useAirlines } from "./use-airlines.js";
+export { useAirportSearch } from "./use-airport-search.js";
+export { useAirports } from "./use-airports.js";
+export { useFlightAncillaries, } from "./use-flight-ancillaries.js";
+export { useFlightBook } from "./use-flight-book.js";
+export { useFlightOfferPrice } from "./use-flight-offer.js";
+export { useFlightOrder, useFlightOrderCancel, } from "./use-flight-order.js";
+export { useFlightOrders } from "./use-flight-orders.js";
+export { useFlightSearch } from "./use-flight-search.js";
+export { useFlightSeatMap, } from "./use-flight-seat-map.js";
+export { useSavedPaymentMethods, } from "./use-saved-payment-methods.js";

package/dist/hooks/use-aircraft.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Fetches the aircraft reference list. Mostly used to hydrate the IATA
+ * aircraft type code on segments (e.g. `738` → "Boeing 737-800") in the
+ * detail sheet.
+ */
+export declare function useAircraft(options?: {
+    enabled?: boolean;
+}): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        iataCode: string;
+        name: string;
+        icaoCode?: string | null | undefined;
+        manufacturer?: string | null | undefined;
+        typicalSeats?: number | null | undefined;
+    }[];
+}, Error>;
+//# sourceMappingURL=use-aircraft.d.ts.map

package/dist/hooks/use-aircraft.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-aircraft.d.ts","sourceRoot":"","sources":["../../src/hooks/use-aircraft.ts"],"names":[],"mappings":"AAOA;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAO;;;;;;;;UAQ9D"}

package/dist/hooks/use-aircraft.js

@@ -0,0 +1,18 @@
+"use client";
+import { useQuery } from "@tanstack/react-query";
+import { useVoyantFlightsContext } from "../provider.js";
+import { getAircraftQueryOptions } from "../query-options.js";
+/**
+ * Fetches the aircraft reference list. Mostly used to hydrate the IATA
+ * aircraft type code on segments (e.g. `738` → "Boeing 737-800") in the
+ * detail sheet.
+ */
+export function useAircraft(options = {}) {
+    const client = useVoyantFlightsContext();
+    const { enabled = true } = options;
+    return useQuery({
+        ...getAircraftQueryOptions(client),
+        enabled,
+        staleTime: 24 * 60 * 60 * 1000,
+    });
+}

package/dist/hooks/use-airlines.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Fetches the full airline reference list. Long-stale because airlines
+ * rarely change once seeded — the operator's reference table is a
+ * deliberate snapshot, not a live feed.
+ */
+export declare function useAirlines(options?: {
+    enabled?: boolean;
+}): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        iataCode: string;
+        name: string;
+        icaoCode?: string | null | undefined;
+        country?: string | null | undefined;
+        logoUrl?: string | null | undefined;
+        alliance?: string | null | undefined;
+    }[];
+}, Error>;
+//# sourceMappingURL=use-airlines.d.ts.map

package/dist/hooks/use-airlines.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-airlines.d.ts","sourceRoot":"","sources":["../../src/hooks/use-airlines.ts"],"names":[],"mappings":"AAOA;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAO;;;;;;;;;UAQ9D"}

package/dist/hooks/use-airlines.js

@@ -0,0 +1,18 @@
+"use client";
+import { useQuery } from "@tanstack/react-query";
+import { useVoyantFlightsContext } from "../provider.js";
+import { getAirlinesQueryOptions } from "../query-options.js";
+/**
+ * Fetches the full airline reference list. Long-stale because airlines
+ * rarely change once seeded — the operator's reference table is a
+ * deliberate snapshot, not a live feed.
+ */
+export function useAirlines(options = {}) {
+    const client = useVoyantFlightsContext();
+    const { enabled = true } = options;
+    return useQuery({
+        ...getAirlinesQueryOptions(client),
+        enabled,
+        staleTime: 24 * 60 * 60 * 1000,
+    });
+}

package/dist/hooks/use-airport-search.d.ts

@@ -0,0 +1,28 @@
+export interface UseAirportSearchOptions {
+    /** Debounce on keystrokes, milliseconds. Default 200. */
+    debounceMs?: number;
+    /** Maximum results returned by the server. Default 25. */
+    limit?: number;
+    /** Disable network entirely (e.g. while combobox is closed). */
+    enabled?: boolean;
+}
+/**
+ * Debounced airport-search hook for combobox typeaheads. Tracks the
+ * raw input separately from the debounced server query so users can
+ * type freely without N round-trips. The query short-circuits when
+ * `enabled` is false or the debounced value is empty AND limit isn't
+ * set (callers that want a default open list should pass `limit`).
+ */
+export declare function useAirportSearch(input: string, options?: UseAirportSearchOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        iataCode: string;
+        name: string;
+        city: string;
+        country: string;
+        icaoCode?: string | null | undefined;
+        timezone?: string | null | undefined;
+        latitude?: number | null | undefined;
+        longitude?: number | null | undefined;
+    }[];
+}, Error>;
+//# sourceMappingURL=use-airport-search.d.ts.map

package/dist/hooks/use-airport-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-airport-search.d.ts","sourceRoot":"","sources":["../../src/hooks/use-airport-search.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,uBAAuB;IACtC,yDAAyD;IACzD,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,0DAA0D;IAC1D,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,gEAAgE;IAChE,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,uBAA4B;;;;;;;;;;;UAcpF"}

package/dist/hooks/use-airport-search.js

@@ -0,0 +1,23 @@
+"use client";
+import { useEffect, useState } from "react";
+import { useAirports } from "./use-airports.js";
+/**
+ * Debounced airport-search hook for combobox typeaheads. Tracks the
+ * raw input separately from the debounced server query so users can
+ * type freely without N round-trips. The query short-circuits when
+ * `enabled` is false or the debounced value is empty AND limit isn't
+ * set (callers that want a default open list should pass `limit`).
+ */
+export function useAirportSearch(input, options = {}) {
+    const { debounceMs = 200, limit = 25, enabled = true } = options;
+    const [debounced, setDebounced] = useState(input);
+    useEffect(() => {
+        const t = setTimeout(() => setDebounced(input), debounceMs);
+        return () => clearTimeout(t);
+    }, [input, debounceMs]);
+    return useAirports({
+        q: debounced.trim() || undefined,
+        limit,
+        enabled,
+    });
+}

package/dist/hooks/use-airports.d.ts

@@ -0,0 +1,21 @@
+import type { AirportSearchFilters } from "../query-keys.js";
+export interface UseAirportsOptions extends AirportSearchFilters {
+    enabled?: boolean;
+}
+/**
+ * Fetch the airport reference list. Use the `q` filter for substring
+ * search (city / IATA / name). Cached per-filter.
+ */
+export declare function useAirports(options?: UseAirportsOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        iataCode: string;
+        name: string;
+        city: string;
+        country: string;
+        icaoCode?: string | null | undefined;
+        timezone?: string | null | undefined;
+        latitude?: number | null | undefined;
+        longitude?: number | null | undefined;
+    }[];
+}, Error>;
+//# sourceMappingURL=use-airports.d.ts.map

package/dist/hooks/use-airports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-airports.d.ts","sourceRoot":"","sources":["../../src/hooks/use-airports.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAG5D,MAAM,WAAW,kBAAmB,SAAQ,oBAAoB;IAC9D,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,OAAO,GAAE,kBAAuB;;;;;;;;;;;UAQ3D"}

package/dist/hooks/use-airports.js

@@ -0,0 +1,17 @@
+"use client";
+import { useQuery } from "@tanstack/react-query";
+import { useVoyantFlightsContext } from "../provider.js";
+import { getAirportsQueryOptions } from "../query-options.js";
+/**
+ * Fetch the airport reference list. Use the `q` filter for substring
+ * search (city / IATA / name). Cached per-filter.
+ */
+export function useAirports(options = {}) {
+    const client = useVoyantFlightsContext();
+    const { enabled = true, ...filters } = options;
+    return useQuery({
+        ...getAirportsQueryOptions(client, filters),
+        enabled,
+        staleTime: 24 * 60 * 60 * 1000,
+    });
+}

package/dist/hooks/use-flight-ancillaries.d.ts

@@ -0,0 +1,63 @@
+import type { FlightOffer } from "@voyantjs/flights/contract/types";
+export interface UseFlightAncillariesOptions {
+    /** Disable the query — useful before the offer is re-priced. */
+    enabled?: boolean;
+    /** TanStack Query stale time, milliseconds. Default 5 minutes. */
+    staleTime?: number;
+}
+/**
+ * POST `/v1/admin/flights/ancillaries` — fetches the bag/assistance/extras
+ * catalog for an offer. Catalog is offer-scoped; in the per-leg booking
+ * flow callers fire one query per leg and merge the picks at book time
+ * via `FlightBookRequest.ancillaries`.
+ *
+ * Default `enabled = false` so callers gate the query on having a valid
+ * (re-priced) offer in hand. When the connector doesn't declare
+ * `flight/ancillaries`, the API returns 501 — propagated as a query error.
+ */
+export declare function useFlightAncillaries(input: {
+    offerId: string;
+    offer?: FlightOffer;
+} | null, options?: UseFlightAncillariesOptions): import("@tanstack/react-query").UseQueryResult<{
+    catalog: {
+        baggage: {
+            id: string;
+            label: string;
+            category: "checked" | "cabin" | "personal_item" | "sports" | "oversized";
+            price: {
+                amount: string;
+                currency: string;
+            };
+            weightKg?: number | undefined;
+            dimensions?: {
+                lengthCm?: number | undefined;
+                widthCm?: number | undefined;
+                heightCm?: number | undefined;
+            } | undefined;
+            recommended?: boolean | undefined;
+            providerData?: Record<string, unknown> | undefined;
+        }[];
+        assistance: {
+            id: string;
+            label: string;
+            category: "wheelchair" | "visual" | "hearing" | "cognitive" | "medical" | "other";
+            price?: {
+                amount: string;
+                currency: string;
+            } | undefined;
+            notes?: string | undefined;
+        }[];
+        extras: {
+            id: string;
+            label: string;
+            category: string;
+            price: {
+                amount: string;
+                currency: string;
+            };
+            pricingScope?: "per_passenger" | "per_booking" | undefined;
+        }[];
+    };
+    validUntil?: string | undefined;
+}, Error>;
+//# sourceMappingURL=use-flight-ancillaries.d.ts.map

package/dist/hooks/use-flight-ancillaries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-flight-ancillaries.d.ts","sourceRoot":"","sources":["../../src/hooks/use-flight-ancillaries.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAA;AAKnE,MAAM,WAAW,2BAA2B;IAC1C,gEAAgE;IAChE,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,kEAAkE;IAClE,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,WAAW,CAAA;CAAE,GAAG,IAAI,EACtD,OAAO,GAAE,2BAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAU1C"}

package/dist/hooks/use-flight-ancillaries.js

@@ -0,0 +1,24 @@
+"use client";
+import { useQuery } from "@tanstack/react-query";
+import { useVoyantFlightsContext } from "../provider.js";
+import { getFlightAncillariesQueryOptions } from "../query-options.js";
+/**
+ * POST `/v1/admin/flights/ancillaries` — fetches the bag/assistance/extras
+ * catalog for an offer. Catalog is offer-scoped; in the per-leg booking
+ * flow callers fire one query per leg and merge the picks at book time
+ * via `FlightBookRequest.ancillaries`.
+ *
+ * Default `enabled = false` so callers gate the query on having a valid
+ * (re-priced) offer in hand. When the connector doesn't declare
+ * `flight/ancillaries`, the API returns 501 — propagated as a query error.
+ */
+export function useFlightAncillaries(input, options = {}) {
+    const client = useVoyantFlightsContext();
+    const { enabled = false, staleTime = 5 * 60_000 } = options;
+    const safeInput = input ?? { offerId: "" };
+    return useQuery({
+        ...getFlightAncillariesQueryOptions(client, safeInput),
+        enabled: enabled && !!input?.offerId,
+        staleTime,
+    });
+}

package/dist/hooks/use-flight-book.d.ts

@@ -0,0 +1,139 @@
+import type { FlightBookRequest } from "@voyantjs/flights/contract/types";
+/**
+ * POST `/v1/admin/flights/book` — books the offer with the given passengers
+ * and contact info. Mutation; on success invalidates the order query so the
+ * confirmation page reads the just-created record.
+ */
+export declare function useFlightBook(): import("@tanstack/react-query").UseMutationResult<{
+    order: {
+        orderId: string;
+        status: "pending" | "confirmed" | "ticketed" | "cancelled" | "failed";
+        offer: {
+            offerId: string;
+            source: string;
+            itineraries: {
+                segments: {
+                    segmentId: string;
+                    carrierCode: string;
+                    flightNumber: string;
+                    departure: {
+                        iataCode: string;
+                        at: string;
+                        terminal?: string | undefined;
+                    };
+                    arrival: {
+                        iataCode: string;
+                        at: string;
+                        terminal?: string | undefined;
+                    };
+                    cabin: "economy" | "premium_economy" | "business" | "first";
+                    operatingCarrierCode?: string | undefined;
+                    operatingFlightNumber?: string | undefined;
+                    duration?: string | undefined;
+                    aircraft?: string | undefined;
+                    fareClass?: string | undefined;
+                    fareBasis?: string | undefined;
+                    status?: string | undefined;
+                    providerData?: Record<string, unknown> | undefined;
+                }[];
+                duration?: string | undefined;
+            }[];
+            fareBreakdowns: {
+                passengerType: "adult" | "child" | "infant" | "senior" | "youth";
+                passengerCount: number;
+                baseFare: {
+                    amount: string;
+                    currency: string;
+                };
+                taxes: {
+                    amount: string;
+                    currency: string;
+                };
+                total: {
+                    amount: string;
+                    currency: string;
+                };
+                fees?: {
+                    amount: string;
+                    currency: string;
+                } | undefined;
+                fareFamily?: string | undefined;
+            }[];
+            totalPrice: {
+                amount: string;
+                currency: string;
+            };
+            validatingCarrier?: string | undefined;
+            expiresAt?: string | undefined;
+            lastTicketingDate?: string | undefined;
+            instantTicketing?: boolean | undefined;
+            fareBundles?: {
+                id: string;
+                label: string;
+                tier: "basic" | "standard" | "plus" | "premium";
+                priceDelta: {
+                    amount: string;
+                    currency: string;
+                };
+                inclusions: {
+                    cabinBag?: {
+                        included: boolean;
+                        weightKg?: number | undefined;
+                    } | undefined;
+                    checkedBag?: {
+                        included: boolean;
+                        pieces?: number | undefined;
+                        weightKg?: number | undefined;
+                    } | undefined;
+                    seatSelection?: "standard" | "none" | "free" | undefined;
+                    priorityBoarding?: boolean | undefined;
+                    loungeAccess?: boolean | undefined;
+                    refundable?: boolean | undefined;
+                    changeable?: boolean | undefined;
+                    notes?: string[] | undefined;
+                };
+                recommended?: boolean | undefined;
+                providerData?: Record<string, unknown> | undefined;
+            }[] | undefined;
+            providerData?: Record<string, unknown> | undefined;
+        };
+        passengers: {
+            passengerId: string;
+            type: "adult" | "child" | "infant" | "senior" | "youth";
+            firstName: string;
+            lastName: string;
+            dateOfBirth: string;
+            middleName?: string | undefined;
+            gender?: "M" | "F" | "X" | undefined;
+            email?: string | undefined;
+            phone?: string | undefined;
+            documents?: {
+                type: "passport" | "national_id" | "visa";
+                number: string;
+                countryOfIssue: string;
+                countryOfNationality?: string | undefined;
+                expiryDate?: string | undefined;
+            }[] | undefined;
+        }[];
+        totalPrice: {
+            amount: string;
+            currency: string;
+        };
+        createdAt: string;
+        pnr?: string | undefined;
+        contact?: {
+            email?: string | undefined;
+            phone?: string | undefined;
+        } | undefined;
+        tickets?: {
+            ticketNumber: string;
+            passengerId: string;
+            segmentIds: string[];
+            status?: string | undefined;
+        }[] | undefined;
+        paymentDeadline?: string | undefined;
+        updatedAt?: string | undefined;
+        providerData?: Record<string, unknown> | undefined;
+    };
+}, Error, FlightBookRequest, unknown>;
+//# sourceMappingURL=use-flight-book.d.ts.map

package/dist/hooks/use-flight-book.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-flight-book.d.ts","sourceRoot":"","sources":["../../src/hooks/use-flight-book.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAA;AAOzE;;;;GAIG;AACH,wBAAgB,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCAa5B"}

package/dist/hooks/use-flight-book.js

@@ -0,0 +1,24 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { fetchWithValidation } from "../client.js";
+import { useVoyantFlightsContext } from "../provider.js";
+import { flightsQueryKeys } from "../query-keys.js";
+import { flightBookResponseSchema } from "../schemas.js";
+/**
+ * POST `/v1/admin/flights/book` — books the offer with the given passengers
+ * and contact info. Mutation; on success invalidates the order query so the
+ * confirmation page reads the just-created record.
+ */
+export function useFlightBook() {
+    const client = useVoyantFlightsContext();
+    const qc = useQueryClient();
+    return useMutation({
+        mutationFn: (input) => fetchWithValidation("/v1/admin/flights/book", flightBookResponseSchema, client, {
+            method: "POST",
+            body: JSON.stringify(input),
+        }),
+        onSuccess: (data) => {
+            qc.setQueryData(flightsQueryKeys.orderDetail(data.order.orderId), { order: data.order });
+        },
+    });
+}