@mapvx/web-components-ssr 1.0.0-rc.0

package/dist/types/public-api.d.ts

@@ -0,0 +1,1132 @@
+declare enum AnimationState {
+    NotStarted = 0,
+    Playing = 1,
+    Paused = 2,
+    Finished = 3
+}
+
+interface CategoryFiltersData {
+    name: string;
+    placeData: string[];
+}
+
+// Note: as of the RFC 7946 version of GeoJSON, Coordinate Reference Systems
+// are no longer supported. (See https://tools.ietf.org/html/rfc7946#appendix-B)}
+
+
+
+/**
+ * A Position is an array of coordinates.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.1
+ * Array should contain between two and three elements.
+ * The previous GeoJSON specification allowed more elements (e.g., which could be used to represent M values),
+ * but the current specification only allows X, Y, and (optionally) Z to be defined.
+ *
+ * Note: the type will not be narrowed down to `[number, number] | [number, number, number]` due to
+ * marginal benefits and the large impact of breaking change.
+ *
+ * See previous discussions on the type narrowing:
+ * - {@link https://github.com/DefinitelyTyped/DefinitelyTyped/pull/21590|Nov 2017}
+ * - {@link https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/67773|Dec 2023}
+ * - {@link https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/71441| Dec 2024}
+ *
+ * One can use a
+ * {@link https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates|user-defined type guard that returns a type predicate}
+ * to determine if a position is a 2D or 3D position.
+ *
+ * @example
+ * import type { Position } from 'geojson';
+ *
+ * type StrictPosition = [x: number, y: number] | [x: number, y: number, z: number]
+ *
+ * function isStrictPosition(position: Position): position is StrictPosition {
+ *   return position.length === 2 || position.length === 3
+ * };
+ *
+ * let position: Position = [-116.91, 45.54];
+ *
+ * let x: number;
+ * let y: number;
+ * let z: number | undefined;
+ *
+ * if (isStrictPosition(position)) {
+ *   // `tsc` would throw an error if we tried to destructure a fourth parameter
+ * 	 [x, y, z] = position;
+ * } else {
+ * 	 throw new TypeError("Position is not a 2D or 3D point");
+ * }
+ */
+type Position = number[];
+
+/**
+ * basic latitude and longitude model
+ * @group Places & Locations
+ */
+interface LatLng {
+    lat: number;
+    lng: number;
+}
+
+interface RouteResponse {
+    legs: RouteLegResponse[];
+}
+interface RouteLegResponse {
+    distance: {
+        value: number;
+    };
+    duration: {
+        value: number;
+    };
+    start_location: LatLng;
+    end_location: LatLng;
+    steps: RouteStepResponse[];
+}
+interface RouteStepResponse {
+    distance: {
+        value: number;
+    };
+    duration: {
+        value: number;
+    };
+    start_location: LatLng;
+    start_inside_floor?: string;
+    start_inside_place?: string;
+    end_location: LatLng;
+    end_inside_floor?: string;
+    end_inside_place?: string;
+    html_instructions: string;
+    plain_instructions: string;
+    maneuver: string;
+    elevator_step: boolean;
+    show_popup?: boolean;
+    icon_prefix?: string;
+    polyline: RoutePolylineResponse;
+}
+interface RoutePolylineResponse {
+    points: string;
+    points_lat_lng?: LatLng[];
+    overview_points?: LatLng[];
+}
+
+/**
+ * Represents a complete route in MapVX that can contain multiple legs.
+ * Each route is composed of a series of legs that connect different points.
+ * @group Routes
+ */
+declare class MVXRoute {
+    /**
+     * Unique identifier for the route generated automatically
+     */
+    id: string;
+    /**
+     * List of legs that compose the complete route
+     */
+    legs: MVXRouteLeg[];
+    /**
+     * Creates a new route instance from API response data
+     * @hidden
+     * @param data API response data containing route information
+     */
+    constructor(data: RouteResponse);
+    /**
+     * Gets all steps of the route by combining steps from all legs
+     * @returns Array with all route steps
+     */
+    get steps(): MVXRouteStep[];
+    /**
+     * Gets the total duration of the route.
+     * This property calculates the sum of the duration of all legs in the route.
+     *
+     * @returns {number} The total duration of the route, in seconds.
+     */
+    get duration(): number;
+    /**
+     * Gets the total length of the route.
+     * This property calculates the sum of the length of all legs in the route.
+     *
+     * @returns {number} The total length of the route, in meters.
+     */
+    get length(): number;
+}
+/**
+ * Represents a route leg that connects two specific points.
+ * Each leg contains information about distance, duration, and detailed steps.
+ * @group Routes
+ */
+declare class MVXRouteLeg {
+    /**
+     * Total distance of the leg in meters
+     */
+    distance: number;
+    /**
+     * Estimated duration of the leg in seconds
+     */
+    duration: number;
+    /**
+     * Starting location of the leg
+     */
+    startLocation: LatLng;
+    /**
+     * Ending location of the leg
+     */
+    endLocation: LatLng;
+    /**
+     * List of detailed steps that compose this leg
+     */
+    steps: MVXRouteStep[];
+    /**
+     * Creates a new route leg instance from response data
+     * @hidden
+     * @param data API response data containing leg information
+     */
+    constructor(data: RouteLegResponse);
+}
+/**
+ * Represents an individual step within a route leg.
+ * Each step contains specific instructions and coordinates for navigation.
+ * @group Routes
+ */
+declare class MVXRouteStep {
+    /**
+     * Distance of the step in meters
+     */
+    distance: number;
+    /**
+     * Estimated duration of the step in seconds
+     */
+    duration: number;
+    /**
+     * Starting location of the step
+     */
+    startLocation: LatLng;
+    /**
+     * Identifier of the floor where the step begins (if applicable)
+     */
+    startInsideFloor?: string;
+    /**
+     * Identifier of the place where the step begins (if applicable)
+     */
+    startInsidePlace?: string;
+    /**
+     * Ending location of the step
+     */
+    endLocation: LatLng;
+    /**
+     * Identifier of the floor where the step ends (if applicable)
+     */
+    endInsideFloor?: string;
+    /**
+     * Identifier of the place where the step ends (if applicable)
+     */
+    endInsidePlace?: string;
+    /**
+     * HTML formatted instructions to display to the user
+     */
+    htmlInstruction: string;
+    /**
+     * Plain text instructions to display to the user
+     */
+    plainInstruction: string;
+    /**
+     * Type of maneuver the user should perform (e.g., "turn-left", "straight")
+     */
+    maneuver: string;
+    /**
+     * Indicates if a popup with additional information should be shown
+     */
+    showPopup?: boolean;
+    /**
+     * Icon prefix to display for this step
+     */
+    iconPrefix?: string;
+    /**
+     * Indicates if this step involves using an elevator
+     */
+    elevatorStep: boolean;
+    /**
+     * Object containing the polyline information for the step
+     * @hidden
+     */
+    polyline: Polyline;
+    /**
+     * Creates a new route step instance from response data
+     * @hidden
+     * @param data API response data containing step information
+     */
+    constructor(data: RouteStepResponse);
+    /**
+     * Gets the polyline coordinates in GeoJSON format
+     * @returns Array of coordinates in [longitude, latitude] format
+     */
+    get geoJsonCoordinates(): Position[];
+    /**
+     * Gets the polyline coordinates in LatLng format
+     * @returns Array of LatLng coordinates
+     */
+    get coordinates(): LatLng[];
+}
+/**
+ * Internal class that handles polyline decoding and management.
+ * A polyline is an encoded representation of a series of coordinates.
+ */
+declare class Polyline {
+    /**
+     * Encoded string of polyline points
+     */
+    points: string;
+    /**
+     * Polyline points in LatLng format (optional)
+     */
+    pointsLatLng?: LatLng[];
+    /**
+     * Overview points of the polyline (optional)
+     */
+    overviewPoints?: LatLng[];
+    /**
+     * Decoded points of the polyline
+     */
+    private decodedPoints;
+    /**
+     * Creates a new polyline instance from response data
+     * @param data Response data containing polyline information
+     */
+    constructor(data: RoutePolylineResponse);
+    /**
+     * Gets coordinates in GeoJSON format
+     * @returns Array of coordinates in [longitude, latitude] format
+     */
+    get geoJsonCoordinates(): Position[];
+    /**
+     * Gets coordinates in LatLng format
+     * @returns Array of LatLng coordinates
+     */
+    get coordinates(): LatLng[];
+}
+
+/**
+ * Represents a location on the map.
+ * @group Places & Locations
+ */
+interface MVXLocation extends LatLng {
+    floorId?: string;
+    placeId?: string;
+}
+
+/**
+ * Model parameters of each floor for locations
+ * Represents the configuration and properties of individual floors within a building
+ * @group Places & Locations
+ */
+interface InnerFloor {
+    /**
+     * Unique identifier for the floor
+     */
+    key: string;
+    /**
+     * Numerical index representing the floor's position in the building
+     * Lower numbers typically represent lower floors
+     */
+    index: number;
+    /**
+     * Floor level number (can be negative for basement floors)
+     */
+    level: number;
+    /**
+     * Full name of the floor (e.g., "Ground Floor", "First Floor")
+     */
+    name: string;
+    /**
+     * Abbreviated name of the floor (e.g., "G", "1F", "B1")
+     */
+    shortName?: string;
+    /**
+     * Indicates if this is the default floor to display when entering the building
+     */
+    defaultFloor: boolean;
+    /**
+     * Reference to the base floor identifier (used for relative positioning)
+     */
+    baseFloor?: string;
+    /**
+     * Indicates if this floor can be reached using GPS positioning
+     * Useful for outdoor areas or floors with GPS accessibility
+     */
+    reachableFromGPS?: boolean;
+}
+
+interface Metadata {
+    category?: string[];
+    image?: string;
+    logo?: string;
+    tags?: string[];
+}
+
+/**
+ * Interface that represents the API response for banners.
+ * Contains the data structure as it comes from the server.
+ * @group Places & Locations
+ */
+interface BannerResponse {
+    /**
+     * URL of the banner image
+     */
+    url: string;
+    /**
+     * List of tags associated with the banner for filtering
+     */
+    tags?: string[];
+    /**
+     * Action URL to redirect to when clicking on the banner
+     */
+    url_action: string;
+    /**
+     * Indicates if the banner should open in the same window or a new one
+     */
+    sameLink: boolean;
+    /**
+     * A description of the banner.
+     *
+     * Can contain html tags.
+     */
+    description?: string;
+}
+/**
+ * Class that represents a banner in MapVX.
+ * Contains information about the image, tags, and banner behavior.
+ * @group Places & Locations
+ */
+declare class Banner {
+    /**
+     * URL of the banner image
+     */
+    url: string;
+    /**
+     * List of tags associated with the banner for filtering
+     */
+    tags: string[];
+    /**
+     * Action URL to redirect to when clicking on the banner
+     */
+    urlAction: string;
+    /**
+     * Indicates if the banner should open in the same window or a new one
+     */
+    sameLink: boolean;
+    /**
+     * A description of the banner.
+     *
+     * Can contain html tags.
+     */
+    description?: string;
+    /**
+     * Creates a new banner instance from API response data
+     * @param rawBanner API response data containing banner information
+     */
+    constructor(rawBanner: BannerResponse);
+}
+
+/**
+ * Two-characters string indicator for each day of the week
+ * Represents the standard format for identifying days in the week
+ * @group Places & Locations
+ */
+type DaysOfTheWeek = "mo" | "tu" | "we" | "th" | "fr" | "sa" | "su";
+/**
+ * Object model for indicating a single period of opening time
+ * Represents a time range when a place is open
+ * @group Places & Locations
+ */
+interface OpeningTime {
+    /**
+     * Opening time in 24-hour format (e.g., "09:00")
+     */
+    open: string;
+    /**
+     * Closing time in 24-hour format (e.g., "18:00")
+     */
+    close: string;
+}
+/**
+ * Object model for indicating multiple opening times periods for different days of the week
+ * Maps each day of the week to an array of opening time periods
+ * @group Places & Locations
+ */
+type OpeningHours = {
+    [day in DaysOfTheWeek]: OpeningTime[];
+};
+
+/**
+ * Base interface for all property types that a place can have.
+ * Defines the common fields that all properties must have.
+ * @group Places & Locations
+ */
+interface Property {
+    /**
+     * Title of the property
+     */
+    title: string;
+    /**
+     * Subtitle or description of the property
+     */
+    subtitle: string;
+    /**
+     * URL of the icon associated with the property (optional)
+     */
+    icon?: string;
+    /**
+     * Image URL for the property icon (optional)
+     */
+    imageUrl?: string;
+    /**
+     * Type of property to identify its category
+     */
+    type?: string;
+    /**
+     * Identifier of the parent place of the property (optional)
+     */
+    childParentPlace?: string;
+    /**
+     * URL associated with the property (optional)
+     */
+    url?: string;
+    /**
+     * Icon prefix (defaults to "fas" for Font Awesome)
+     */
+    iconPrefix?: string;
+    /**
+     * Order of the property (optional)
+     */
+    sortChildrenBy?: string;
+}
+/**
+ * Interface that represents the API response for properties.
+ * Contains the data structure as it comes from the server.
+ * @group Places & Locations
+ */
+interface PropertyResponse {
+    /**
+     * Identifying key of the property
+     */
+    key: string;
+    /**
+     * Descriptive text of the property
+     */
+    text: string;
+    /**
+     * URL of the associated icon (optional)
+     */
+    icon?: string;
+    /**
+     * Image URL for the property icon (optional)
+     */
+    imageUrl?: string;
+    /**
+     * Type of property
+     */
+    type?: string;
+    /**
+     * URL associated with the property (optional)
+     */
+    url?: string;
+    /**
+     * List of child places associated with this property
+     */
+    child_places?: PlaceResponse[] | string[];
+    /**
+     * List of nested child properties
+     */
+    child_properties: PropertyResponse[];
+    /**
+     * Identifier of the parent place of the children
+     */
+    child_parent_place?: string;
+    /**
+     * Icon prefix
+     */
+    iconPrefix?: string;
+    /**
+     * Order of properties should be sorted by
+     */
+    sortChildrenBy?: string;
+}
+/**
+ * Interface that represents a transport service associated with a place.
+ * Extends the Property interface with transport-specific fields.
+ * @group Places & Locations
+ */
+interface TransportLine extends Property {
+    /**
+     * Fixed type that identifies this property as a transport line
+     */
+    type: "transport_line";
+    /**
+     * List of available transport lines
+     */
+    lines: string[];
+    /**
+     * Source or provider of the transport service
+     */
+    source: string[] | string;
+}
+
+interface InnerFloorResponse {
+    defaultFloor: boolean;
+    index: number;
+    level: number;
+    name: string;
+    shortName?: string;
+    vectorTile: boolean;
+    reachableFromGPS?: boolean;
+    baseFloor?: string;
+}
+type RawLogo = string | {
+    light: string;
+    dark: string;
+};
+interface PlaceResponse {
+    id: string;
+    title: string;
+    description?: string;
+    shortDescription?: string;
+    lat: number;
+    lng: number;
+    address?: string;
+    category: string;
+    general_category: string;
+    localizedCategory?: string;
+    parent_institution: string;
+    externalId?: string;
+    alias?: string;
+    innerFloors?: {
+        [key: string]: InnerFloorResponse;
+    };
+    inFloor?: string[];
+    hasBeacons: boolean;
+    opening_hours: OpeningHours;
+    properties?: PropertyResponse[];
+    logo?: RawLogo;
+    images?: string[];
+    keywords?: string[];
+    tags?: string[];
+    banners?: BannerResponse[];
+    parent_id: string;
+    parent_type: string;
+    metadata?: Metadata;
+    visibility?: "public" | "protected" | "hidden";
+}
+
+/**
+ * MapVX place object, is a custom object containing data of a specific real place.
+ * Represents a physical location with all its associated metadata and properties.
+ *
+ * @example
+ * ```typescript
+ * const place = new MVXPlace(placeResponse);
+ * console.log(place.title); // "Coffee Shop"
+ * console.log(place.position); // { lat: 40.7128, lng: -74.0060 }
+ * ```
+ *
+ * @group Places & Locations
+ */
+declare class MVXPlace {
+    /**
+     * Unique identifier to reference the place in MapVX system
+     */
+    mapvxId: string;
+    /**
+     * Client-side identifier for the place (optional)
+     * Used for custom identification in client applications
+     */
+    clientId?: string;
+    /**
+     * Title text for the place (localized based on client language)
+     */
+    title: string;
+    /**
+     * Detailed description text for the place (localized based on client language)
+     */
+    description?: string;
+    /**
+     * Short description text for the place (localized based on client language)
+     */
+    shortDescription?: string;
+    /**
+     * Central position coordinates for the place
+     * @see {@link LatLng} for coordinate structure
+     */
+    position: LatLng;
+    /**
+     * Flag to control visibility of the place in search results
+     */
+    hidePlace: boolean;
+    /**
+     * Category identifier for the place
+     */
+    category: string;
+    /**
+     * Localized category name for the place (based on client language)
+     */
+    localizedCategory?: string;
+    /**
+     * General purpose category string for the place (localized)
+     */
+    generalCategory: string;
+    /**
+     * Floors available in the parent place. If this exists, the place is indoor.
+     * Otherwise, the place is considered outdoor.
+     * @see {@link InnerFloor} for floor structure
+     */
+    innerFloors: InnerFloor[];
+    /**
+     * Specific floor identifiers where this place exists (for indoor locations)
+     */
+    inFloors?: string[];
+    /**
+     * Unique identifier of the institution to which this place belongs
+     */
+    parentInstitutionId: string;
+    /**
+     * Business hours when the place is open
+     * @see {@link OpeningHours} for schedule structure
+     */
+    openingHours?: OpeningHours;
+    /**
+     * Physical address of the place in plain text (if provided)
+     */
+    address?: string;
+    /**
+     * Transport services associated with this place
+     * @see {@link TransportLine} for transport service structure
+     */
+    transportLine?: TransportLine[];
+    /**
+     * URL of the place's logo image
+     */
+    logo?: string;
+    /**
+     * List of available image URLs for the place
+     */
+    images: string[];
+    /**
+     * List of available banner images for the place
+     * @see {@link Banner} for banner structure
+     */
+    banners: Banner[];
+    /**
+     * List of properties connected to the place
+     * @see {@link Property} for property structure
+     */
+    properties?: Property[];
+    /**
+     * Unique identifier of the parent place or object
+     */
+    parentId: string;
+    /**
+     * Type of the object being referenced by {@link parentId}
+     */
+    parentType: string;
+    /**
+     * Tags associated with the place for categorization and filtering
+     */
+    tags: string[];
+    /**
+     * Metadata of the place.
+     */
+    metadata?: Metadata;
+    /**
+     * Visibility of the place
+     */
+    visibility: "public" | "protected" | "hidden";
+    /**
+     * Creates a new place instance with the parameters specified in the data.
+     *
+     * @param rawPlace - JSON configuration parameters for the place from API response
+     * @returns A new instance of MVXPlace
+     *
+     * @example
+     * ```typescript
+     * const placeResponse = await fetchPlaceData(placeId);
+     * const place = new MVXPlace(placeResponse);
+     * ```
+     */
+    constructor(rawPlace: PlaceResponse);
+    /**
+     * Returns the floor in which the place exists as an InnerFloor object.
+     * If no matching available floor is found or if the place is not indoor,
+     * an undefined value will be returned.
+     *
+     * @param parentPlaceFloors - Array of existing parent place floors to search in
+     * @returns The matching InnerFloor object or undefined if not found
+     *
+     * @example
+     * ```typescript
+     * const buildingFloors = getBuildingFloors();
+     * const placeFloor = place.inFloor(buildingFloors);
+     * if (placeFloor) {
+     *   console.log(`Place is on floor: ${placeFloor.name}`);
+     * }
+     * ```
+     */
+    inFloor(parentPlaceFloors: InnerFloor[]): InnerFloor | undefined;
+    /**
+     * Returns a string representation of the place
+     * @returns String in format "MVXPlace {mapvxId}"
+     */
+    toString(): string;
+}
+
+interface InstitutionCityFilterOption {
+    institutionId: string;
+    filterId: string;
+    name: string;
+    type: "institution";
+}
+interface ParentPlaceCityFilterOption {
+    parentPlaceId: string;
+    filterId: string;
+    name: string;
+    type: "parent-place";
+    institutionId: string;
+}
+type CityFilterOption = InstitutionCityFilterOption | ParentPlaceCityFilterOption;
+
+interface InstitutionResponse {
+    id: string;
+    title: string;
+    category: string;
+    description?: string;
+    hasPlaces: boolean;
+    icon?: string;
+    country: string;
+    properties?: PropertyResponse[];
+}
+
+/**
+ * MapVX Institution object, is a custom object containing data of conglomerate of places (enterprise or subdivision).
+ * Represents a collection of related places that form a larger organizational unit.
+ *
+ * @example
+ * ```typescript
+ * const institution = new Institution(institutionResponse);
+ * console.log(institution.title); // "Shopping Mall"
+ * console.log(institution.hasPlaces); // true
+ * ```
+ *
+ * @group Places & Locations
+ */
+declare class Institution {
+    /**
+     * Unique identifier for the institution in MapVX system
+     */
+    mapvxId: string;
+    /**
+     * Title or name of the institution
+     */
+    title: string;
+    /**
+     * Detailed description of the institution (optional)
+     */
+    description?: string;
+    /**
+     * Country where the institution is located
+     */
+    country: string;
+    /**
+     * Category or type of the institution
+     */
+    category: string;
+    /**
+     * Flag indicating if the institution contains places
+     */
+    hasPlaces: boolean;
+    /**
+     * List of properties associated with the institution
+     * @see {@link Property} for property structure
+     */
+    properties?: Property[];
+    /**
+     * URL of the institution's icon or logo
+     */
+    icon?: string;
+    /**
+     * Creates a new instance of an Institution object with the rawInstitution arguments.
+     *
+     * @param rawInstitution - JSON configuration parameters for the institution from API response
+     * @returns A new instance of Institution
+     *
+     * @example
+     * ```typescript
+     * const institutionResponse = await fetchInstitutionData(institutionId);
+     * const institution = new Institution(institutionResponse);
+     * ```
+     */
+    constructor(rawInstitution: InstitutionResponse);
+}
+
+/**
+ * Multilanguage object model for different languages
+ * Represents text content that can be displayed in multiple languages
+ * @group Places & Locations
+ */
+interface MultiLanguage {
+    /**
+     * Default language text that will be used if the requested language is not available
+     */
+    default: string;
+    /**
+     * Language-specific text content indexed by language code
+     * Example: { "en": "Hello", "es": "Hola", "default": "Hello" }
+     */
+    [language: string]: string;
+}
+
+/**
+ * Interface that represents the API response for transport services.
+ * Contains both real-time schedules and regular schedules.
+ */
+interface TransportResponse {
+    /**
+     * List of real-time schedules for transport services
+     */
+    realtimeSchedules: RealtimeSchedule[];
+    /**
+     * List of regular schedules for transport services
+     */
+    schedules: Schedule[];
+}
+/**
+ * Interface that represents a real-time schedule of a transport service.
+ * Contains detailed information about a specific route in real-time.
+ * @group Places & Locations
+ */
+interface RealtimeSchedule {
+    /**
+     * Name of the transport route
+     */
+    routeName: string;
+    /**
+     * Informative message about the service status
+     */
+    message: string;
+    /**
+     * Opening hours of the service (optional)
+     */
+    opening_hours?: [];
+    /**
+     * Additional properties of the service (optional)
+     */
+    properties?: [];
+    /**
+     * Name of the current stop
+     */
+    stopName: string;
+    /**
+     * Final destination of the route
+     */
+    finalDestination: string;
+    /**
+     * Origin or source of the service
+     */
+    source: string;
+    /**
+     * URL of the icon associated with the service (optional)
+     */
+    icon?: string;
+    /**
+     * Unique identifier of the vehicle
+     */
+    vehicleId: string;
+    /**
+     * Distance from the current stop in meters
+     */
+    distance: number;
+    /**
+     * Estimated arrival time in text format
+     */
+    estimatedTime: string;
+    /**
+     * Remaining time until arrival in text format
+     */
+    remainingTime: string;
+    /**
+     * Service title in multiple languages
+     */
+    title: MultiLanguage;
+    /**
+     * Indicates if the service is delayed
+     */
+    delayed: boolean;
+    /**
+     * Route direction (outbound or inbound)
+     */
+    routeDirection: string;
+    /**
+     * Route identifier
+     */
+    route: string;
+    /**
+     * Latitude of the vehicle's current location
+     */
+    latitude: number;
+    /**
+     * Longitude of the vehicle's current location
+     */
+    longitude: number;
+    /**
+     * Stop identifier
+     */
+    stopId: string;
+    /**
+     * List of stops associated with this route (optional)
+     */
+    stops?: MVXPlace[];
+}
+/**
+ * Interface that represents a regular schedule of a transport service.
+ * Contains information about fixed schedules of a transport line.
+ * @group Places & Locations
+ */
+interface Schedule {
+    /**
+     * Identifier of the transport line
+     */
+    line: string;
+    /**
+     * Route direction (outbound or inbound)
+     */
+    routeDirection: string;
+    /**
+     * Schedules organized by days of the week
+     */
+    schedule: DaysAndTimes[];
+    /**
+     * Origin or source of the service
+     */
+    source: string;
+    /**
+     * Service title in multiple languages
+     */
+    title: MultiLanguage;
+    /**
+     * Today's schedule in text format
+     */
+    today_schedule: string;
+    /**
+     * Next schedule in text format
+     */
+    next_schedule: string;
+}
+/**
+ * Interface that represents schedules for specific days of the week.
+ * Defines which days and at what times the service operates.
+ * @group Places & Locations
+ */
+interface DaysAndTimes {
+    /**
+     * List of days of the week in abbreviated format (e.g., ["mo", "tu", "we"])
+     */
+    days: string[];
+    /**
+     * List of schedules in text format (e.g., ["08:00", "12:00", "18:00"])
+     */
+    times: string[];
+}
+/**
+ * Class that represents a transport object in MapVX.
+ * Contains both regular schedules and real-time information.
+ * @group Others
+ */
+declare class MVXTransport {
+    /**
+     * List of regular schedules for transport services
+     */
+    schedule: Schedule[];
+    /**
+     * List of real-time routes for transport services
+     */
+    routes: RealtimeSchedule[];
+    /**
+     * Creates a new transport instance with the parameters specified in the response of the endpoint.
+     * @hidden
+     * @param data json parameters for the transport object.
+     * @returns A new instance of MVXTransport is returned.
+     */
+    constructor(data: TransportResponse);
+}
+
+interface InitialData {
+    availablePlaces: PlaceResponse[] | null;
+    institutions: InstitutionResponse[] | null;
+}
+
+interface CurrentLocation {
+    type: 'current-location';
+    title: 'Current location';
+    position: LatLng;
+}
+declare function toCurrentLocation(position: GeolocationPosition): CurrentLocation;
+declare function isCurrentLocation(point: RoutePoint | null): point is CurrentLocation;
+declare function isPlace(point: RoutePoint | null): point is MVXPlace;
+type RoutePoint = MVXPlace | CurrentLocation;
+
+interface FormattedSchedule {
+    day: string;
+    schedule: string[];
+}
+
+interface SearchData {
+    term: string;
+    results: MVXPlace[];
+}
+declare const EMPTY_SEARCH_DATA: SearchData;
+
+interface SelectFilterAction {
+    type: 'select-filter';
+    data: {
+        filter: string;
+    };
+}
+interface ShowPlaceAction {
+    type: 'show-place';
+    data: {
+        placeId: string;
+        alias: string | undefined;
+    };
+}
+interface SelectDestinationAction {
+    type: 'select-destination';
+    data: {
+        destinationId: string;
+        alias: string | undefined;
+    };
+}
+interface SearchAction {
+    type: 'search';
+    data: {
+        searchTerm: string;
+    };
+}
+interface ReturnToHomeAction {
+    type: 'return-to-home';
+    data: {
+        filter: string;
+    };
+}
+type UserAction = SelectFilterAction | ShowPlaceAction | SelectDestinationAction | SearchAction | ReturnToHomeAction;
+
+declare function isDealOrEventBanner(banner: Banner): boolean;
+declare function extractBannerColor(description: string): string;
+
+declare const FALLBACK_IMAGE_URL = "https://images.ctfassets.net/37yx0l0lf3yk/6eJ4fYG9hQxJ8ayujcebhe/8cf968e7d66df9a8bc75b72b7e7d6432/00002167_BedrockWebsite_TenantCOmingSoon_PlaceholderImage_3840x3840_V2-web.jpg?q=80&fm=webp&w=1920";
+declare const MEASUREMENT_ID = "G-9KB6BB1J7M";
+
+/**
+ * Get the currentschedule of the store as a string.
+ * @param openingHours Opening hours of the store.
+ * @returns The schedule of the store.
+ */
+declare function getSchedule(openingHours: OpeningHours): string;
+declare function prepareAllSchedules(openingHours: OpeningHours): FormattedSchedule[];
+
+export { AnimationState, Banner, EMPTY_SEARCH_DATA, FALLBACK_IMAGE_URL, Institution, MEASUREMENT_ID, MVXPlace, MVXRoute, MVXRouteLeg, MVXRouteStep, MVXTransport, extractBannerColor, getSchedule, isCurrentLocation, isDealOrEventBanner, isPlace, prepareAllSchedules, toCurrentLocation };
+export type { CategoryFiltersData, CityFilterOption, CurrentLocation, DaysOfTheWeek, FormattedSchedule, InitialData, InnerFloor, InstitutionResponse, LatLng, MVXLocation, OpeningHours, OpeningTime, PlaceResponse, Property, ReturnToHomeAction, RoutePoint, SearchAction, SearchData, SelectDestinationAction, SelectFilterAction, ShowPlaceAction, UserAction };