mcp-travelcode 1.0.0

package/build/tools/get-airport-flights.js

@@ -0,0 +1,78 @@
+import { z } from "zod";
+import { formatAirportBoard } from "../formatters/aerodatabox-formatter.js";
+export const getAirportFlightsSchema = {
+    airport_code: z
+        .string()
+        .describe("IATA airport code (e.g. 'JFK', 'LHR', 'WAW')"),
+    direction: z
+        .enum(["departure", "arrival"])
+        .default("departure")
+        .describe("Show departures or arrivals"),
+    from_time: z
+        .string()
+        .describe("Start of time window in YYYY-MM-DDTHH:mm format (local airport time, e.g. '2026-02-15T08:00')"),
+    to_time: z
+        .string()
+        .describe("End of time window in YYYY-MM-DDTHH:mm format (max 12 hours after from_time, e.g. '2026-02-15T14:00')"),
+    include_codeshares: z
+        .boolean()
+        .default(false)
+        .describe("Include codeshare flights (duplicates under different flight numbers)"),
+    include_cargo: z
+        .boolean()
+        .default(false)
+        .describe("Include cargo flights"),
+};
+export function registerGetAirportFlights(server, client) {
+    server.tool("get_airport_flights", "Get the departure or arrival board for an airport within a time window (max 12 hours). Shows all flights with their status, terminals, and gates. Use this to monitor departures/arrivals or check for widespread delays.", getAirportFlightsSchema, async ({ airport_code, direction, from_time, to_time, include_codeshares, include_cargo }) => {
+        try {
+            // Validate time window (max 12 hours)
+            const from = new Date(from_time);
+            const to = new Date(to_time);
+            const diffHours = (to.getTime() - from.getTime()) / (1000 * 60 * 60);
+            if (diffHours > 12) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: "Error: Time window must not exceed 12 hours. Please narrow the range.",
+                        }],
+                    isError: true,
+                };
+            }
+            if (diffHours <= 0) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: "Error: to_time must be after from_time.",
+                        }],
+                    isError: true,
+                };
+            }
+            const code = airport_code.toUpperCase();
+            const board = await client.getAerodatabox(`/flights/airports/iata/${encodeURIComponent(code)}/${from_time}/${to_time}`, {
+                withCancellations: true,
+                withCodeshares: include_codeshares,
+                withCargo: include_cargo,
+                withPrivate: false,
+                direction,
+            });
+            const flights = direction === "departure" ? board.departures || [] : board.arrivals || [];
+            return {
+                content: [{
+                        type: "text",
+                        text: formatAirportBoard(flights, code, direction, from_time, to_time),
+                    }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error getting airport flights for ${airport_code}: ${error.message}`,
+                    }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=get-airport-flights.js.map

package/build/tools/get-airport.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { TravelCodeApiClient } from "../client/api-client.js";
+export declare const getAirportSchema: {
+    code: z.ZodString;
+};
+export declare function registerGetAirport(server: McpServer, client: TravelCodeApiClient): void;
+//# sourceMappingURL=get-airport.d.ts.map

package/build/tools/get-airport.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+import { formatAirportDetail } from "../formatters/airport-formatter.js";
+export const getAirportSchema = {
+    code: z.string().describe("Airport IATA code (e.g. 'JFK', 'LHR') or internal airport ID"),
+};
+export function registerGetAirport(server, client) {
+    server.tool("get_airport", "Get detailed information about a specific airport or city by its IATA code. Returns name, city, and country.", getAirportSchema, async ({ code }) => {
+        try {
+            const airport = await client.get(`/data/airports/${encodeURIComponent(code)}`, {
+                type: "iata",
+                scope: "country,city",
+            });
+            return {
+                content: [{ type: "text", text: formatAirportDetail(airport) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Error getting airport "${code}": ${error.message}` }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=get-airport.js.map

package/build/tools/get-flight-delay-stats.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { TravelCodeApiClient } from "../client/api-client.js";
+export declare const getFlightDelayStatsSchema: {
+    flight_number: z.ZodString;
+};
+export declare function registerGetFlightDelayStats(server: McpServer, client: TravelCodeApiClient): void;
+//# sourceMappingURL=get-flight-delay-stats.d.ts.map

package/build/tools/get-flight-delay-stats.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import { formatFlightDelayStats } from "../formatters/aerodatabox-formatter.js";
+export const getFlightDelayStatsSchema = {
+    flight_number: z
+        .string()
+        .describe("Flight number including airline code (e.g. 'LO776', 'BA304')"),
+};
+export function registerGetFlightDelayStats(server, client) {
+    server.tool("get_flight_delay_stats", "Get historical delay statistics for a specific flight number. Shows how often the flight is delayed, average delay duration, and reliability assessment. Use this to evaluate a flight's punctuality before booking.", getFlightDelayStatsSchema, async ({ flight_number }) => {
+        try {
+            const normalized = flight_number.replace(/\s+/g, "").toUpperCase();
+            const stats = await client.getAerodatabox(`/flights/${encodeURIComponent(normalized)}/delays`);
+            return {
+                content: [{ type: "text", text: formatFlightDelayStats(stats, normalized) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error getting delay stats for "${flight_number}": ${error.message}`,
+                    }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=get-flight-delay-stats.js.map

package/build/tools/get-flight-results.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { TravelCodeApiClient } from "../client/api-client.js";
+export declare const getFlightResultsSchema: {
+    cache_id: z.ZodString;
+    max_stops: z.ZodOptional<z.ZodNumber>;
+    sort_by: z.ZodDefault<z.ZodEnum<["price", "duration"]>>;
+    sort_order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+    airlines: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    max_price: z.ZodOptional<z.ZodNumber>;
+    baggage_only: z.ZodDefault<z.ZodBoolean>;
+    offset: z.ZodDefault<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+};
+export declare function registerGetFlightResults(server: McpServer, client: TravelCodeApiClient): void;
+//# sourceMappingURL=get-flight-results.d.ts.map

package/build/tools/get-flight-results.js

@@ -0,0 +1,68 @@
+import { z } from "zod";
+import { formatFilteredResults } from "../formatters/flight-formatter.js";
+export const getFlightResultsSchema = {
+    cache_id: z.string().describe("Cache ID from a previous search_flights result"),
+    max_stops: z.number().int().min(0).max(3).optional().describe("Maximum number of stops (0 = direct only, 1 = max 1 stop, etc.)"),
+    sort_by: z.enum(["price", "duration"]).default("price").describe("Sort results by price or duration"),
+    sort_order: z.enum(["asc", "desc"]).default("asc").describe("Sort direction"),
+    airlines: z.array(z.string()).optional().describe("Filter to specific airline IATA codes (e.g. ['BA', 'LH'])"),
+    max_price: z.number().optional().describe("Maximum price per person"),
+    baggage_only: z.boolean().default(false).describe("Only show flights with included baggage"),
+    offset: z.number().int().min(0).default(0).describe("Pagination offset"),
+    limit: z.number().int().min(1).max(50).default(10).describe("Number of results to return"),
+};
+export function registerGetFlightResults(server, client) {
+    server.tool("get_flight_results", "Retrieve or filter existing flight search results using a cache ID from a previous search. Apply filters (direct flights, specific airlines, price range), change sorting, or paginate through results without running a new search. Cache expires after ~15 minutes.", getFlightResultsSchema, async ({ cache_id, max_stops, sort_by, sort_order, airlines, max_price, baggage_only, offset, limit }) => {
+        try {
+            // Build query params
+            const params = {
+                offset,
+                limit,
+                sort: sort_by,
+                sortOrder: sort_order.toUpperCase(),
+                embedded: "airlines,dictionaries",
+            };
+            // Build filter params
+            if (max_stops !== undefined) {
+                params["filter[transfer]"] = max_stops;
+                params["filter[transferReturn]"] = max_stops;
+            }
+            if (max_price !== undefined) {
+                params["filter[maxprice]"] = max_price;
+            }
+            if (baggage_only) {
+                params["filter[baggage]"] = 1;
+            }
+            if (airlines && airlines.length > 0) {
+                params["filter[airlines]"] = airlines.map((a) => a.toUpperCase()).join(",");
+            }
+            const results = await client.get(`/search/flights/${encodeURIComponent(cache_id)}`, params);
+            // Build filter summary
+            const filterParts = [];
+            if (max_stops !== undefined) {
+                filterParts.push(max_stops === 0 ? "Direct only" : `Max ${max_stops} stop(s)`);
+            }
+            if (airlines && airlines.length > 0) {
+                filterParts.push(`Airlines: ${airlines.join(", ")}`);
+            }
+            if (max_price !== undefined) {
+                filterParts.push(`Max price: ${max_price}`);
+            }
+            if (baggage_only) {
+                filterParts.push("Baggage included only");
+            }
+            filterParts.push(`Sorted by ${sort_by} (${sort_order})`);
+            const text = formatFilteredResults(results, cache_id, filterParts.join(" | "));
+            return {
+                content: [{ type: "text", text }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Error getting flight results: ${error.message}` }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=get-flight-results.js.map

package/build/tools/get-flight-status.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { TravelCodeApiClient } from "../client/api-client.js";
+export declare const getFlightStatusSchema: {
+    flight_number: z.ZodString;
+    date: z.ZodString;
+    with_aircraft_image: z.ZodDefault<z.ZodBoolean>;
+    with_location: z.ZodDefault<z.ZodBoolean>;
+};
+export declare function registerGetFlightStatus(server: McpServer, client: TravelCodeApiClient): void;
+//# sourceMappingURL=get-flight-status.d.ts.map

package/build/tools/get-flight-status.js

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import { formatFlightStatus } from "../formatters/aerodatabox-formatter.js";
+export const getFlightStatusSchema = {
+    flight_number: z
+        .string()
+        .describe("Flight number including airline code (e.g. 'LO776', 'BA304', 'LH1234')"),
+    date: z
+        .string()
+        .describe("Flight date in YYYY-MM-DD format (e.g. '2026-02-15')"),
+    with_aircraft_image: z
+        .boolean()
+        .default(false)
+        .describe("Include aircraft image URL in the response"),
+    with_location: z
+        .boolean()
+        .default(false)
+        .describe("Include current aircraft position if in-flight"),
+};
+export function registerGetFlightStatus(server, client) {
+    server.tool("get_flight_status", "Get real-time status of a specific flight by flight number and date. Returns departure/arrival times (scheduled, actual, estimated), terminals, gates, aircraft info, and delay information. Use this to check if a flight is on time, delayed, or cancelled.", getFlightStatusSchema, async ({ flight_number, date, with_aircraft_image, with_location }) => {
+        try {
+            const normalized = flight_number.replace(/\s+/g, "").toUpperCase();
+            const flights = await client.getAerodatabox(`/flights/number/${encodeURIComponent(normalized)}/${date}`, {
+                withAircraftImage: with_aircraft_image,
+                withLocation: with_location,
+            });
+            return {
+                content: [{ type: "text", text: formatFlightStatus(flights, normalized, date) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error getting flight status for "${flight_number}" on ${date}: ${error.message}`,
+                    }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=get-flight-status.js.map

package/build/tools/get-hotel-location.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { TravelCodeApiClient } from "../client/api-client.js";
+export declare const getHotelLocationSchema: {
+    id: z.ZodNumber;
+};
+export declare function registerGetHotelLocation(server: McpServer, client: TravelCodeApiClient): void;
+//# sourceMappingURL=get-hotel-location.d.ts.map

package/build/tools/get-hotel-location.js

@@ -0,0 +1,27 @@
+import { z } from "zod";
+export const getHotelLocationSchema = {
+    id: z.number().int().describe("Location ID (from search_hotel_locations)"),
+};
+export function registerGetHotelLocation(server, client) {
+    server.tool("get_hotel_location", "Get hotel location details by ID. Returns name and entity type (city, region, hotel).", getHotelLocationSchema, async ({ id }) => {
+        try {
+            const data = await client.getWithTokenParam("/data/hotel-location", { id });
+            const loc = data.result;
+            const text = [
+                `Location #${loc.id}`,
+                `Name: ${loc.nameEn}${loc.nameRu !== loc.nameEn ? ` (${loc.nameRu})` : ""}`,
+                `Type: ${loc.entityType}`,
+            ].join("\n");
+            return {
+                content: [{ type: "text", text }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Error getting hotel location: ${error.message}` }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=get-hotel-location.js.map

package/build/tools/get-order.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { TravelCodeApiClient } from "../client/api-client.js";
+export declare const getOrderSchema: {
+    order_id: z.ZodNumber;
+};
+export declare function registerGetOrder(server: McpServer, client: TravelCodeApiClient): void;
+//# sourceMappingURL=get-order.d.ts.map

package/build/tools/get-order.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { formatOrderDetail } from "../formatters/order-formatter.js";
+export const getOrderSchema = {
+    order_id: z.number().int().describe("Order ID"),
+};
+export function registerGetOrder(server, client) {
+    server.tool("get_order", "Get full details of an order including passengers, services, tickets, and payment status.", getOrderSchema, async ({ order_id }) => {
+        try {
+            const order = await client.get(`/orders/${order_id}`);
+            return {
+                content: [{ type: "text", text: formatOrderDetail(order) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Error getting order ${order_id}: ${error.message}` }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=get-order.js.map

package/build/tools/list-orders.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { TravelCodeApiClient } from "../client/api-client.js";
+export declare const listOrdersSchema: {
+    status: z.ZodOptional<z.ZodEnum<["pending", "confirmed", "ticketed", "pending_cancellation", "cancelled"]>>;
+    pnr: z.ZodOptional<z.ZodString>;
+    passenger_name: z.ZodOptional<z.ZodString>;
+    date_from: z.ZodOptional<z.ZodString>;
+    date_to: z.ZodOptional<z.ZodString>;
+    sort: z.ZodDefault<z.ZodEnum<["createdAt", "updatedAt", "price", "status"]>>;
+    sort_order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+    offset: z.ZodDefault<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+};
+export declare function registerListOrders(server: McpServer, client: TravelCodeApiClient): void;
+//# sourceMappingURL=list-orders.d.ts.map

package/build/tools/list-orders.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { formatOrderList } from "../formatters/order-formatter.js";
+export const listOrdersSchema = {
+    status: z
+        .enum(["pending", "confirmed", "ticketed", "pending_cancellation", "cancelled"])
+        .optional()
+        .describe("Filter by order status"),
+    pnr: z.string().optional().describe("Search by PNR (booking reference)"),
+    passenger_name: z.string().optional().describe("Search by passenger first or last name"),
+    date_from: z.string().optional().describe("Filter orders created from this date (YYYY-MM-DD)"),
+    date_to: z.string().optional().describe("Filter orders created until this date (YYYY-MM-DD)"),
+    sort: z
+        .enum(["createdAt", "updatedAt", "price", "status"])
+        .default("createdAt")
+        .describe("Sort field"),
+    sort_order: z.enum(["asc", "desc"]).default("desc").describe("Sort direction"),
+    offset: z.number().int().min(0).default(0).describe("Pagination offset"),
+    limit: z.number().int().min(1).max(100).default(20).describe("Number of results to return"),
+};
+export function registerListOrders(server, client) {
+    server.tool("list_orders", "List user's orders with optional filtering by status, PNR, passenger name, or date range. Supports pagination and sorting.", listOrdersSchema, async ({ status, pnr, passenger_name, date_from, date_to, sort, sort_order, offset, limit }) => {
+        try {
+            const data = await client.get("/orders", {
+                status,
+                pnr,
+                passengerName: passenger_name,
+                dateFrom: date_from,
+                dateTo: date_to,
+                sort,
+                sortOrder: sort_order,
+                offset,
+                limit,
+            });
+            return {
+                content: [{ type: "text", text: formatOrderList(data) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Error listing orders: ${error.message}` }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=list-orders.js.map

package/build/tools/modify-order.d.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { TravelCodeApiClient } from "../client/api-client.js";
+export declare const modifyOrderSchema: {
+    order_id: z.ZodNumber;
+    type: z.ZodEnum<["contact", "passport", "rebook", "baggage"]>;
+    changes: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+};
+export declare function registerModifyOrder(server: McpServer, client: TravelCodeApiClient): void;
+//# sourceMappingURL=modify-order.d.ts.map

package/build/tools/modify-order.js

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { formatModifyResult } from "../formatters/order-formatter.js";
+export const modifyOrderSchema = {
+    order_id: z.number().int().describe("Order ID to modify"),
+    type: z
+        .enum(["contact", "passport", "rebook", "baggage"])
+        .describe("Type of modification: contact (change email/phone), passport (change document), rebook (change dates), baggage (add baggage)"),
+    changes: z.record(z.unknown()).describe("Changes object. Fields depend on type:\n" +
+        "- contact: { email, phoneCode, phoneNumber }\n" +
+        "- passport: { serviceId, passengerId, documentNumber, documentType, expiryDate, nationality }\n" +
+        "- rebook: { serviceId, newDate (DD.MM.YYYY), newDateEnd (DD.MM.YYYY) }\n" +
+        "- baggage: { serviceId, services: [{ type: 'baggage', weight, passengerId }] }"),
+};
+export function registerModifyOrder(server, client) {
+    server.tool("modify_order", "Modify an existing order. Modification is asynchronous — use get_order to poll for the result. Call check_order_modification first to see which changes are allowed. Supported types: contact, passport, rebook, baggage.", modifyOrderSchema, async ({ order_id, type, changes }) => {
+        try {
+            const data = await client.post(`/orders/${order_id}/modify`, {
+                type,
+                changes,
+            });
+            return {
+                content: [{ type: "text", text: formatModifyResult(data) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Error modifying order ${order_id}: ${error.message}` }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=modify-order.js.map

package/build/tools/search-airlines.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { TravelCodeApiClient } from "../client/api-client.js";
+export declare const searchAirlinesSchema: {
+    query: z.ZodString;
+    limit: z.ZodDefault<z.ZodNumber>;
+};
+export declare function registerSearchAirlines(server: McpServer, client: TravelCodeApiClient): void;
+//# sourceMappingURL=search-airlines.d.ts.map

package/build/tools/search-airlines.js

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import { formatAirlineList } from "../formatters/airline-formatter.js";
+export const searchAirlinesSchema = {
+    query: z.string().describe("Search term: airline name or IATA code (e.g. 'British Airways', 'BA', 'Lufthansa')"),
+    limit: z.number().int().min(1).max(50).default(10).describe("Maximum number of results to return"),
+};
+export function registerSearchAirlines(server, client) {
+    server.tool("search_airlines", "Search for airlines by name or IATA code. Returns matching airlines with their codes and names. Use this to find airline codes for filtering flight searches.", searchAirlinesSchema, async ({ query, limit }) => {
+        try {
+            const airlines = await client.get("/data/airlines", {
+                search: query,
+                limit,
+                offset: 0,
+                sort: "title",
+                sortOrder: "ASC",
+            });
+            return {
+                content: [{ type: "text", text: formatAirlineList(airlines, query) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Error searching airlines: ${error.message}` }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=search-airlines.js.map

package/build/tools/search-airports.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { TravelCodeApiClient } from "../client/api-client.js";
+export declare const searchAirportsSchema: {
+    query: z.ZodString;
+    limit: z.ZodDefault<z.ZodNumber>;
+};
+export declare function registerSearchAirports(server: McpServer, client: TravelCodeApiClient): void;
+//# sourceMappingURL=search-airports.d.ts.map

package/build/tools/search-airports.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { formatAirportList } from "../formatters/airport-formatter.js";
+export const searchAirportsSchema = {
+    query: z.string().describe("Search term: airport name, city name, or IATA code (e.g. 'London', 'JFK', 'Heathrow')"),
+    limit: z.number().int().min(1).max(50).default(10).describe("Maximum number of results to return"),
+};
+export function registerSearchAirports(server, client) {
+    server.tool("search_airports", "Search for airports by name, city, or IATA code. Returns a list of matching airports and cities with their codes. Use this to find airport codes before searching for flights.", searchAirportsSchema, async ({ query, limit }) => {
+        try {
+            const airports = await client.get("/data/airports", {
+                search: query,
+                limit,
+                offset: 0,
+                sort: "title",
+                sortOrder: "ASC",
+                scope: "country,city",
+            });
+            return {
+                content: [{ type: "text", text: formatAirportList(airports, query) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Error searching airports: ${error.message}` }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=search-airports.js.map

package/build/tools/search-flights.d.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { TravelCodeApiClient } from "../client/api-client.js";
+import { TravelCodeConfig } from "../config.js";
+export declare const searchFlightsSchema: {
+    origin: z.ZodString;
+    destination: z.ZodString;
+    departure_date: z.ZodString;
+    return_date: z.ZodOptional<z.ZodString>;
+    cabin_class: z.ZodDefault<z.ZodEnum<["economy", "premium_economy", "business", "first"]>>;
+    adults: z.ZodDefault<z.ZodNumber>;
+    children: z.ZodDefault<z.ZodNumber>;
+    infants: z.ZodDefault<z.ZodNumber>;
+    preferred_airlines: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+};
+export declare function registerSearchFlights(server: McpServer, client: TravelCodeApiClient, config: TravelCodeConfig): void;
+//# sourceMappingURL=search-flights.d.ts.map