@sharpapi/sharpapi-node-airports 1.0.1 → 1.0.2

package/README.md

@@ -1,13 +1,13 @@
 ![SharpAPI GitHub cover](https://sharpapi.com/sharpapi-github-php-bg.jpg "SharpAPI Node.js Client")
 
-# Airports Database & Flight Duration Calculator API for Node.js
+# Airports Database & Flight Duration API for Node.js
 
-## ✈️ Access global airports database and calculate flight durations — powered by SharpAPI.
+## ✈️ Access 30k+ airports and calculate flight durations — powered by SharpAPI.
 
 [![npm version](https://img.shields.io/npm/v/@sharpapi/sharpapi-node-airports.svg)](https://www.npmjs.com/package/@sharpapi/sharpapi-node-airports)
 [![License](https://img.shields.io/npm/l/@sharpapi/sharpapi-node-airports.svg)](https://github.com/sharpapi/sharpapi-node-client/blob/master/LICENSE.md)
 
-**SharpAPI Airports Database** provides access to nearly 30,000 airports worldwide with comprehensive filtering, search capabilities, and flight duration calculations. Perfect for travel applications, booking systems, and aviation tools.
+**SharpAPI Airports Database** provides access to nearly 30,000 airports worldwide with detailed information including ICAO, IATA, LID codes, and geographical data. Also calculates precise flight durations between airports.
 
 ---
 
@@ -17,9 +17,11 @@
 2. [Installation](#installation)
 3. [Usage](#usage)
 4. [API Documentation](#api-documentation)
-5. [Response Format](#response-format)
-6. [Examples](#examples)
-7. [License](#license)
+5. [Examples](#examples)
+6. [Use Cases](#use-cases)
+7. [API Endpoints](#api-endpoints)
+8. [Related Packages](#related-packages)
+9. [License](#license)
 
 ---
 
@@ -34,9 +36,9 @@
 
 ### Step 1. Install the package via npm:
 
-```bash
+\`\`\`bash
 npm install @sharpapi/sharpapi-node-airports
-```
+\`\`\`
 
 ### Step 2. Get your API key
 
@@ -46,167 +48,147 @@ Visit [SharpAPI.com](https://sharpapi.com/) to get your API key.
 
 ## Usage
 
-```javascript
+\`\`\`javascript
 const { SharpApiAirportsService } = require('@sharpapi/sharpapi-node-airports');
 
-const apiKey = process.env.SHARP_API_KEY;
+const apiKey = process.env.SHARP_API_KEY; // Store your API key in environment variables
 const service = new SharpApiAirportsService(apiKey);
 
 async function searchAirports() {
   try {
-    // Search airports by city
+    // Get airports in a specific country
     const airports = await service.getAirports({
-      city: 'New York',
-      per_page: 10,
-      iata_assigned: true
-    });
-
-    console.log(`Found ${airports.data.length} airports:`);
-    airports.data.forEach(airport => {
-      console.log(`${airport.name} (${airport.iata}) - ${airport.city}, ${airport.country}`);
+      country: 'US',
+      iata_assigned: true,
+      per_page: 10
     });
 
-    // Get specific airport by IATA code
-    const jfk = await service.getAirportByIata('JFK');
-    console.log('\nJFK Airport:', jfk);
-
-    // Calculate flight duration
-    const duration = await service.calculateFlightDuration('JFK', 'LAX');
-    console.log('\nFlight JFK → LAX:', duration);
+    console.log('Found airports:', airports.data);
+    console.log('Total:', airports.meta.total);
   } catch (error) {
     console.error('Error:', error.message);
   }
 }
 
 searchAirports();
-```
+\`\`\`
 
 ---
 
 ## API Documentation
 
-### Methods
-
-#### `getAirports(filters?: object): Promise<object>`
+All endpoints are **synchronous** and return data immediately (no polling required).
 
-Get paginated list of airports with optional filters.
-
-**Filters:**
-- `per_page` (number): Results per page (max 100, default: 25)
-- `iata_assigned` (boolean): Only airports with IATA codes
-- `icao_assigned` (boolean): Only airports with ICAO codes
-- `lid_assigned` (boolean): Only airports with LID codes
-- `country` (string): Filter by 2-letter country code
-- `timezone` (string): Filter by timezone
-- `name` (string): Filter by airport name (partial match)
-- `city` (string): Filter by city name (partial match)
-
-**Returns:**
-- Paginated list of airports with metadata
+### Methods
 
-#### `getAirportByIata(iataCode: string): Promise<object>`
+#### `getAirports(filters)`
 
-Get airport information by IATA code.
+Get a paginated list of airports with optional filters.
 
 **Parameters:**
-- `iataCode` (string): Three-letter IATA code (e.g., 'JFK')
+- `filters` (object, optional):
+  - `per_page` (number, optional): Results per page (max 100, default 25)
+  - `iata_assigned` (boolean, optional): Filter for airports with IATA codes
+  - `icao_assigned` (boolean, optional): Filter for airports with ICAO codes
+  - `lid_assigned` (boolean, optional): Filter for airports with LID codes
+  - `country` (string, optional): Filter by 2-letter country code (e.g., 'US')
+  - `timezone` (string, optional): Filter by timezone (e.g., 'America/New_York')
+  - `name` (string, optional): Filter by airport name (partial match)
+  - `city` (string, optional): Filter by city name (partial match)
+
+**Returns:** Promise<object> - Paginated list with data, links, and meta information
+
+**Example:**
+\`\`\`javascript
+const airports = await service.getAirports({
+  country: 'GB',
+  iata_assigned: true,
+  per_page: 50
+});
+\`\`\`
 
-#### `getAirportByIcao(icaoCode: string): Promise<object>`
+#### `getAirportByUuid(uuid)`
 
-Get airport information by ICAO code.
+Get detailed airport information by UUID.
 
 **Parameters:**
-- `icaoCode` (string): Four-letter ICAO code (e.g., 'KJFK')
+- `uuid` (string, required): Airport UUID
 
-#### `getAirportByUuid(uuid: string): Promise<object>`
+**Returns:** Promise<object> - Airport details
 
-Get airport information by UUID.
+**Example:**
+\`\`\`javascript
+const airport = await service.getAirportByUuid('1ef266de-5a6c-67d6-86a1-06bb2780ed98');
+\`\`\`
 
-#### `getNearbyAirports(latitude: number, longitude: number, radius?: number, limit?: number): Promise<object>`
+#### `getAirportByIata(iataCode)`
 
-Find airports near a location.
+Get airport information by IATA code.
 
 **Parameters:**
-- `latitude` (number): Latitude coordinate
-- `longitude` (number): Longitude coordinate
-- `radius` (number, optional): Search radius in kilometers (default: 100)
-- `limit` (number, optional): Maximum results (default: 10)
+- `iataCode` (string, required): IATA airport code (e.g., 'LAX', 'JFK', 'LHR')
 
-#### `calculateFlightDuration(fromIata: string, toIata: string): Promise<object>`
+**Returns:** Promise<object> - Airport details
 
-Calculate flight duration between two airports.
+**Example:**
+\`\`\`javascript
+const airport = await service.getAirportByIata('LAX');
+console.log(airport.name); // "Los Angeles International Airport"
+\`\`\`
+
+#### `getAirportByIcao(icaoCode)`
+
+Get airport information by ICAO code.
 
 **Parameters:**
-- `fromIata` (string): Departure airport IATA code
-- `toIata` (string): Arrival airport IATA code
+- `icaoCode` (string, required): ICAO airport code (e.g., 'KLAX', 'KJFK', 'EGLL')
 
-#### `getCountries(): Promise<object>`
+**Returns:** Promise<object> - Airport details
 
-Get list of all countries with airports.
+**Example:**
+\`\`\`javascript
+const airport = await service.getAirportByIcao('KLAX');
+\`\`\`
 
-#### `getCitiesByCountry(countryCode: string): Promise<object>`
+#### `getAirportByLid(lidCode)`
 
-Get cities with airports in a specific country.
+Get airport information by LID code.
 
----
+**Parameters:**
+- `lidCode` (string, required): LID airport code
 
-## Response Format
+**Returns:** Promise<object> - Airport details
 
-### Airport List Response
+**Example:**
+\`\`\`javascript
+const airport = await service.getAirportByLid('00AA');
+\`\`\`
 
-```json
-{
-  "data": [
-    {
-      "id": "1ef266de-5a6c-67d6-86a1-06bb2780ed98",
-      "icao": "KJFK",
-      "iata": "JFK",
-      "lid": "",
-      "name": "John F Kennedy International Airport",
-      "city": "New York",
-      "subdivision": "New York",
-      "country": "US",
-      "timezone": "America/New_York",
-      "elevation": 13,
-      "latitude": 40.6398,
-      "longitude": -73.7789
-    }
-  ],
-  "links": {
-    "first": "https://sharpapi.com/api/v1/airports?page=1",
-    "last": "https://sharpapi.com/api/v1/airports?page=1128",
-    "prev": null,
-    "next": "https://sharpapi.com/api/v1/airports?page=2"
-  },
-  "meta": {
-    "current_page": 1,
-    "from": 1,
-    "last_page": 1128,
-    "per_page": 25,
-    "to": 25,
-    "total": 28186
-  }
-}
-```
+#### `calculateFlightDuration(...)`
 
-### Single Airport Response
+Calculate flight duration between two airports.
 
-```json
-{
-  "id": "1ef266de-5a6c-67d6-86a1-06bb2780ed98",
-  "icao": "KJFK",
-  "iata": "JFK",
-  "lid": "",
-  "name": "John F Kennedy International Airport",
-  "city": "New York",
-  "subdivision": "New York",
-  "country": "US",
-  "timezone": "America/New_York",
-  "elevation": 13,
-  "latitude": 40.6398,
-  "longitude": -73.7789
-}
-```
+**Parameters:**
+- `departureCodeType` (string, required): 'iata', 'icao', or 'lid'
+- `departureCode` (string, required): Departure airport code
+- `departureDate` (string, required): Departure date in YYYY-MM-DD format
+- `departureTime` (string, required): Departure time in HH:MM format (24-hour)
+- `arrivalCodeType` (string, required): 'iata', 'icao', or 'lid'
+- `arrivalCode` (string, required): Arrival airport code
+- `arrivalDate` (string, required): Arrival date in YYYY-MM-DD format
+- `arrivalTime` (string, required): Arrival time in HH:MM format (24-hour)
+
+**Returns:** Promise<object> - Flight duration with detailed breakdown
+
+**Example:**
+\`\`\`javascript
+const duration = await service.calculateFlightDuration(
+  'iata', 'LAX', '2026-02-15', '08:00',
+  'iata', 'JFK', '2026-02-15', '16:30'
+);
+console.log(duration.total_duration); // Total flight time
+console.log(duration.duration_breakdown); // Hours, minutes breakdown
+\`\`\`
 
 ---
 
@@ -214,235 +196,179 @@ Get cities with airports in a specific country.
 
 ### Search Airports by Country
 
-```javascript
+\`\`\`javascript
 const { SharpApiAirportsService } = require('@sharpapi/sharpapi-node-airports');
 
 const service = new SharpApiAirportsService(process.env.SHARP_API_KEY);
 
-async function getUKAirports() {
-  const airports = await service.getAirports({
-    country: 'GB',
+async function getUSAirports() {
+  const result = await service.getAirports({
+    country: 'US',
     iata_assigned: true,
-    per_page: 50
+    per_page: 100
   });
 
-  console.log(`Found ${airports.meta.total} UK airports`);
+  console.log(\`Found \${result.meta.total} US airports with IATA codes\`);
 
-  airports.data.forEach(airport => {
-    console.log(`${airport.iata} - ${airport.name}, ${airport.city}`);
+  result.data.forEach(airport => {
+    console.log(\`\${airport.iata} - \${airport.name} (\${airport.city})\`);
   });
 }
 
-getUKAirports();
-```
-
-### Flight Search Application
-
-```javascript
-const service = new SharpApiAirportsService(process.env.SHARP_API_KEY);
-
-async function searchFlights(departure, arrival) {
-  // Get departure airport
-  const depAirport = await service.getAirportByIata(departure);
-  console.log(`Departure: ${depAirport.name}, ${depAirport.city}`);
-
-  // Get arrival airport
-  const arrAirport = await service.getAirportByIata(arrival);
-  console.log(`Arrival: ${arrAirport.name}, ${arrAirport.city}`);
-
-  // Calculate flight duration
-  const duration = await service.calculateFlightDuration(departure, arrival);
-  console.log(`Estimated Duration: ${duration.hours}h ${duration.minutes}m`);
-  console.log(`Distance: ${duration.distance} km`);
-
-  return {
-    from: depAirport,
-    to: arrAirport,
-    duration: duration
-  };
-}
-
-searchFlights('LHR', 'JFK').then(result => {
-  console.log('Flight Details:', result);
-});
-```
+getUSAirports();
+\`\`\`
 
-### Travel App Integration
+### Get Specific Airport Details
 
-```javascript
+\`\`\`javascript
 const service = new SharpApiAirportsService(process.env.SHARP_API_KEY);
 
-async function buildDestinationSelector(countryCode) {
-  // Get all cities with airports in the country
-  const cities = await service.getCitiesByCountry(countryCode);
-
-  const destinations = await Promise.all(
-    cities.map(async (city) => {
-      const airports = await service.getAirports({
-        country: countryCode,
-        city: city,
-        iata_assigned: true,
-        per_page: 10
-      });
-
-      return {
-        city: city,
-        airports: airports.data.map(a => ({
-          code: a.iata,
-          name: a.name,
-          timezone: a.timezone
-        }))
-      };
-    })
-  );
+async function getAirportDetails() {
+  const lax = await service.getAirportByIata('LAX');
 
-  return destinations;
+  console.log('Airport:', lax.name);
+  console.log('City:', lax.city);
+  console.log('Country:', lax.country);
+  console.log('Timezone:', lax.timezone);
+  console.log('Elevation:', lax.elevation, 'ft');
+  console.log('Coordinates:', lax.latitude, lax.longitude);
+  console.log('Codes: IATA:', lax.iata, 'ICAO:', lax.icao);
 }
 
-const usDestinations = await buildDestinationSelector('US');
-console.log('US Destinations:', usDestinations);
-```
+getAirportDetails();
+\`\`\`
 
-### Nearby Airports Finder
+### Calculate Flight Duration
 
-```javascript
+\`\`\`javascript
 const service = new SharpApiAirportsService(process.env.SHARP_API_KEY);
 
-async function findNearestAirport(latitude, longitude) {
-  const nearby = await service.getNearbyAirports(latitude, longitude, 50, 5);
-
-  console.log(`Airports within 50km of (${latitude}, ${longitude}):`);
-
-  nearby.forEach((airport, index) => {
-    console.log(`${index + 1}. ${airport.name} (${airport.iata})`);
-    console.log(`   Distance: ${airport.distance} km`);
-    console.log(`   City: ${airport.city}, ${airport.country}`);
-  });
+async function calculateFlight() {
+  // Flight from Los Angeles to New York
+  const duration = await service.calculateFlightDuration(
+    'iata', 'LAX',
+    '2026-02-15', '08:00',
+    'iata', 'JFK',
+    '2026-02-15', '16:30'
+  );
 
-  return nearby[0]; // Return closest airport
+  console.log('Flight Duration:', duration.human_readable);
+  console.log('Hours:', duration.duration_breakdown.hours);
+  console.log('Minutes:', duration.duration_breakdown.minutes);
+  console.log('Departure:', duration.departure_airport.name);
+  console.log('Arrival:', duration.arrival_airport.name);
 }
 
-// Find airports near San Francisco
-findNearestAirport(37.7749, -122.4194);
-```
+calculateFlight();
+\`\`\`
 
-### Multi-City Trip Planner
+### Paginate Through Results
 
-```javascript
+\`\`\`javascript
 const service = new SharpApiAirportsService(process.env.SHARP_API_KEY);
 
-async function planMultiCityTrip(cities) {
-  const itinerary = [];
+async function browseAirports() {
+  let currentPage = 1;
+  let hasMore = true;
 
-  for (let i = 0; i < cities.length - 1; i++) {
-    const fromCity = cities[i];
-    const toCity = cities[i + 1];
-
-    // Find airports in each city
-    const fromAirports = await service.getAirports({
-      city: fromCity,
-      iata_assigned: true,
-      per_page: 1
+  while (hasMore && currentPage <= 5) {
+    const result = await service.getAirports({
+      per_page: 25,
+      page: currentPage
     });
 
-    const toAirports = await service.getAirports({
-      city: toCity,
-      iata_assigned: true,
-      per_page: 1
+    console.log(\`Page \${currentPage}:\`);
+    result.data.forEach(airport => {
+      console.log(\`  - \${airport.name}\`);
     });
 
-    if (fromAirports.data.length === 0 || toAirports.data.length === 0) {
-      console.log(`No airports found for ${fromCity} or ${toCity}`);
-      continue;
-    }
-
-    const fromAirport = fromAirports.data[0];
-    const toAirport = toAirports.data[0];
-
-    // Calculate duration
-    const duration = await service.calculateFlightDuration(
-      fromAirport.iata,
-      toAirport.iata
-    );
-
-    itinerary.push({
-      leg: i + 1,
-      from: {
-        city: fromCity,
-        airport: fromAirport.name,
-        code: fromAirport.iata
-      },
-      to: {
-        city: toCity,
-        airport: toAirport.name,
-        code: toAirport.iata
-      },
-      duration: duration
-    });
+    hasMore = result.links.next !== null;
+    currentPage++;
   }
-
-  return itinerary;
 }
 
-const cities = ['London', 'Paris', 'Rome', 'Barcelona'];
-const trip = await planMultiCityTrip(cities);
-
-console.log('Multi-City Itinerary:');
-trip.forEach(leg => {
-  console.log(`\nLeg ${leg.leg}: ${leg.from.city} → ${leg.to.city}`);
-  console.log(`  ${leg.from.code} to ${leg.to.code}`);
-  console.log(`  Duration: ${leg.duration.hours}h ${leg.duration.minutes}m`);
-});
-```
+browseAirports();
+\`\`\`
 
 ---
 
 ## Use Cases
 
-- **Travel Booking Platforms**: Airport search and selection
-- **Flight Search Engines**: Calculate durations and distances
-- **Travel Itinerary Planners**: Multi-city trip planning
-- **Mobile Travel Apps**: Nearby airport finder
-- **Aviation Analytics**: Airport database analysis
-- **Route Planning**: Optimize flight routes
-- **Travel Comparison Sites**: Compare flight options
-- **Tourism Applications**: Destination discovery
+- **Travel Booking**: Display airport information in booking systems
+- **Flight Search**: Enable airport code lookups and autocomplete
+- **Trip Planning**: Calculate flight times for itinerary planning
+- **Mobile Apps**: Integrate airport data into travel applications
+- **Route Planning**: Determine travel times for multi-leg journeys
+- **Logistics**: Calculate shipping times via air freight
 
 ---
 
-## Database Coverage
-
-- **Total Airports**: ~30,000 worldwide
-- **Coverage**: All continents and major aviation hubs
-- **Code Systems**: IATA, ICAO, and LID codes
-- **Data Fields**: Name, city, country, timezone, elevation, coordinates
-- **Updates**: Regular database maintenance
+## API Endpoints
 
----
+All endpoints are **synchronous** (return 200 OK immediately):
 
-## API Features
+- **GET** `/airports` - List airports with filters
+- **GET** `/airports/{uuid}` - Get airport by UUID
+- **GET** `/airports/iata/{iata}` - Get airport by IATA code
+- **GET** `/airports/icao/{icao}` - Get airport by ICAO code
+- **GET** `/airports/lid/{lid}` - Get airport by LID code
+- **GET** `/airports/flight_duration/{departureCodeType}/{departureCode}/{departureDate}/{departureTime}/{arrivalCodeType}/{arrivalCode}/{arrivalDate}/{arrivalTime}` - Calculate flight duration
 
-- **Synchronous**: Instant responses, no polling required
-- **Paginated Results**: Efficient data retrieval
-- **Flexible Filtering**: Multiple filter options
-- **Geographic Search**: Find airports by location
-- **Duration Calculation**: Estimate flight times
-- **Global Coverage**: Worldwide airport database
+For detailed API specifications, refer to:
+- [Postman Documentation](https://documenter.getpostman.com/view/31106842/2sBXVeGsVj)
+- [Product Page](https://sharpapi.com/en/catalog/utility/airports-database-flight-duration-calculator)
 
 ---
 
-## API Endpoint
+## Response Format
 
-**GET** `/airports`
+### Airport Object
 
-For detailed API specifications, refer to:
-- [Postman Documentation](https://documenter.getpostman.com/view/31106842/2sBXVeGsW2)
-- [Product Page](https://sharpapi.com/en/catalog/utility/airports-database-flight-duration-calculator)
+\`\`\`json
+{
+  "id": "1ef266de-5a6c-67d6-86a1-06bb2780ed98",
+  "icao": "00AA",
+  "iata": "",
+  "lid": "00AA",
+  "name": "Aero B Ranch Airport",
+  "city": "Leoti",
+  "subdivision": "Kansas",
+  "country": "US",
+  "timezone": "America/Chicago",
+  "elevation": 3435,
+  "latitude": 38.7,
+  "longitude": -101.47
+}
+\`\`\`
+
+### Paginated Response
+
+\`\`\`json
+{
+  "data": [ /* array of airport objects */ ],
+  "links": {
+    "first": "https://sharpapi.com/api/v1/airports?page=1",
+    "last": "https://sharpapi.com/api/v1/airports?page=1128",
+    "prev": null,
+    "next": "https://sharpapi.com/api/v1/airports?page=2"
+  },
+  "meta": {
+    "current_page": 1,
+    "from": 1,
+    "last_page": 1128,
+    "per_page": 25,
+    "to": 25,
+    "total": 28186
+  }
+}
+\`\`\`
 
 ---
 
 ## Related Packages
 
+- [@sharpapi/sharpapi-node-travel-review-sentiment](https://www.npmjs.com/package/@sharpapi/sharpapi-node-travel-review-sentiment)
+- [@sharpapi/sharpapi-node-web-scraping](https://www.npmjs.com/package/@sharpapi/sharpapi-node-web-scraping)
 - [@sharpapi/sharpapi-node-client](https://www.npmjs.com/package/@sharpapi/sharpapi-node-client) - Full SharpAPI SDK
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sharpapi/sharpapi-node-airports",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "SharpAPI.com Node.js SDK for Airports Database & Flight Duration Calculator",
   "main": "src/index.js",
   "scripts": {

package/src/CLAUDE.md

@@ -0,0 +1,7 @@
+<claude-mem-context>
+# Recent Activity
+
+<!-- This section is auto-generated by claude-mem. Edit content outside the tags. -->
+
+*No recent activity*
+</claude-mem-context>

package/src/SharpApiAirportsService.js

@@ -2,6 +2,9 @@ const { SharpApiCoreService } = require('@sharpapi/sharpapi-node-core');
 
 /**
  * Service for accessing Airports Database & Flight Duration Calculator API using SharpAPI.com
+ *
+ * Provides access to nearly 30,000 airports worldwide with detailed information including
+ * ICAO, IATA, LID codes, geographical data, and flight duration calculations.
  */
 class SharpApiAirportsService extends SharpApiCoreService {
   /**
@@ -10,106 +13,106 @@ class SharpApiAirportsService extends SharpApiCoreService {
    * @param {string} [apiBaseUrl='https://sharpapi.com/api/v1'] - API base URL
    */
   constructor(apiKey, apiBaseUrl = 'https://sharpapi.com/api/v1') {
-    super(apiKey, apiBaseUrl, '@sharpapi/sharpapi-node-airports/1.0.1');
+    super(apiKey, apiBaseUrl, '@sharpapi/sharpapi-node-airports/1.0.2');
   }
 
   /**
-   * Get list of airports with optional filters
+   * Get list of airports with optional filters (synchronous endpoint)
    *
    * @param {object} [filters={}] - Filter options
    * @param {number} [filters.per_page=25] - Results per page (max 100)
    * @param {boolean} [filters.iata_assigned] - Filter by IATA code assignment
    * @param {boolean} [filters.icao_assigned] - Filter by ICAO code assignment
-   * @param {string} [filters.country] - Filter by country
-   * @param {string} [filters.name] - Filter by airport name
-   * @param {string} [filters.city] - Filter by city
-   * @returns {Promise<object>} - List of airports
+   * @param {boolean} [filters.lid_assigned] - Filter by LID code assignment
+   * @param {string} [filters.country] - Filter by 2-letter country code
+   * @param {string} [filters.timezone] - Filter by full timezone name
+   * @param {string} [filters.name] - Filter by airport name (partial match allowed)
+   * @param {string} [filters.city] - Filter by city name (partial match allowed)
+   * @returns {Promise<object>} - Paginated list of airports with metadata
    */
   async getAirports(filters = {}) {
     const response = await this.makeRequest('GET', '/airports', filters);
-    return response.data;
+    return response;
   }
 
   /**
-   * Get airport information by IATA code
-   *
-   * @param {string} iataCode - The IATA code of the airport
-   * @returns {Promise<object>} - Airport information
-   */
-  async getAirportByIata(iataCode) {
-    const response = await this.makeRequest('GET', `/airports/iata/${iataCode}`);
-    return response.data;
-  }
-
-  /**
-   * Get airport information by ICAO code
-   *
-   * @param {string} icaoCode - The ICAO code of the airport
-   * @returns {Promise<object>} - Airport information
-   */
-  async getAirportByIcao(icaoCode) {
-    const response = await this.makeRequest('GET', `/airports/icao/${icaoCode}`);
-    return response.data;
-  }
-
-  /**
-   * Get airport information by UUID
+   * Get airport information by UUID (synchronous endpoint)
    *
    * @param {string} uuid - The UUID of the airport
    * @returns {Promise<object>} - Airport information
    */
   async getAirportByUuid(uuid) {
     const response = await this.makeRequest('GET', `/airports/${uuid}`);
-    return response.data;
+    return response;
   }
 
   /**
-   * Get airports near a specific location
+   * Get airport information by IATA code (synchronous endpoint)
    *
-   * @param {number} latitude - Latitude of the location
-   * @param {number} longitude - Longitude of the location
-   * @param {number} [radius=100] - Radius in kilometers
-   * @param {number} [limit=10] - Maximum number of results to return
-   * @returns {Promise<object>} - Nearby airports
+   * @param {string} iataCode - The IATA code of the airport (e.g., 'LAX', 'JFK')
+   * @returns {Promise<object>} - Airport information
    */
-  async getNearbyAirports(latitude, longitude, radius = 100, limit = 10) {
-    const data = { latitude, longitude, radius, limit };
-    const response = await this.makeRequest('GET', '/utility/airports/nearby', data);
-    return response.data;
+  async getAirportByIata(iataCode) {
+    const response = await this.makeRequest('GET', `/airports/iata/${iataCode}`);
+    return response;
   }
 
   /**
-   * Calculate flight duration between two airports
+   * Get airport information by ICAO code (synchronous endpoint)
    *
-   * @param {string} fromIata - IATA code of departure airport
-   * @param {string} toIata - IATA code of arrival airport
-   * @returns {Promise<object>} - Flight duration information
+   * @param {string} icaoCode - The ICAO code of the airport (e.g., 'KLAX', 'KJFK')
+   * @returns {Promise<object>} - Airport information
    */
-  async calculateFlightDuration(fromIata, toIata) {
-    const response = await this.makeRequest('GET', `/utility/flight-duration/${fromIata}/${toIata}`);
-    return response.data;
+  async getAirportByIcao(icaoCode) {
+    const response = await this.makeRequest('GET', `/airports/icao/${icaoCode}`);
+    return response;
   }
 
   /**
-   * Get all countries with airports
+   * Get airport information by LID code (synchronous endpoint)
    *
-   * @returns {Promise<object>} - List of countries
+   * @param {string} lidCode - The LID code of the airport
+   * @returns {Promise<object>} - Airport information
    */
-  async getCountries() {
-    const response = await this.makeRequest('GET', '/utility/airports/countries');
-    return response.data;
+  async getAirportByLid(lidCode) {
+    const response = await this.makeRequest('GET', `/airports/lid/${lidCode}`);
+    return response;
   }
 
   /**
-   * Get all cities with airports in a specific country
+   * Calculate flight duration between two airports (synchronous endpoint)
+   *
+   * @param {string} departureCodeType - Type of departure code: 'iata', 'icao', or 'lid'
+   * @param {string} departureCode - Departure airport code
+   * @param {string} departureDate - Departure date in YYYY-MM-DD format
+   * @param {string} departureTime - Departure time in HH:MM format
+   * @param {string} arrivalCodeType - Type of arrival code: 'iata', 'icao', or 'lid'
+   * @param {string} arrivalCode - Arrival airport code
+   * @param {string} arrivalDate - Arrival date in YYYY-MM-DD format
+   * @param {string} arrivalTime - Arrival time in HH:MM format
+   * @returns {Promise<object>} - Flight duration information with detailed breakdown
    *
-   * @param {string} countryCode - ISO country code
-   * @returns {Promise<object>} - List of cities
+   * @example
+   * // Calculate flight from LAX to JFK
+   * const duration = await service.calculateFlightDuration(
+   *   'iata', 'LAX', '2026-02-15', '08:00',
+   *   'iata', 'JFK', '2026-02-15', '16:30'
+   * );
    */
-  async getCitiesByCountry(countryCode) {
-    const response = await this.makeRequest('GET', `/utility/airports/cities/${countryCode}`);
-    return response.data;
+  async calculateFlightDuration(
+    departureCodeType,
+    departureCode,
+    departureDate,
+    departureTime,
+    arrivalCodeType,
+    arrivalCode,
+    arrivalDate,
+    arrivalTime
+  ) {
+    const endpoint = `/airports/flight_duration/${departureCodeType}/${departureCode}/${departureDate}/${departureTime}/${arrivalCodeType}/${arrivalCode}/${arrivalDate}/${arrivalTime}`;
+    const response = await this.makeRequest('GET', endpoint);
+    return response;
   }
 }
 
-module.exports = { SharpApiAirportsService };
+module.exports = { SharpApiAirportsService };