@kquika-inc/s-system 1.0.7

package/README.md

@@ -0,0 +1,222 @@
+# @kquika-inc/s-system
+
+The TypeScript client for S-System, the airline operations platform from
+Kquika.
+
+Flight operations and airport operations: live status, on-time performance,
+route analytics, stand utilization and terminal congestion, from the platform
+that forecasts disruption up to four days out.
+
+```bash
+npm install @kquika-inc/s-system
+```
+
+Browser and Node 18+. Fully typed, no fetch polyfill. MIT licensed.
+
+Also available for Python as
+[`kquika-ssystem`](https://pypi.org/project/kquika-ssystem/).
+
+## Data provenance
+
+Every flight carries `data_confidence`, so your code can read the origin of a
+record before acting on it.
+
+| Value | Meaning |
+|---|---|
+| `live_feed` | Observed from the live provider feed. |
+| `database` | Observed on an earlier read and persisted. |
+
+Fields are left null where the source carries no value. A null
+`delay_minutes` means no time was reported.
+
+## Denominators
+
+`on_time_percentage` is calculated over `measured_flights`, and both counts
+are in the response. Flights that reported no time are excluded from that
+denominator, so other ratios can be derived from the same payload.
+
+`gate_conflicts` is keyed on airport and gate together, so gate labels are
+only compared within a single station.
+
+## What you can call
+
+| | Plan |
+|---|---|
+| **List flights** with origin, destination and date filters | Standard |
+| **One flight** by number | Standard |
+| **Metrics**: on-time performance, average delay, gate conflicts | Standard |
+| **Search** by number, route or date | Standard |
+| **Route analytics**: performance grouped by route | Professional |
+| **Refresh** the live feed on demand | Professional |
+| **Airport overview**: movements, delay, stand utilization | Standard |
+| **LiDAR heatmap**: passenger density by zone | Professional |
+| **Congestion**: current level plus 1h and 3h forecast | Professional |
+
+Passenger intelligence is delivered through the application and through
+scheduled data delivery. Contact your account manager about direct access for
+your integration.
+
+## Plans
+
+Your rate limit follows your plan. Read it from the response headers instead
+of hardcoding it.
+
+| Plan | Rate limit | Burst |
+|---|---|---|
+| Standard | 100 requests/minute | 200/minute |
+| Professional | 500 requests/minute | 1,000/minute |
+| Enterprise | 2,000 requests/minute | 5,000/minute |
+
+API access starts at Standard. Starter covers the dashboard and basic
+passenger insights without programmatic access.
+
+Capabilities follow the plan too. `GET /subscription` returns the feature
+codes your account carries, so an integration can hide what it cannot reach
+instead of surfacing a 403 to a user who cannot act on it.
+
+---
+
+# Using the client
+
+## Getting started
+
+```ts
+import { client, listFlights } from '@kquika-inc/s-system';
+
+client.setConfig({
+  baseUrl: 'https://www.s-system.cloud',
+  headers: { 'X-API-Key': process.env.S_SYSTEM_API_KEY! },
+});
+
+const { data, error } = await listFlights({ query: { origin: 'SDQ', limit: 25 } });
+
+if (error || !data?.success) {
+  console.error(data?.message ?? error);
+} else {
+  for (const f of data.data!.flights!) {
+    console.log(f.flight_number, f.origin, f.destination, f.data_confidence);
+  }
+}
+```
+
+**Check `success` before reading `data`.** Every response carries
+`{success, data, message}`, and `data` is null when `success` is false.
+
+## `data_confidence`
+
+```ts
+for (const flight of data.data) {
+  if (flight.data_confidence === 'live_feed') schedule(flight);
+}
+```
+
+`live_feed` is the current reading from the provider. `database` is the same
+reading persisted from an earlier call, so it may lag the feed.
+
+TypeScript narrows that union, so a typo fails to compile instead of
+silently never matching.
+
+## Nulls
+
+`null` carries meaning in each of these fields.
+
+| Field | `null` means |
+|---|---|
+| `delay_minutes` | No time was reported. |
+| `scheduled_departure` | No schedule source covers this flight. |
+| `departure_gate` | Unassigned, or the source carries no gate. |
+| `on_time_percentage` | Nothing was measured. |
+
+```ts
+// Wrong: counts an unreported flight as on time.
+const avg = flights.reduce((s, f) => s + (f.delay_minutes ?? 0), 0) / flights.length;
+
+// Right: denominated on what was actually measured.
+const measured = flights.filter(f => f.delay_minutes !== null);
+const avg = measured.reduce((s, f) => s + f.delay_minutes!, 0) / measured.length;
+```
+
+## Airport operations
+
+```ts
+import {
+  getAirportOverview, getAirportHeatmap, getAirportCongestion,
+} from '@kquika-inc/s-system';
+
+const heat = await getAirportHeatmap({ path: { airport_code: 'SDQ' } });
+
+if (!heat.data?.data?.lidar_available) {
+  // This station has no LiDAR coverage, so points is empty.
+  console.log('No LiDAR here.');
+} else {
+  for (const p of heat.data.data.points!) {
+    console.log(p.zone, p.intensity, p.wait_time_minutes);
+  }
+}
+```
+
+`avg_wait_minutes` covers queueing zones only: security, check-in,
+immigration and customs. Gates and lounges are out of scope.
+
+Heatmap and congestion require Professional. Overview is Standard.
+
+## Flight metrics and route analytics
+
+```ts
+import { getFlightMetrics, getRouteAnalytics } from '@kquika-inc/s-system';
+
+const m = await getFlightMetrics();
+const d = m.data!.data!;
+console.log(d.on_time, 'of', d.measured_flights, 'measured');
+console.log('of', d.total_flights, 'scheduled');
+```
+
+Two denominators are returned. `on_time_percentage` divides by
+`measured_flights`. Dividing by `total_flights` yourself treats an unreported
+flight as on time.
+
+`gate_conflicts` is null when no flight carried both a gate and a scheduled
+time, which means the check could not run. Null and 0 carry different
+meanings here.
+
+## Errors
+
+| Code | Meaning |
+|---|---|
+| `unauthorized` | No valid key. Check `X-API-Key`. |
+| `forbidden` | The key lacks the permission for this endpoint. |
+| `plan_required` | Your plan does not cover this endpoint. |
+| `rate_limited` | Back off for `retry_after_seconds`. |
+
+`error` is a stable code and safe to branch on. `message` is for a human and
+its wording may change.
+
+`plan_required` is a billing matter: route analytics and refresh need
+Professional, as do heatmap and congestion.
+
+On 429, wait for `retry_after_seconds` before the next call. Rejected
+requests count toward the limit.
+
+## Types
+
+Every schema is exported.
+
+```ts
+import type {
+  Flight,
+  DisruptionPrediction,
+  Exposure,
+  Meta,
+} from '@kquika-inc/s-system';
+
+function isActionable(p: DisruptionPrediction): boolean {
+  return p.risk_level === 'critical' || p.risk_level === 'elevated';
+}
+```
+
+## Support
+
+An API key, a plan change, or a capability you need that your plan does not
+carry: [www.s-system.cloud](https://www.s-system.cloud)
+
+S-System is built by Kquika, Inc.

package/dist/client.gen.d.ts

@@ -0,0 +1,12 @@
+import type { ClientOptions } from './types.gen';
+import { type Config, type ClientOptions as DefaultClientOptions } from '@hey-api/client-fetch';
+/**
+ * The `createClientConfig()` function will be called on client initialization
+ * and the returned object will become the client's initial configuration.
+ *
+ * You may want to initialize your client this way instead of calling
+ * `setConfig()`. This is useful for example if you're using Next.js
+ * to ensure your client always has the correct values.
+ */
+export type CreateClientConfig<T extends DefaultClientOptions = ClientOptions> = (override?: Config<DefaultClientOptions & T>) => Config<Required<DefaultClientOptions> & T>;
+export declare const client: import("@hey-api/client-fetch").Client;

package/dist/client.gen.js

@@ -0,0 +1,5 @@
+// This file is auto-generated by @hey-api/openapi-ts
+import { createClient, createConfig } from '@hey-api/client-fetch';
+export const client = createClient(createConfig({
+    baseUrl: 'https://www.s-system.cloud'
+}));

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types.gen';
+export * from './sdk.gen';

package/dist/index.js

@@ -0,0 +1,3 @@
+// This file is auto-generated by @hey-api/openapi-ts
+export * from './types.gen';
+export * from './sdk.gen';

package/dist/sdk.gen.d.ts

@@ -0,0 +1,98 @@
+import type { Options as ClientOptions, TDataShape, Client } from '@hey-api/client-fetch';
+import type { ListFlightsData, GetFlightData, GetFlightMetricsData, GetRouteAnalyticsData, SearchFlightsData, RefreshFlightsData, GetAirportOverviewData, GetAirportHeatmapData, GetAirportCongestionData } from './types.gen';
+export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean> = ClientOptions<TData, ThrowOnError> & {
+    /**
+     * You can provide a client instance returned by `createClient()` instead of
+     * individual options. This might be also useful if you want to implement a
+     * custom client.
+     */
+    client?: Client;
+    /**
+     * You can pass arbitrary values through the `meta` object. This can be
+     * used to access values that aren't defined as part of the SDK function.
+     */
+    meta?: Record<string, unknown>;
+};
+/**
+ * List flights
+ * Flights for the authenticated company, with optional filters.
+ *
+ * **Requires Standard.**
+ *
+ * Each flight carries a `data_confidence` value. Confirm it before using the
+ * flight for operational planning.
+ */
+export declare const listFlights: <ThrowOnError extends boolean = false>(options?: Options<ListFlightsData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").FlightListResponse, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * One flight
+ * Details for a specific flight.
+ *
+ * **Requires Standard.**
+ */
+export declare const getFlight: <ThrowOnError extends boolean = false>(options: Options<GetFlightData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").FlightResponse, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * On-time performance, average delay and gate conflicts
+ * Aggregate performance for the operating day.
+ *
+ * **Requires Standard.**
+ *
+ * `on_time_percentage` is denominated on `measured_flights`. Flights that
+ * reported no time are excluded from that denominator. Both counts are returned
+ * so other ratios can be derived from the same response.
+ *
+ * `gate_conflicts` is keyed on airport and gate together, so gate labels are
+ * only compared within a single station.
+ */
+export declare const getFlightMetrics: <ThrowOnError extends boolean = false>(options?: Options<GetFlightMetricsData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").MetricsResponse, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * On-time performance grouped by route
+ * Performance per route over a window.
+ *
+ * **Requires Professional.**
+ */
+export declare const getRouteAnalytics: <ThrowOnError extends boolean = false>(options?: Options<GetRouteAnalyticsData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").RouteAnalyticsResponse, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * Search flights by number, route or date
+ * Free-text search across flight number, route and date.
+ *
+ * **Requires Standard.**
+ */
+export declare const searchFlights: <ThrowOnError extends boolean = false>(options: Options<SearchFlightsData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").FlightListResponse, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * Force a refresh of the live flight feed
+ * Pulls the live feed on demand, outside the scheduled refresh cycle.
+ *
+ * **Requires Professional.**
+ *
+ * This endpoint calls an upstream provider and is rate limited. Use it in
+ * response to a known change. Scheduled refreshes continue to run
+ * independently.
+ */
+export declare const refreshFlights: <ThrowOnError extends boolean = false>(options?: Options<RefreshFlightsData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").RefreshResponse, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * Airport overview
+ * Movements, delay and stand utilization for a station.
+ *
+ * **Requires Standard.**
+ */
+export declare const getAirportOverview: <ThrowOnError extends boolean = false>(options: Options<GetAirportOverviewData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").AirportOverviewResponse, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * LiDAR heatmap
+ * Passenger density by zone, from LiDAR.
+ *
+ * **Requires Professional.**
+ *
+ * Points are returned for stations with LiDAR coverage. Check
+ * `lidar_available` on the response before reading `points`.
+ */
+export declare const getAirportHeatmap: <ThrowOnError extends boolean = false>(options: Options<GetAirportHeatmapData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").HeatmapResponse, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * Congestion prediction
+ * Current congestion and the one and three hour forecast.
+ *
+ * **Requires Professional.**
+ *
+ * `avg_wait_minutes` covers queueing zones only: security, check-in,
+ * immigration and customs.
+ */
+export declare const getAirportCongestion: <ThrowOnError extends boolean = false>(options: Options<GetAirportCongestionData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").CongestionResponse, import("./types.gen").ErrorResponse, ThrowOnError>;

package/dist/sdk.gen.js

@@ -0,0 +1,184 @@
+// This file is auto-generated by @hey-api/openapi-ts
+import { client as _heyApiClient } from './client.gen';
+/**
+ * List flights
+ * Flights for the authenticated company, with optional filters.
+ *
+ * **Requires Standard.**
+ *
+ * Each flight carries a `data_confidence` value. Confirm it before using the
+ * flight for operational planning.
+ */
+export const listFlights = (options) => {
+    return (options?.client ?? _heyApiClient).get({
+        security: [
+            {
+                name: 'X-API-Key',
+                type: 'apiKey'
+            }
+        ],
+        url: '/api/v1/flights',
+        ...options
+    });
+};
+/**
+ * One flight
+ * Details for a specific flight.
+ *
+ * **Requires Standard.**
+ */
+export const getFlight = (options) => {
+    return (options.client ?? _heyApiClient).get({
+        security: [
+            {
+                name: 'X-API-Key',
+                type: 'apiKey'
+            }
+        ],
+        url: '/api/v1/flights/{flight_id}',
+        ...options
+    });
+};
+/**
+ * On-time performance, average delay and gate conflicts
+ * Aggregate performance for the operating day.
+ *
+ * **Requires Standard.**
+ *
+ * `on_time_percentage` is denominated on `measured_flights`. Flights that
+ * reported no time are excluded from that denominator. Both counts are returned
+ * so other ratios can be derived from the same response.
+ *
+ * `gate_conflicts` is keyed on airport and gate together, so gate labels are
+ * only compared within a single station.
+ */
+export const getFlightMetrics = (options) => {
+    return (options?.client ?? _heyApiClient).get({
+        security: [
+            {
+                name: 'X-API-Key',
+                type: 'apiKey'
+            }
+        ],
+        url: '/api/v1/flights/metrics',
+        ...options
+    });
+};
+/**
+ * On-time performance grouped by route
+ * Performance per route over a window.
+ *
+ * **Requires Professional.**
+ */
+export const getRouteAnalytics = (options) => {
+    return (options?.client ?? _heyApiClient).get({
+        security: [
+            {
+                name: 'X-API-Key',
+                type: 'apiKey'
+            }
+        ],
+        url: '/api/v1/flights/route-analytics',
+        ...options
+    });
+};
+/**
+ * Search flights by number, route or date
+ * Free-text search across flight number, route and date.
+ *
+ * **Requires Standard.**
+ */
+export const searchFlights = (options) => {
+    return (options.client ?? _heyApiClient).get({
+        security: [
+            {
+                name: 'X-API-Key',
+                type: 'apiKey'
+            }
+        ],
+        url: '/api/v1/flights/search',
+        ...options
+    });
+};
+/**
+ * Force a refresh of the live flight feed
+ * Pulls the live feed on demand, outside the scheduled refresh cycle.
+ *
+ * **Requires Professional.**
+ *
+ * This endpoint calls an upstream provider and is rate limited. Use it in
+ * response to a known change. Scheduled refreshes continue to run
+ * independently.
+ */
+export const refreshFlights = (options) => {
+    return (options?.client ?? _heyApiClient).post({
+        security: [
+            {
+                name: 'X-API-Key',
+                type: 'apiKey'
+            }
+        ],
+        url: '/api/v1/flights/refresh',
+        ...options
+    });
+};
+/**
+ * Airport overview
+ * Movements, delay and stand utilization for a station.
+ *
+ * **Requires Standard.**
+ */
+export const getAirportOverview = (options) => {
+    return (options.client ?? _heyApiClient).get({
+        security: [
+            {
+                name: 'X-API-Key',
+                type: 'apiKey'
+            }
+        ],
+        url: '/api/airport/{airport_code}/overview',
+        ...options
+    });
+};
+/**
+ * LiDAR heatmap
+ * Passenger density by zone, from LiDAR.
+ *
+ * **Requires Professional.**
+ *
+ * Points are returned for stations with LiDAR coverage. Check
+ * `lidar_available` on the response before reading `points`.
+ */
+export const getAirportHeatmap = (options) => {
+    return (options.client ?? _heyApiClient).get({
+        security: [
+            {
+                name: 'X-API-Key',
+                type: 'apiKey'
+            }
+        ],
+        url: '/api/airport/{airport_code}/heatmap',
+        ...options
+    });
+};
+/**
+ * Congestion prediction
+ * Current congestion and the one and three hour forecast.
+ *
+ * **Requires Professional.**
+ *
+ * `avg_wait_minutes` covers queueing zones only: security, check-in,
+ * immigration and customs.
+ */
+export const getAirportCongestion = (options) => {
+    return (options.client ?? _heyApiClient).get({
+        security: [
+            {
+                name: 'X-API-Key',
+                type: 'apiKey'
+            }
+        ],
+        url: '/api/airport/{airport_code}/congestion',
+        ...options
+    });
+};

package/dist/types.gen.d.ts

@@ -0,0 +1,451 @@
+/**
+ * Standard response envelope. Check `success` before reading `data`.
+ */
+export type Envelope = {
+    /**
+     * True when the request succeeded. `data` is null on any error. Branch on this
+     * field; do not test for the presence of `data`.
+     */
+    success: boolean;
+    /**
+     * Response payload. Null on error.
+     */
+    data?: unknown;
+    /**
+     * Human readable status text, safe to display. Wording is not part of the
+     * contract; branch on the HTTP status or on `error`.
+     */
+    message: string;
+};
+export type Flight = {
+    flight_number: string;
+    airline_code?: string;
+    origin: string;
+    destination: string;
+    /**
+     * Published departure time, UTC. Null when no schedule source covers this
+     * flight.
+     */
+    scheduled_departure?: string | null;
+    actual_departure?: string | null;
+    /**
+     * Actual departure minus scheduled departure, in minutes. Null when either time
+     * is unavailable. Null and 0 carry different meanings.
+     */
+    delay_minutes?: number | null;
+    /**
+     * Null when unassigned or not supplied by the source.
+     */
+    departure_gate?: string | null;
+    departure_terminal?: string | null;
+    aircraft_type?: string | null;
+    /**
+     * Normalized flight status. Defaults to `scheduled` when the source supplies no
+     * value.
+     */
+    status?: 'scheduled' | 'active' | 'landed' | 'delayed' | 'cancelled' | 'diverted' | 'unknown';
+    /**
+     * Provenance of this record. `live_feed` and `database` are observed records.
+     * `generated` is synthetic sample data and is not suitable for operational
+     * planning.
+     */
+    data_confidence: 'live_feed' | 'database' | 'generated';
+};
+export type FlightListResponse = Envelope & {
+    data?: {
+        flights?: Array<Flight>;
+        count?: number;
+        /**
+         * Provenance of the returned records. `generated` indicates synthetic sample
+         * data.
+         */
+        source?: 'live_feed' | 'database' | 'generated' | 'mixed';
+    };
+};
+export type FlightResponse = Envelope & {
+    data?: Flight;
+};
+export type MetricsResponse = Envelope & {
+    data?: {
+        /**
+         * All flights for the operating day, including those with no reported times.
+         */
+        total_flights?: number;
+        /**
+         * Flights that reported a departure time. Denominator for `on_time_percentage`.
+         */
+        measured_flights?: number;
+        /**
+         * Departures within 15 minutes of schedule.
+         */
+        on_time?: number;
+        /**
+         * `on_time` divided by `measured_flights`. Null when `measured_flights` is 0.
+         */
+        on_time_percentage?: number | null;
+        /**
+         * Mean delay across delayed departures only. The denominator excludes on time
+         * departures.
+         */
+        average_delay_minutes?: number | null;
+        /**
+         * Departures sharing a stand within the turnaround minimum. Null when no flight
+         * carried both a gate and a scheduled time, which is distinct from 0.
+         */
+        gate_conflicts?: number | null;
+    };
+};
+export type RouteAnalyticsResponse = Envelope & {
+    data?: Array<{
+        route?: string;
+        origin?: string;
+        destination?: string;
+        flights?: number;
+        /**
+         * Flights that reported a time. Denominator for the rates in this record.
+         */
+        measured_flights?: number;
+        on_time_percentage?: number | null;
+        average_delay_minutes?: number | null;
+        worst_delay_minutes?: number | null;
+    }>;
+};
+export type RefreshResponse = Envelope & {
+    data?: {
+        flights_fetched?: number;
+        /**
+         * Records persisted. May be lower than `flights_fetched`, since records without
+         * a usable schedule are skipped.
+         */
+        flights_stored?: number;
+        source?: string;
+    };
+};
+export type AirportOverviewResponse = Envelope & {
+    data?: {
+        airport_code?: string;
+        departures_today?: number;
+        arrivals_today?: number;
+        on_time_percentage?: number | null;
+        average_delay_minutes?: number | null;
+        gates_in_use?: number | null;
+        gate_conflicts?: number | null;
+    };
+};
+export type HeatmapResponse = Envelope & {
+    data?: {
+        airport_code?: string;
+        /**
+         * Whether LiDAR coverage exists at this station. `points` is empty when false,
+         * which carries no information about occupancy.
+         */
+        lidar_available?: boolean;
+        points?: Array<{
+            zone?: string;
+            zone_type?: string;
+            intensity?: number;
+            passenger_count?: number | null;
+            wait_time_minutes?: number | null;
+        }>;
+    };
+};
+export type CongestionResponse = Envelope & {
+    data?: Array<{
+        timestamp?: string;
+        congestion_level?: 'low' | 'moderate' | 'high' | 'critical';
+        estimated_passengers?: number | null;
+        /**
+         * Mean wait across queueing zones only: security, check-in, immigration and
+         * customs. Gates and lounges are out of scope.
+         */
+        avg_wait_minutes?: number | null;
+        /**
+         * Forecast level one hour ahead. Null when unavailable.
+         */
+        predicted_1h?: string | null;
+        /**
+         * Forecast level three hours ahead. Null when unavailable.
+         */
+        predicted_3h?: string | null;
+    }>;
+};
+export type ErrorResponse = Envelope & {
+    /**
+     * Stable machine-readable code. Safe to branch on.
+     */
+    error?: string;
+    /**
+     * Present on 429. Wait this long before retrying.
+     */
+    retry_after_seconds?: number | null;
+};
+/**
+ * IATA code, three letters. Case insensitive.
+ */
+export type AirportCode = string;
+export type ListFlightsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * IATA code, three letters. Case insensitive.
+         */
+        origin?: string;
+        destination?: string;
+        /**
+         * Operating day, ISO 8601. Defaults to today in UTC.
+         */
+        date?: string;
+        limit?: number;
+    };
+    url: '/api/v1/flights';
+};
+export type ListFlightsErrors = {
+    /**
+     * Missing or invalid API key.
+     */
+    401: ErrorResponse;
+    /**
+     * The key lacks the required scope, or the plan does not cover this endpoint.
+     * Use `error` to distinguish: `forbidden` indicates key scope, `plan_required`
+     * indicates billing.
+     */
+    403: ErrorResponse;
+    /**
+     * Too many requests.
+     */
+    429: ErrorResponse;
+};
+export type ListFlightsError = ListFlightsErrors[keyof ListFlightsErrors];
+export type ListFlightsResponses = {
+    /**
+     * Flights matching the filters.
+     */
+    200: FlightListResponse;
+};
+export type ListFlightsResponse = ListFlightsResponses[keyof ListFlightsResponses];
+export type GetFlightData = {
+    body?: never;
+    path: {
+        flight_id: string;
+    };
+    query?: never;
+    url: '/api/v1/flights/{flight_id}';
+};
+export type GetFlightErrors = {
+    /**
+     * Missing or invalid API key.
+     */
+    401: ErrorResponse;
+    /**
+     * No such flight.
+     */
+    404: ErrorResponse;
+};
+export type GetFlightError = GetFlightErrors[keyof GetFlightErrors];
+export type GetFlightResponses = {
+    /**
+     * The flight.
+     */
+    200: FlightResponse;
+};
+export type GetFlightResponse = GetFlightResponses[keyof GetFlightResponses];
+export type GetFlightMetricsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/flights/metrics';
+};
+export type GetFlightMetricsErrors = {
+    /**
+     * Missing or invalid API key.
+     */
+    401: ErrorResponse;
+};
+export type GetFlightMetricsError = GetFlightMetricsErrors[keyof GetFlightMetricsErrors];
+export type GetFlightMetricsResponses = {
+    /**
+     * Metrics for the day.
+     */
+    200: MetricsResponse;
+};
+export type GetFlightMetricsResponse = GetFlightMetricsResponses[keyof GetFlightMetricsResponses];
+export type GetRouteAnalyticsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Lookback window in days.
+         */
+        days?: number;
+    };
+    url: '/api/v1/flights/route-analytics';
+};
+export type GetRouteAnalyticsErrors = {
+    /**
+     * Missing or invalid API key.
+     */
+    401: ErrorResponse;
+    /**
+     * The key lacks the required scope, or the plan does not cover this endpoint.
+     * Use `error` to distinguish: `forbidden` indicates key scope, `plan_required`
+     * indicates billing.
+     */
+    403: ErrorResponse;
+};
+export type GetRouteAnalyticsError = GetRouteAnalyticsErrors[keyof GetRouteAnalyticsErrors];
+export type GetRouteAnalyticsResponses = {
+    /**
+     * Route performance.
+     */
+    200: RouteAnalyticsResponse;
+};
+export type GetRouteAnalyticsResponse = GetRouteAnalyticsResponses[keyof GetRouteAnalyticsResponses];
+export type SearchFlightsData = {
+    body?: never;
+    path?: never;
+    query: {
+        /**
+         * Flight number, route as ORIGIN-DESTINATION, or a date.
+         */
+        q: string;
+        limit?: number;
+    };
+    url: '/api/v1/flights/search';
+};
+export type SearchFlightsErrors = {
+    /**
+     * Missing or invalid API key.
+     */
+    401: ErrorResponse;
+};
+export type SearchFlightsError = SearchFlightsErrors[keyof SearchFlightsErrors];
+export type SearchFlightsResponses = {
+    /**
+     * Matching flights.
+     */
+    200: FlightListResponse;
+};
+export type SearchFlightsResponse = SearchFlightsResponses[keyof SearchFlightsResponses];
+export type RefreshFlightsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/flights/refresh';
+};
+export type RefreshFlightsErrors = {
+    /**
+     * Missing or invalid API key.
+     */
+    401: ErrorResponse;
+    /**
+     * The key lacks the required scope, or the plan does not cover this endpoint.
+     * Use `error` to distinguish: `forbidden` indicates key scope, `plan_required`
+     * indicates billing.
+     */
+    403: ErrorResponse;
+    /**
+     * Too many requests.
+     */
+    429: ErrorResponse;
+};
+export type RefreshFlightsError = RefreshFlightsErrors[keyof RefreshFlightsErrors];
+export type RefreshFlightsResponses = {
+    /**
+     * Refresh completed.
+     */
+    200: RefreshResponse;
+};
+export type RefreshFlightsResponse = RefreshFlightsResponses[keyof RefreshFlightsResponses];
+export type GetAirportOverviewData = {
+    body?: never;
+    path: {
+        /**
+         * IATA code, three letters. Case insensitive.
+         */
+        airport_code: string;
+    };
+    query?: never;
+    url: '/api/airport/{airport_code}/overview';
+};
+export type GetAirportOverviewErrors = {
+    /**
+     * Missing or invalid API key.
+     */
+    401: ErrorResponse;
+};
+export type GetAirportOverviewError = GetAirportOverviewErrors[keyof GetAirportOverviewErrors];
+export type GetAirportOverviewResponses = {
+    /**
+     * Overview for the station.
+     */
+    200: AirportOverviewResponse;
+};
+export type GetAirportOverviewResponse = GetAirportOverviewResponses[keyof GetAirportOverviewResponses];
+export type GetAirportHeatmapData = {
+    body?: never;
+    path: {
+        /**
+         * IATA code, three letters. Case insensitive.
+         */
+        airport_code: string;
+    };
+    query?: never;
+    url: '/api/airport/{airport_code}/heatmap';
+};
+export type GetAirportHeatmapErrors = {
+    /**
+     * Missing or invalid API key.
+     */
+    401: ErrorResponse;
+    /**
+     * The key lacks the required scope, or the plan does not cover this endpoint.
+     * Use `error` to distinguish: `forbidden` indicates key scope, `plan_required`
+     * indicates billing.
+     */
+    403: ErrorResponse;
+};
+export type GetAirportHeatmapError = GetAirportHeatmapErrors[keyof GetAirportHeatmapErrors];
+export type GetAirportHeatmapResponses = {
+    /**
+     * Heatmap points.
+     */
+    200: HeatmapResponse;
+};
+export type GetAirportHeatmapResponse = GetAirportHeatmapResponses[keyof GetAirportHeatmapResponses];
+export type GetAirportCongestionData = {
+    body?: never;
+    path: {
+        /**
+         * IATA code, three letters. Case insensitive.
+         */
+        airport_code: string;
+    };
+    query?: {
+        hours?: number;
+    };
+    url: '/api/airport/{airport_code}/congestion';
+};
+export type GetAirportCongestionErrors = {
+    /**
+     * Missing or invalid API key.
+     */
+    401: ErrorResponse;
+    /**
+     * The key lacks the required scope, or the plan does not cover this endpoint.
+     * Use `error` to distinguish: `forbidden` indicates key scope, `plan_required`
+     * indicates billing.
+     */
+    403: ErrorResponse;
+};
+export type GetAirportCongestionError = GetAirportCongestionErrors[keyof GetAirportCongestionErrors];
+export type GetAirportCongestionResponses = {
+    /**
+     * Congestion readings and forecast.
+     */
+    200: CongestionResponse;
+};
+export type GetAirportCongestionResponse = GetAirportCongestionResponses[keyof GetAirportCongestionResponses];
+export type ClientOptions = {
+    baseUrl: 'https://www.s-system.cloud' | (string & {});
+};

package/dist/types.gen.js

@@ -0,0 +1,2 @@
+// This file is auto-generated by @hey-api/openapi-ts
+export {};

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@kquika-inc/s-system",
+  "version": "1.0.7",
+  "description": "Predict flight disruption, price the passenger-rights exposure it carries, and rebook before it costs you.",
+  "author": { "name": "Kquika, Inc.", "email": "support@kquika.com" },
+  "homepage": "https://www.s-system.cloud/document",
+  "keywords": ["s-system", "airline-operations", "aviation", "passenger-management", "disruption-prediction", "api-client", "passenger-rights", "rebooking", "ancillary-pricing", "airport-operations"],
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@hey-api/client-fetch": "^0.10.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.0"
+  },
+  "license": "MIT",
+  "publishConfig": { "access": "public" }
+}