bengaluru-transit 0.1.0

package/dist/api/info.js

@@ -0,0 +1,197 @@
+import { validate, stringifyId } from "../utils/validation";
+import { rawHelplineResponseSchema, rawServiceTypesResponseSchema, rawAboutDataResponseSchema, rawEmergencyMessagesResponseSchema, rawFareScrollMessagesResponseSchema, } from "../schemas/info";
+/**
+ * Transform raw transit API response to clean, normalized format
+ */
+function transformHelplineResponse(raw) {
+    return {
+        items: raw.data.map((item) => ({
+            labelName: item.labelname,
+            busStopName: item.busstopname,
+            helplineNumber: item.helplinenumber,
+        })),
+    };
+}
+/**
+ * Transform raw service types API response to clean, normalized format
+ */
+function transformServiceTypesResponse(raw) {
+    return {
+        items: raw.data.map((item) => ({
+            serviceType: item.servicetype,
+            serviceTypeId: stringifyId(item.servicetypeid),
+        })),
+    };
+}
+/**
+ * Transform raw about data API response to clean, normalized format
+ */
+function transformAboutDataResponse(raw) {
+    // About data typically has only one item
+    const item = raw.data[0];
+    return {
+        item: {
+            termsAndConditionsUrl: item.termsandconditionsurl,
+            aboutBmtcUrl: item.aboutbmtcurl,
+            aboutDeveloperUrl: item.aboutdeveloperurl,
+            airportLatitude: item.airportlattitude,
+            airportLongitude: item.airportlongitude,
+            airportStationId: stringifyId(item.airportstationid),
+            airportStationName: item.airportstationname,
+        },
+    };
+}
+/**
+ * Transform raw emergency messages API response to clean, normalized format
+ */
+function transformEmergencyMessagesResponse(raw) {
+    return {
+        items: raw.data.map((item) => ({
+            id: stringifyId(item.id),
+            messageEnglish: item.message_english,
+            messageKannada: item.message_kannada,
+            isDisplay: item.isdisplay === 1,
+            displayKey: item.display_key,
+        })),
+    };
+}
+/**
+ * Transform raw fare scroll messages API response to clean, normalized format
+ */
+function transformFareScrollMessagesResponse(raw) {
+    return {
+        items: raw.data.map((item) => ({
+            id: stringifyId(item.id),
+            messageEnglish: item.message_english,
+            messageKannada: item.message_kannada,
+            isDisplay: item.isdisplay === 1,
+            displayKey: item.display_key,
+        })),
+    };
+}
+/**
+ * Info/General API methods
+ */
+export class InfoAPI {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get transit helpline information
+     * @returns Helpline information including contact numbers in normalized format
+     * @throws {HTTPError} If the API request fails (network error, 4xx, 5xx)
+     * @example
+     * ```typescript
+     * const helpline = await client.info.getHelpline();
+     * helpline.items.forEach(item => {
+     *   console.log(`${item.title}: ${item.contactNumber}`);
+     * });
+     * ```
+     */
+    async getHelpline() {
+        const response = await this.client.getClient().post("GetHelplineData", {
+            json: {},
+        });
+        const data = await response.json();
+        // Validate raw response with Zod schema
+        const rawResponse = validate(rawHelplineResponseSchema, data, "Invalid helpline response");
+        // Transform to clean, normalized format
+        return transformHelplineResponse(rawResponse);
+    }
+    /**
+     * Get service types (e.g., AC, Non AC/Ordinary)
+     * @returns List of available service types in normalized format
+     * @throws {HTTPError} If the API request fails (network error, 4xx, 5xx)
+     * @example
+     * ```typescript
+     * const serviceTypes = await client.info.getServiceTypes();
+     * const acService = serviceTypes.items.find(s => s.serviceTypeName.includes("AC"));
+     * // Use acService.serviceTypeId in planTrip({ serviceTypeId })
+     * ```
+     */
+    async getServiceTypes() {
+        const response = await this.client.getClient().post("GetAllServiceTypes", {
+            json: {},
+        });
+        const data = await response.json();
+        // Validate raw response with Zod schema
+        const rawResponse = validate(rawServiceTypesResponseSchema, data, "Invalid service types response");
+        // Transform to clean, normalized format
+        return transformServiceTypesResponse(rawResponse);
+    }
+    /**
+     * Get about information including URLs and airport information
+     * @returns About data with terms, URLs, and airport coordinates in normalized format
+     * @throws {HTTPError} If the API request fails (network error, 4xx, 5xx)
+     * @example
+     * ```typescript
+     * const about = await client.info.getAbout();
+     * console.log(`Airport coordinates: [${about.airportLatitude}, ${about.airportLongitude}]`);
+     * console.log(`Terms URL: ${about.termsUrl}`);
+     * ```
+     */
+    async getAbout() {
+        const response = await this.client.getClient().post("GetAboutData", {
+            json: {},
+        });
+        const data = await response.json();
+        // Validate raw response with Zod schema
+        const rawResponse = validate(rawAboutDataResponseSchema, data, "Invalid about data response");
+        // Transform to clean, normalized format
+        return transformAboutDataResponse(rawResponse);
+    }
+    /**
+     * Get emergency messages (English and Kannada)
+     * @returns List of emergency messages with display settings in normalized format
+     * @throws {HTTPError} If the API request fails (network error, 4xx, 5xx)
+     * @example
+     * ```typescript
+     * const messages = await client.info.getEmergencyMessages();
+     * const activeMessages = messages.items.filter(m => m.isDisplay);
+     *
+     * activeMessages.forEach(msg => {
+     *   console.log(`${msg.displayKey}: ${msg.messageEn}`);
+     * });
+     * ```
+     */
+    async getEmergencyMessages() {
+        const response = await this.client
+            .getClient()
+            .post("GetEmergencyMessage_v1", {
+            json: {},
+        });
+        const data = await response.json();
+        // Validate raw response with Zod schema
+        const rawResponse = validate(rawEmergencyMessagesResponseSchema, data, "Invalid emergency messages response");
+        // Transform to clean, normalized format
+        return transformEmergencyMessagesResponse(rawResponse);
+    }
+    /**
+     * Get fare scroll messages (English and Kannada)
+     * @returns List of fare scroll messages with display settings in normalized format
+     * @throws {HTTPError} If the API request fails (network error, 4xx, 5xx)
+     * @example
+     * ```typescript
+     * const messages = await client.info.getFareScrollMessages();
+     * messages.items.forEach(msg => {
+     *   if (msg.isDisplay) {
+     *     console.log(`Fare update: ${msg.messageEn}`);
+     *   }
+     * });
+     * ```
+     */
+    async getFareScrollMessages() {
+        const response = await this.client
+            .getClient()
+            .post("GetFareScrollMessage", {
+            json: {},
+        });
+        const data = await response.json();
+        // Validate raw response with Zod schema
+        const rawResponse = validate(rawFareScrollMessagesResponseSchema, data, "Invalid fare scroll messages response");
+        // Transform to clean, normalized format
+        return transformFareScrollMessagesResponse(rawResponse);
+    }
+}
+//# sourceMappingURL=info.js.map

package/dist/api/info.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"info.js","sourceRoot":"","sources":["../../src/api/info.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EACN,yBAAyB,EACzB,6BAA6B,EAC7B,0BAA0B,EAC1B,kCAAkC,EAClC,mCAAmC,GACnC,MAAM,iBAAiB,CAAC;AAqBzB;;GAEG;AACH,SAAS,yBAAyB,CAAC,GAAwB;IAC1D,OAAO;QACN,KAAK,EAAE,GAAG,CAAC,IAAI,CAAC,GAAG,CAClB,CAAC,IAAI,EAAoB,EAAE,CAAC,CAAC;YAC5B,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,cAAc,EAAE,IAAI,CAAC,cAAc;SACnC,CAAC,CACF;KACD,CAAC;AACH,CAAC;AAED;;GAEG;AACH,SAAS,6BAA6B,CACrC,GAA4B;IAE5B,OAAO;QACN,KAAK,EAAE,GAAG,CAAC,IAAI,CAAC,GAAG,CAClB,CAAC,IAAI,EAAuB,EAAE,CAAC,CAAC;YAC/B,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,aAAa,EAAE,WAAW,CAAC,IAAI,CAAC,aAAa,CAAC;SAC9C,CAAC,CACF;KACD,CAAC;AACH,CAAC;AAED;;GAEG;AACH,SAAS,0BAA0B,CAClC,GAAyB;IAEzB,yCAAyC;IACzC,MAAM,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACzB,OAAO;QACN,IAAI,EAAE;YACL,qBAAqB,EAAE,IAAI,CAAC,qBAAqB;YACjD,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;YACzC,eAAe,EAAE,IAAI,CAAC,gBAAgB;YACtC,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;YACvC,gBAAgB,EAAE,WAAW,CAAC,IAAI,CAAC,gBAAgB,CAAC;YACpD,kBAAkB,EAAE,IAAI,CAAC,kBAAkB;SAC3C;KACD,CAAC;AACH,CAAC;AAED;;GAEG;AACH,SAAS,kCAAkC,CAC1C,GAAiC;IAEjC,OAAO;QACN,KAAK,EAAE,GAAG,CAAC,IAAI,CAAC,GAAG,CAClB,CAAC,IAAI,EAA4B,EAAE,CAAC,CAAC;YACpC,EAAE,EAAE,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC;YACxB,cAAc,EAAE,IAAI,CAAC,eAAe;YACpC,cAAc,EAAE,IAAI,CAAC,eAAe;YACpC,SAAS,EAAE,IAAI,CAAC,SAAS,KAAK,CAAC;YAC/B,UAAU,EAAE,IAAI,CAAC,WAAW;SAC5B,CAAC,CACF;KACD,CAAC;AACH,CAAC;AAED;;GAEG;AACH,SAAS,mCAAmC,CAC3C,GAAkC;IAElC,OAAO;QACN,KAAK,EAAE,GAAG,CAAC,IAAI,CAAC,GAAG,CAClB,CAAC,IAAI,EAA6B,EAAE,CAAC,CAAC;YACrC,EAAE,EAAE,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC;YACxB,cAAc,EAAE,IAAI,CAAC,eAAe;YACpC,cAAc,EAAE,IAAI,CAAC,eAAe;YACpC,SAAS,EAAE,IAAI,CAAC,SAAS,KAAK,CAAC;YAC/B,UAAU,EAAE,IAAI,CAAC,WAAW;SAC5B,CAAC,CACF;KACD,CAAC;AACH,CAAC;AAED;;GAEG;AACH,MAAM,OAAO,OAAO;IACC;IAApB,YAAoB,MAAkB;QAAlB,WAAM,GAAN,MAAM,CAAY;IAAG,CAAC;IAE1C;;;;;;;;;;;OAWG;IACH,KAAK,CAAC,WAAW;QAChB,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,iBAAiB,EAAE;YACtE,IAAI,EAAE,EAAE;SACR,CAAC,CAAC;QAEH,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAW,CAAC;QAE5C,wCAAwC;QACxC,MAAM,WAAW,GAAG,QAAQ,CAC3B,yBAAyB,EACzB,IAAI,EACJ,2BAA2B,CAC3B,CAAC;QAEF,wCAAwC;QACxC,OAAO,yBAAyB,CAAC,WAAW,CAAC,CAAC;IAC/C,CAAC;IAED;;;;;;;;;;OAUG;IACH,KAAK,CAAC,eAAe;QACpB,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,oBAAoB,EAAE;YACzE,IAAI,EAAE,EAAE;SACR,CAAC,CAAC;QAEH,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAW,CAAC;QAE5C,wCAAwC;QACxC,MAAM,WAAW,GAAG,QAAQ,CAC3B,6BAA6B,EAC7B,IAAI,EACJ,gCAAgC,CAChC,CAAC;QAEF,wCAAwC;QACxC,OAAO,6BAA6B,CAAC,WAAW,CAAC,CAAC;IACnD,CAAC;IAED;;;;;;;;;;OAUG;IACH,KAAK,CAAC,QAAQ;QACb,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,cAAc,EAAE;YACnE,IAAI,EAAE,EAAE;SACR,CAAC,CAAC;QAEH,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAW,CAAC;QAE5C,wCAAwC;QACxC,MAAM,WAAW,GAAG,QAAQ,CAC3B,0BAA0B,EAC1B,IAAI,EACJ,6BAA6B,CAC7B,CAAC;QAEF,wCAAwC;QACxC,OAAO,0BAA0B,CAAC,WAAW,CAAC,CAAC;IAChD,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,KAAK,CAAC,oBAAoB;QACzB,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,MAAM;aAChC,SAAS,EAAE;aACX,IAAI,CAAC,wBAAwB,EAAE;YAC/B,IAAI,EAAE,EAAE;SACR,CAAC,CAAC;QAEJ,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAW,CAAC;QAE5C,wCAAwC;QACxC,MAAM,WAAW,GAAG,QAAQ,CAC3B,kCAAkC,EAClC,IAAI,EACJ,qCAAqC,CACrC,CAAC;QAEF,wCAAwC;QACxC,OAAO,kCAAkC,CAAC,WAAW,CAAC,CAAC;IACxD,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,KAAK,CAAC,qBAAqB;QAC1B,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,MAAM;aAChC,SAAS,EAAE;aACX,IAAI,CAAC,sBAAsB,EAAE;YAC7B,IAAI,EAAE,EAAE;SACR,CAAC,CAAC;QAEJ,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAW,CAAC;QAE5C,wCAAwC;QACxC,MAAM,WAAW,GAAG,QAAQ,CAC3B,mCAAmC,EACnC,IAAI,EACJ,uCAAuC,CACvC,CAAC;QAEF,wCAAwC;QACxC,OAAO,mCAAmC,CAAC,WAAW,CAAC,CAAC;IACzD,CAAC;CACD"}

package/dist/api/locations.d.ts

@@ -0,0 +1,26 @@
+import type { BaseClient } from "../client/base-client";
+import type { SearchPlacesResponse, SearchPlacesParams } from "../types/locations";
+/**
+ * Locations API methods
+ */
+export declare class LocationsAPI {
+    private client;
+    constructor(client: BaseClient);
+    /**
+     * Search for places by name
+     * @param params - Parameters including search query
+     * @param params.query - Place name to search for
+     * @returns List of matching places in normalized format
+     * @throws {TransitValidationError} If query is invalid or validation fails
+     * @throws {HTTPError} If the API request fails (network error, 4xx, 5xx)
+     * @example
+     * ```typescript
+     * const places = await client.locations.searchPlaces({ query: "Kempegowda Bus Station" });
+     * places.items.forEach(place => {
+     *   console.log(`${place.title} - [${place.latitude}, ${place.longitude}]`);
+     * });
+     * ```
+     */
+    searchPlaces(params: SearchPlacesParams): Promise<SearchPlacesResponse>;
+}
+//# sourceMappingURL=locations.d.ts.map

package/dist/api/locations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locations.d.ts","sourceRoot":"","sources":["../../src/api/locations.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,KAAK,EACX,oBAAoB,EAEpB,kBAAkB,EAElB,MAAM,oBAAoB,CAAC;AAoB5B;;GAEG;AACH,qBAAa,YAAY;IACZ,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,UAAU;IAEtC;;;;;;;;;;;;;;OAcG;IACG,YAAY,CACjB,MAAM,EAAE,kBAAkB,GACxB,OAAO,CAAC,oBAAoB,CAAC;CA4BhC"}

package/dist/api/locations.js

@@ -0,0 +1,57 @@
+import { validate } from "../utils/validation";
+import { rawSearchPlacesResponseSchema, searchPlacesParamsSchema, } from "../schemas/locations";
+/**
+ * Transform raw search places API response to clean, normalized format
+ */
+function transformSearchPlacesResponse(raw) {
+    const items = raw.data.map((item) => ({
+        title: item.title,
+        address: item.placename,
+        latitude: item.lat,
+        longitude: item.lng,
+    }));
+    return {
+        items,
+    };
+}
+/**
+ * Locations API methods
+ */
+export class LocationsAPI {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Search for places by name
+     * @param params - Parameters including search query
+     * @param params.query - Place name to search for
+     * @returns List of matching places in normalized format
+     * @throws {TransitValidationError} If query is invalid or validation fails
+     * @throws {HTTPError} If the API request fails (network error, 4xx, 5xx)
+     * @example
+     * ```typescript
+     * const places = await client.locations.searchPlaces({ query: "Kempegowda Bus Station" });
+     * places.items.forEach(place => {
+     *   console.log(`${place.title} - [${place.latitude}, ${place.longitude}]`);
+     * });
+     * ```
+     */
+    async searchPlaces(params) {
+        // Validate input parameters - API expects "placename", map from "query"
+        const validatedParams = validate(searchPlacesParamsSchema, {
+            placename: params.query,
+        }, "Invalid search places parameters");
+        const response = await this.client
+            .getClient()
+            .post("GetSearchPlaceData", {
+            json: validatedParams,
+        });
+        const data = await response.json();
+        // Validate raw response with Zod schema
+        const rawResponse = validate(rawSearchPlacesResponseSchema, data, "Invalid search places response");
+        // Transform to clean, normalized format
+        return transformSearchPlacesResponse(rawResponse);
+    }
+}
+//# sourceMappingURL=locations.js.map

package/dist/api/locations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"locations.js","sourceRoot":"","sources":["../../src/api/locations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC/C,OAAO,EACN,6BAA6B,EAC7B,wBAAwB,GACxB,MAAM,sBAAsB,CAAC;AAS9B;;GAEG;AACH,SAAS,6BAA6B,CACrC,GAA4B;IAE5B,MAAM,KAAK,GAAgB,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;QAClD,KAAK,EAAE,IAAI,CAAC,KAAK;QACjB,OAAO,EAAE,IAAI,CAAC,SAAS;QACvB,QAAQ,EAAE,IAAI,CAAC,GAAG;QAClB,SAAS,EAAE,IAAI,CAAC,GAAG;KACnB,CAAC,CAAC,CAAC;IAEJ,OAAO;QACN,KAAK;KACL,CAAC;AACH,CAAC;AAED;;GAEG;AACH,MAAM,OAAO,YAAY;IACJ;IAApB,YAAoB,MAAkB;QAAlB,WAAM,GAAN,MAAM,CAAY;IAAG,CAAC;IAE1C;;;;;;;;;;;;;;OAcG;IACH,KAAK,CAAC,YAAY,CACjB,MAA0B;QAE1B,wEAAwE;QACxE,MAAM,eAAe,GAAG,QAAQ,CAC/B,wBAAwB,EACxB;YACC,SAAS,EAAE,MAAM,CAAC,KAAK;SACvB,EACD,kCAAkC,CAClC,CAAC;QAEF,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,MAAM;aAChC,SAAS,EAAE;aACX,IAAI,CAAC,oBAAoB,EAAE;YAC3B,IAAI,EAAE,eAAe;SACrB,CAAC,CAAC;QAEJ,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAW,CAAC;QAE5C,wCAAwC;QACxC,MAAM,WAAW,GAAG,QAAQ,CAC3B,6BAA6B,EAC7B,IAAI,EACJ,gCAAgC,CAChC,CAAC;QAEF,wCAAwC;QACxC,OAAO,6BAA6B,CAAC,WAAW,CAAC,CAAC;IACnD,CAAC;CACD"}

package/dist/api/routes.d.ts

@@ -0,0 +1,341 @@
+import type { BaseClient } from "../client/base-client";
+import type { RoutePointsResponse, RoutePointsParams, RouteSearchResponse, RouteSearchParams, AllRoutesResponse, TimetableResponse, TimetableByRouteParams, RouteDetailsResponse, RouteDetailsParams, RoutesBetweenStopsResponse, RoutesBetweenStopsParams, FareDataResponse, FareDataParams, TripPlannerResponse, TripPlannerParams, PathDetailsParams, PathDetailsResponse, WaypointsParams, TripPathResponse, TimetableByStationParams, TimetableByStationResponse } from "../types/routes";
+/**
+ * Routes API methods
+ */
+export declare class RoutesAPI {
+    private client;
+    constructor(client: BaseClient);
+    /**
+     * Get route points (path) for a given route ID
+     * @param params - Parameters including route ID
+     * @param params.routeId - Route ID (always string for consistency)
+     * @returns Route path as GeoJSON LineString FeatureCollection
+     * @throws {TransitValidationError} If routeId is invalid or validation fails
+     * @throws {HTTPError} If the API request fails (network error, 4xx, 5xx)
+     * @example
+     * ```typescript
+     * const routePath = await client.routes.getRoutePoints({
+     *   routeId: "11797"
+     * });
+     * // Use routePath.routePath.features[0].geometry.coordinates to draw on map
+     * ```
+     */
+    getRoutePoints(params: RoutePointsParams): Promise<RoutePointsResponse>;
+    /**
+     * Search for routes by query text (partial match)
+     * @param params - Parameters including search query
+     * @param params.query - Search query for routes (partial match supported)
+     * @returns List of matching routes in normalized format
+     * @throws {TransitValidationError} If query is invalid or validation fails
+     * @throws {HTTPError} If the API request fails (network error, 4xx, 5xx)
+     * @example
+     * ```typescript
+     * const routes = await client.routes.searchRoutes({ query: "285-M" });
+     * routes.items.forEach(route => {
+     *   console.log(`${route.routeNo} - ${route.parentRouteId}`);
+     * });
+     * ```
+     */
+    searchRoutes(params: RouteSearchParams): Promise<RouteSearchResponse>;
+    /**
+     * Get all routes list
+     * @returns List of all routes in normalized format
+     * @throws {HTTPError} If the API request fails (network error, 4xx, 5xx)
+     * @example
+     * ```typescript
+     * const allRoutes = await client.routes.getAllRoutes();
+     * console.log(`Total routes: ${allRoutes.items.length}`);
+     *
+     * // Find routes by name
+     * const matchingRoutes = allRoutes.items.filter(r =>
+     *   r.routeName.includes("KBS")
+     * );
+     * ```
+     */
+    getAllRoutes(): Promise<AllRoutesResponse>;
+    /**
+     * Get timetable by route ID
+     * @param params - Parameters including route ID and optional filters
+     * @param params.routeId - Route ID (always string for consistency)
+     * @param params.startTime - Optional: Start time for timetable (Date object, defaults to current time)
+     * @param params.endTime - Optional: End time for timetable (Date object, defaults to 23:59 of startTime date)
+     * @param params.fromStopId - Optional: Filter by from stop ID (requires toStopId)
+     * @param params.toStopId - Optional: Filter by to stop ID (requires fromStopId)
+     * @returns Timetable data in normalized format
+     * @throws {TransitValidationError} If routeId is invalid, validation fails, or stop IDs are provided incorrectly
+     * @throws {HTTPError} If the API request fails (network error, 4xx, 5xx)
+     * @example
+     * ```typescript
+     * // Get timetable for entire route
+     * const timetable = await client.routes.getTimetableByRoute({
+     *   routeId: "11797"
+     * });
+     *
+     * // Get timetable between specific stops
+     * const timetable = await client.routes.getTimetableByRoute({
+     *   routeId: "11797",
+     *   fromStopId: "22357",
+     *   toStopId: "21447",
+     *   startTime: new Date("2026-01-20T09:00:00")
+     * });
+     * ```
+     */
+    getTimetableByRoute(params: TimetableByRouteParams): Promise<TimetableResponse>;
+    /**
+     * Search route details by parent route ID
+     * @param params - Parameters including parent route ID and optional service type ID
+     * @param params.parentRouteId - Parent route ID (always string for consistency, obtained from searchRoutes)
+     * @param params.serviceTypeId - Optional: Filter by service type ID
+     * @returns Route details with live vehicle information for both directions (up and down)
+     * @throws {Error} If parentRouteId is invalid or validation fails
+     * @throws {HTTPError} If the API request fails (network error, 4xx, 5xx)
+     * @remarks
+     * The parentRouteId should be obtained from searchRoutes().parentRouteId.
+     * The response contains subroute IDs in up.stops and down.stops (subrouteId property).
+     * @example
+     * ```typescript
+     * // First search for route
+     * const routes = await client.routes.searchRoutes({ query: "500-CA" });
+     * const parentRouteId = routes.items[0].parentRouteId;
+     *
+     * // Get route details with live vehicles
+     * const details = await client.routes.searchByRouteDetails({ parentRouteId });
+     *
+     * // Access live vehicles for up direction
+     * details.up.vehicles.features.forEach(vehicle => {
+     *   console.log(`Vehicle ${vehicle.properties.vehicleRegNo} at ${vehicle.geometry.coordinates}`);
+     * });
+     * ```
+     */
+    searchByRouteDetails(params: RouteDetailsParams): Promise<RouteDetailsResponse>;
+    /**
+     * Get routes between two stops
+     * @param params - Parameters including from and to stop IDs
+     * @param params.fromStopId - From stop ID (always string for consistency)
+     * @param params.toStopId - To stop ID (always string for consistency)
+     * @returns List of routes connecting the two stops in normalized format
+     * @throws {TransitValidationError} If stop IDs are invalid or validation fails
+     * @throws {HTTPError} If the API request fails (network error, 4xx, 5xx)
+     * @remarks
+     * The routeId in the response is likely a subroute ID (specific to direction/variant).
+     * It can be used with searchByRouteDetails() endpoint.
+     * Note: This differs from parentRouteId returned by searchRoutes().
+     * @example
+     * ```typescript
+     * const routes = await client.routes.getRoutesBetweenStops({
+     *   fromStopId: "22357",
+     *   toStopId: "21447"
+     * });
+     *
+     * routes.items.forEach(route => {
+     *   console.log(`Route ${route.routeNo}: ${route.fromStop} → ${route.toStop}`);
+     * });
+     * ```
+     */
+    getRoutesBetweenStops(params: RoutesBetweenStopsParams): Promise<RoutesBetweenStopsResponse>;
+    /**
+     * Get fares for a route between stops
+     * @param params - Parameters from getRoutesBetweenStops() response
+     * @param params.routeId - Subroute ID (always string for consistency, from RouteBetweenStopsItem)
+     * @param params.routeDirection - Route direction: "up" or "down"
+     * @param params.sourceCode - Source code (from RouteBetweenStopsItem)
+     * @param params.destinationCode - Destination code (from RouteBetweenStopsItem)
+     * @returns Fares with service types and their fare amounts
+     * @throws {Error} If parameters are invalid or validation fails
+     * @throws {HTTPError} If the API request fails (network error, 4xx, 5xx)
+     * @remarks
+     * The parameters should come from a RouteBetweenStopsItem returned by getRoutesBetweenStops().
+     * This endpoint requires the subroute ID (not parent route ID) along with route direction,
+     * source and destination codes to determine the exact fare for that route variant.
+     * @example
+     * ```typescript
+     * // First get routes between stops
+     * const routes = await client.routes.getRoutesBetweenStops({
+     *   fromStopId: "22357",
+     *   toStopId: "21447"
+     * });
+     *
+     * // Get fare for first route
+     * const route = routes.items[0];
+     * const fare = await client.routes.getFares({
+     *   routeId: route.subrouteId,
+     *   routeDirection: route.routeDirection,
+     *   sourceCode: route.sourceCode,
+     *   destinationCode: route.destinationCode
+     * });
+     *
+     * fare.items.forEach(item => {
+     *   console.log(`Service: ${item.serviceType}, Fare: ₹${item.fare}`);
+     * });
+     * ```
+     */
+    getFares(params: FareDataParams): Promise<FareDataResponse>;
+    /**
+     * Plan a trip with multiple route options
+     * @param params - Trip planner parameters with 4 possible combinations:
+     *   - Stop to Stop: fromStopId, toStopId
+     *   - Stop to Location: fromStopId, toCoordinates
+     *   - Location to Stop: fromCoordinates, toStopId
+     *   - Location to Location: fromCoordinates, toCoordinates
+     * @returns Trip plans with all available routes (merged from directRoutes and transferRoutes)
+     * @remarks
+     * This endpoint supports 4 combinations of origin/destination:
+     * - Stop IDs (always string for consistency, will be converted to numbers for API)
+     * - Coordinates (latitude/longitude)
+     * Optional parameters:
+     * - serviceTypeId: Filter by service type (from getAllServiceTypes)
+     * - fromDateTime: Future datetime (Date object, converted to "YYYY-MM-DD HH:mm" format)
+     * - filterBy: "minimum-transfers" or "shortest-time"
+     *
+     * All routes are returned in a single `routes` array. Filter by `transferCount === 0` to identify direct routes.
+     * @throws {TransitError} If fromDateTime is not in the future
+     * @throws {TransitValidationError} If parameters are invalid or validation fails
+     * @throws {HTTPError} If the API request fails (network error, 4xx, 5xx)
+     * @example
+     * ```typescript
+     * // Location to Stop
+     * const trip = await client.routes.planTrip({
+     *   fromCoordinates: [13.09784, 77.59167],
+     *   toStopId: "20922"
+     * });
+     *
+     * // Find fastest direct route
+     * const fastest = trip.routes
+     *   .filter(r => r.transferCount === 0)
+     *   .sort((a, b) => a.totalDurationSeconds - b.totalDurationSeconds)[0];
+     * ```
+     * @example
+     * ```typescript
+     * // Stop to Stop with filters
+     * const trip = await client.routes.planTrip({
+     *   fromStopId: "22357",
+     *   toStopId: "21447",
+     *   filterBy: "shortest-time",
+     *   fromDateTime: new Date("2026-01-20T09:00:00")
+     * });
+     * ```
+     */
+    planTrip(params: TripPlannerParams): Promise<TripPlannerResponse>;
+    /**
+     * Get all stops/stations along trip legs
+     * @param params - Path details parameters with array of trip leg segments
+     * @param params.trips - Array of trip leg segments, each with tripId, fromStopId, and toStopId
+     * @returns All stops along the trip legs with station details, scheduled times, and coordinates as GeoJSON FeatureCollection
+     * @remarks
+     * This endpoint is typically used after planning a trip to get detailed
+     * station-by-station information for each leg of the journey.
+     * Each item in the request should have tripId, fromStopId, and toStopId
+     * (typically from TripPlannerPathLeg).
+     *
+     * Note: This returns stops/stations, not a geographic path (for route paths, use getTripPath).
+     * @throws {TransitValidationError} If trip parameters are invalid or validation fails
+     * @throws {HTTPError} If the API request fails (network error, 4xx, 5xx)
+     * @example
+     * ```typescript
+     * // After planning a trip, get all stops along the route
+     * const trip = await client.routes.planTrip({
+     *   fromStopId: "22357",
+     *   toStopId: "21447"
+     * });
+     *
+     * // Extract trip legs (excluding walking segments)
+     * const tripLegs = trip.routes[0].legs
+     *   .filter(leg => !leg.routeNo.startsWith('walk'))
+     *   .map(leg => ({
+     *     tripId: leg.tripId,
+     *     fromStopId: leg.fromStopId,
+     *     toStopId: leg.toStopId
+     *   }));
+     *
+     * // Get all stops as GeoJSON
+     * const stops = await client.routes.getTripStops({ trips: tripLegs });
+     * // Use stops.features to display on map
+     * ```
+     */
+    getTripStops(params: PathDetailsParams): Promise<PathDetailsResponse>;
+    /**
+     * Get trip path as GeoJSON FeatureCollection with LineString features
+     * @param params - Trip path parameters with via points (bus stops)
+     * @param params.viaPoints - Array of [latitude, longitude] coordinates or GeoJSON FeatureCollection from getTripStops()
+     * @returns GeoJSON FeatureCollection with LineString features representing the route path
+     * @remarks
+     * This endpoint returns encoded polyline strings representing path segments between origin, via points, and destination.
+     * The wrapper decodes these using HERE Flexible Polyline format into GeoJSON LineString features.
+     * Each segment becomes a LineString feature with [lng, lat] coordinates.
+     *
+     * The first point in viaPoints is the origin, the last point is the destination.
+     * All intermediate points are treated as via points (bus stops along the route).
+     *
+     * You can pass GeoJSON FeatureCollection from `getTripStops()` - coordinates will be extracted, properties ignored.
+     * @throws {TransitValidationError} If viaPoints are invalid or validation fails
+     * @throws {HTTPError} If the API request fails (network error, 4xx, 5xx)
+     * @example
+     * ```typescript
+     * // Get stops first
+     * const stops = await client.routes.getTripStops({ trips: tripLegs });
+     *
+     * // Get path using stops (coordinates extracted automatically)
+     * const path = await client.routes.getTripPath({ viaPoints: stops });
+     * // Use path.features to draw route lines on map
+     * ```
+     * @example
+     * ```typescript
+     * // Or use coordinates directly
+     * const path = await client.routes.getTripPath({
+     *   viaPoints: [
+     *     [13.09784, 77.59167], // Origin
+     *     [13.09884, 77.59267], // Via point
+     *     [13.09984, 77.59367]  // Destination
+     *   ]
+     * });
+     * ```
+     */
+    getTripPath(params: WaypointsParams): Promise<TripPathResponse>;
+    /**
+     * Get routes that pass through both stations (in sequence)
+     * @param params - Parameters including from station ID, to station ID, and optional filters
+     * @param params.fromStopId - From stop ID (always string for consistency)
+     * @param params.toStopId - To stop ID (always string for consistency)
+     * @param params.routeId - Optional: Filter by specific route ID
+     * @param params.date - Optional: Date for timetable (Date object, defaults to current date)
+     * @returns Routes that go through both stations with schedule information
+     * @remarks
+     * This is NOT a full timetable - each route has one startTime, not multiple scheduled trips.
+     * Routes may start before fromStop and/or continue after toStop.
+     * @throws {TransitValidationError} If stop IDs are invalid or validation fails
+     * @throws {HTTPError} If the API request fails (network error, 4xx, 5xx)
+     * @example
+     * ```typescript
+     * // Find routes passing through both stops
+     * const routes = await client.routes.getRoutesThroughStations({
+     *   fromStopId: "30475",
+     *   toStopId: "35376"
+     * });
+     *
+     * routes.items.forEach(route => {
+     *   console.log(`Route ${route.routeNo} starts at ${route.startTime}`);
+     *   console.log(`Travel time: ${route.travelTime}, Distance: ${route.distance} km`);
+     * });
+     * ```
+     * @example
+     * ```typescript
+     * // Filter by specific route
+     * const routes = await client.routes.getRoutesThroughStations({
+     *   fromStopId: "30475",
+     *   toStopId: "35376",
+     *   routeId: "2292",
+     *   date: new Date("2026-01-20")
+     * });
+     * ```
+     * @remarks
+     * This endpoint returns all routes that pass through both the fromStation and toStation in sequence.
+     * The routes may start before fromStation and/or continue after toStation - they just need to pass through both.
+     * Returns one startTime per route (not a full timetable with multiple trips).
+     * For a full timetable with multiple trips, use getTimetableByRoute() instead.
+     * The date, start time, and end time parameters are required by the API but don't affect the output.
+     * Use routeId to filter results to a specific route.
+     */
+    getRoutesThroughStations(params: TimetableByStationParams): Promise<TimetableByStationResponse>;
+}
+//# sourceMappingURL=routes.d.ts.map

package/dist/api/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../src/api/routes.ts"],"names":[],"mappings":"AAmCA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,KAAK,EACX,mBAAmB,EAEnB,iBAAiB,EACjB,mBAAmB,EAEnB,iBAAiB,EAEjB,iBAAiB,EAGjB,iBAAiB,EAEjB,sBAAsB,EAEtB,oBAAoB,EAEpB,kBAAkB,EAKlB,0BAA0B,EAE1B,wBAAwB,EAGxB,gBAAgB,EAEhB,cAAc,EAEd,mBAAmB,EAEnB,iBAAiB,EAIjB,iBAAiB,EACjB,mBAAmB,EAGnB,eAAe,EACf,gBAAgB,EAEhB,wBAAwB,EACxB,0BAA0B,EAG1B,MAAM,iBAAiB,CAAC;AAmnBzB;;GAEG;AACH,qBAAa,SAAS;IACT,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,UAAU;IAEtC;;;;;;;;;;;;;;OAcG;IACG,cAAc,CACnB,MAAM,EAAE,iBAAiB,GACvB,OAAO,CAAC,mBAAmB,CAAC;IAyB/B;;;;;;;;;;;;;;OAcG;IACG,YAAY,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAyB3E;;;;;;;;;;;;;;OAcG;IACG,YAAY,IAAI,OAAO,CAAC,iBAAiB,CAAC;IAmBhD;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACG,mBAAmB,CACxB,MAAM,EAAE,sBAAsB,GAC5B,OAAO,CAAC,iBAAiB,CAAC;IAiE7B;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACG,oBAAoB,CACzB,MAAM,EAAE,kBAAkB,GACxB,OAAO,CAAC,oBAAoB,CAAC;IAwChC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACG,qBAAqB,CAC1B,MAAM,EAAE,wBAAwB,GAC9B,OAAO,CAAC,0BAA0B,CAAC;IAoCtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACG,QAAQ,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAsCjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4CG;IACG,QAAQ,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAyEvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACG,YAAY,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAyC3E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACG,WAAW,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC;IA+DrE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2CG;IACG,wBAAwB,CAC7B,MAAM,EAAE,wBAAwB,GAC9B,OAAO,CAAC,0BAA0B,CAAC;CAgDtC"}