@infobus/vue/dist/index.d.ts

Vue components and composables for public transportation websites using GTFS data through the Infobús API

import { App } from 'vue';
import { ComponentOptionsMixin } from 'vue';
import { ComponentProvideOptions } from 'vue';
import { ComputedRef } from 'vue';
import { DefineComponent } from 'vue';
import { ExtractPropTypes } from 'vue';
import { PropType } from 'vue';
import { PublicProps } from 'vue';
import { Ref } from 'vue';

declare type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_2<T> = T extends undefined ? never : T;

declare type __VLS_Prettify<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_Prettify_2<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_TypePropsToRuntimeProps<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_2<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_2<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_WithDefaults<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
        default: D[K];
    }> : P[K];
};

declare type __VLS_WithDefaults_2<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_2<P[K] & {
        default: D[K];
    }> : P[K];
};

declare type __VLS_WithTemplateSlots<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare const _default: {
    install(app: App): void;
};
export default _default;

declare interface GeoJSONFeatureCollection {
    type: 'FeatureCollection';
    features: RouteShape[];
}

export declare interface InfobusApiConfig {
    baseUrl: string;
    apiKey?: string;
    timeout?: number;
}

export declare const InfobusNextTrips: __VLS_WithTemplateSlots< DefineComponent<ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
    limit: number;
    includeRealtime: boolean;
    autoRefresh: boolean;
    refreshInterval: number;
    showStopInfo: boolean;
    showLastUpdated: boolean;
    showRefreshButton: boolean;
    showAccessibility: boolean;
    maxTrips: number;
}>>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    error: (error: string) => void;
    tripsLoaded: (trips: NextTrip[]) => void;
    refresh: () => void;
}, string, PublicProps, Readonly< ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
    limit: number;
    includeRealtime: boolean;
    autoRefresh: boolean;
    refreshInterval: number;
    showStopInfo: boolean;
    showLastUpdated: boolean;
    showRefreshButton: boolean;
    showAccessibility: boolean;
    maxTrips: number;
}>>> & Readonly<{
    onError?: ((error: string) => any) | undefined;
    onTripsLoaded?: ((trips: NextTrip[]) => any) | undefined;
    onRefresh?: (() => any) | undefined;
}>, {
    limit: number;
    includeRealtime: boolean;
    autoRefresh: boolean;
    refreshInterval: number;
    showStopInfo: boolean;
    showLastUpdated: boolean;
    showRefreshButton: boolean;
    showAccessibility: boolean;
    maxTrips: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>, {
    loading?(_: {}): any;
    error?(_: {
        error: string;
    }): any;
    "no-trips"?(_: {}): any;
}>;

export declare const InfobusRouteMap: DefineComponent<ExtractPropTypes<__VLS_WithDefaults_2<__VLS_TypePropsToRuntimeProps_2<Props_2>, {
    directionId: undefined;
    includeStops: boolean;
    simplify: boolean;
    autoRefresh: boolean;
    refreshInterval: number;
    showRouteInfo: boolean;
    showRefreshButton: boolean;
}>>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    error: (error: string) => void;
    refresh: () => void;
    routeShapesLoaded: (shapes: RouteShape[]) => void;
}, string, PublicProps, Readonly< ExtractPropTypes<__VLS_WithDefaults_2<__VLS_TypePropsToRuntimeProps_2<Props_2>, {
    directionId: undefined;
    includeStops: boolean;
    simplify: boolean;
    autoRefresh: boolean;
    refreshInterval: number;
    showRouteInfo: boolean;
    showRefreshButton: boolean;
}>>> & Readonly<{
    onError?: ((error: string) => any) | undefined;
    onRefresh?: (() => any) | undefined;
    onRouteShapesLoaded?: ((shapes: RouteShape[]) => any) | undefined;
}>, {
    directionId: number;
    autoRefresh: boolean;
    refreshInterval: number;
    showRefreshButton: boolean;
    simplify: boolean;
    includeStops: boolean;
    showRouteInfo: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare interface NextTrip {
    trip_id: string;
    route_id: string;
    route_short_name: string;
    route_long_name: string;
    trip_headsign: string;
    arrival_time: string;
    departure_time: string;
    stop_sequence: number;
    pickup_type: number;
    drop_off_type: number;
    shape_dist_traveled?: number;
    timepoint?: number;
    estimated_arrival?: string;
    estimated_departure?: string;
    delay?: number;
    vehicle_id?: string;
    block_id?: string;
    wheelchair_accessible?: number;
    bikes_allowed?: number;
    route_color?: string;
    route_text_color?: string;
}

declare interface NextTripsResponse {
    stop_info: StopInfo;
    trips: NextTrip[];
    last_updated: string;
}

declare interface Props {
    stopId: string;
    config: InfobusApiConfig;
    limit?: number;
    routeId?: string;
    directionId?: number;
    includeRealtime?: boolean;
    autoRefresh?: boolean;
    refreshInterval?: number;
    showStopInfo?: boolean;
    showLastUpdated?: boolean;
    showRefreshButton?: boolean;
    showAccessibility?: boolean;
    maxTrips?: number;
}

declare interface Props_2 {
    routeId: string;
    config: InfobusApiConfig;
    directionId?: number;
    includeStops?: boolean;
    simplify?: boolean;
    autoRefresh?: boolean;
    refreshInterval?: number;
    showRouteInfo?: boolean;
    showRefreshButton?: boolean;
}

export declare interface RouteInfo {
    route_id: string;
    agency_id?: string;
    route_short_name: string;
    route_long_name: string;
    route_desc?: string;
    route_type: number;
    route_url?: string;
    route_color?: string;
    route_text_color?: string;
    route_sort_order?: number;
    continuous_pickup?: number;
    continuous_drop_off?: number;
}

export declare interface RouteShape {
    type: 'Feature';
    geometry: {
        type: 'LineString';
        coordinates: [number, number][];
    };
    properties: {
        shape_id: string;
        route_id: string;
        route_short_name?: string;
        route_long_name?: string;
        route_color?: string;
        direction_id?: number;
    };
}

declare interface RouteShapesResponse {
    route_info: RouteInfo;
    shapes: GeoJSONFeatureCollection;
}

export declare interface StopInfo {
    stop_id: string;
    stop_name: string;
    stop_desc?: string;
    stop_lat: number;
    stop_lon: number;
    zone_id?: string;
    stop_url?: string;
    location_type?: number;
    parent_station?: string;
    stop_timezone?: string;
    wheelchair_boarding?: number;
    platform_code?: string;
}

export declare function useInfobusApi(config: InfobusApiConfig): {
    isLoading: Ref<boolean, boolean>;
    error: Ref<string | null, string | null>;
    makeRequest: <T>(endpoint: string, options?: RequestInit) => Promise<T>;
};

export declare function useNextTrips(config: InfobusApiConfig): {
    isLoading: Ref<boolean, boolean>;
    error: Ref<string | null, string | null>;
    data: Ref<NextTripsResponse | null, NextTripsResponse | null>;
    trips: ComputedRef<NextTrip[]>;
    stopInfo: ComputedRef< StopInfo | null>;
    lastUpdated: ComputedRef<string | null>;
    lastFetch: Ref<Date | null, Date | null>;
    fetchNextTrips: (stopId: string, options?: {
        limit?: number;
        routeId?: string;
        directionId?: number;
        includeRealtime?: boolean;
    }) => Promise<NextTrip[]>;
    refresh: (stopId: string, options?: {}) => Promise<NextTrip[]>;
    getTripsByRoute: (routeId: string) => NextTrip[];
    getNextTrips: (count: number) => NextTrip[];
    isStale: (maxAgeMinutes?: number) => boolean;
};

export declare function useRouteShapes(config: InfobusApiConfig): {
    isLoading: Ref<boolean, boolean>;
    error: Ref<string | null, string | null>;
    data: Ref<RouteShapesResponse | null, RouteShapesResponse | null>;
    shapes: ComputedRef<GeoJSONFeatureCollection | null>;
    routeInfo: ComputedRef< RouteInfo | null>;
    features: ComputedRef< RouteShape[]>;
    lastFetch: Ref<Date | null, Date | null>;
    fetchRouteShapes: (routeId: string, options?: {
        directionId?: number;
        includeStops?: boolean;
        simplify?: boolean;
        format?: 'geojson' | 'polyline';
    }) => Promise<GeoJSONFeatureCollection>;
    refresh: (routeId: string, options?: {}) => Promise<GeoJSONFeatureCollection>;
    getShapesByDirection: (directionId: number) => RouteShape[];
    getAllCoordinates: () => [number, number][];
    getBounds: () => {
        north: number;
        south: number;
        east: number;
        west: number;
    } | null;
    isStale: (maxAgeMinutes?: number) => boolean;
};

export { }