venue-js 1.0.0-0

package/dist/index.d.ts

@@ -0,0 +1,1158 @@
+import { QueryClient, QueryObserver, EnsureQueryDataOptions } from '@tanstack/query-core';
+export { QueryObserver } from '@tanstack/query-core';
+import * as geojson from 'geojson';
+import { Position, Geometry, GeoJsonProperties, Feature, Point, Polygon, MultiPolygon, LineString, GeometryCollection } from 'geojson';
+import * as maptalks from 'maptalks';
+import { Coordinate, Map, MapAnimationOptionsType, MapViewType, HandlerFn, EventParams, MapPaddingType, Extent, Marker, ui, LineString as LineString$1, Polygon as Polygon$1, MultiPolygon as MultiPolygon$1, MultiLineString } from 'maptalks';
+import { ThreeLayer, BaseObject } from 'maptalks.three';
+import { ExtrudePolygonOptionType } from 'maptalks.three/dist/type';
+import { SpriteMaterial, AmbientLight, DirectionalLight } from 'three';
+
+type Id = string;
+type MediaFile = {
+    ext: string;
+    hash: string;
+    height: number;
+    mime: string;
+    name: string;
+    path: string | null;
+    size: number;
+    url: string;
+    width: number;
+};
+type Media = MediaFile & {
+    id: Id;
+    alternativeText: string | null;
+    caption: string | null;
+    createdAt: string;
+    ext: string;
+    folderPath: string;
+    formats: Record<string, MediaFile>;
+    previewUrl: string | null;
+    provider: string;
+    provider_metadata: string | null;
+    updatedAt: string;
+};
+type Model3d = {
+    id: Id;
+    name: string;
+    properties: {
+        position: Position;
+        rotation: {
+            x: number;
+            y: number;
+            z?: number;
+        };
+        scale: [number, number, number];
+        url: string;
+    };
+};
+type EntityTimestamps = {
+    createdAt: string;
+    updatedAt: string;
+    publishedAt: string;
+};
+type SymbolProperties = {
+    lineColor?: string;
+    lineWidth?: string;
+    lineDasharray?: string;
+    lineOpacity?: string;
+    lineJoin?: string;
+    lineCap?: string;
+    linePatternFile?: string;
+    lineDx?: string;
+    lineDy?: string;
+    polygonFill?: string;
+    polygonOpacity?: string;
+    polygonPatternFile?: string;
+};
+type TransalatableString = Record<string, string>;
+type ImdfFeature<G extends Geometry | null = Geometry, P = GeoJsonProperties> = Feature<G, P> & {
+    id: Id;
+    feature_type: string;
+};
+type AnchorGeometry = Point;
+type AnchorProperties = EntityTimestamps & {
+    address_id: Id | null;
+    unit_id: Id;
+    locale: string;
+};
+type AnchorFeature = ImdfFeature<AnchorGeometry, AnchorProperties>;
+type AmenityGeometry = Point;
+type AmenityProperties = EntityTimestamps & {
+    amenity_logo: Media | null;
+    category: string;
+    description: TransalatableString | null;
+    gallery: Media[];
+    isNavigatable: boolean;
+    is_featured: boolean;
+    level_id: Id;
+    location_description: string;
+    logo: Media | null;
+    name: TransalatableString | null;
+    style: unknown;
+    unit_ids: Id[];
+    venue_id: Id;
+};
+type AmenityFeature = ImdfFeature<AmenityGeometry, AmenityProperties> & {
+    feature_type: "amenity";
+};
+type DetailGeometry = Point;
+type DetailProperties = {
+    level_id: Id;
+    [k: string]: any;
+};
+type DetailFeature = ImdfFeature<DetailGeometry, DetailProperties>;
+type FixtureGeometry = Point;
+type FixtureProperties = EntityTimestamps & {
+    anchor_id: Id | null;
+    category: string;
+    is_landmark: boolean;
+    level_id: Id;
+    locale: string;
+    model3d: Model3d[];
+    name: string | null;
+    style: SymbolProperties;
+    venue_id: Id;
+    [k: string]: any;
+};
+type FixtureFeature = ImdfFeature<FixtureGeometry, FixtureProperties>;
+type KioskGeometry = Polygon | MultiPolygon;
+type KioskProperties = EntityTimestamps & {
+    alt_name: string;
+    anchor_id: Id;
+    is_landmark: boolean;
+    level_id: Id;
+    locale: string;
+    model3d: Model3d[];
+    name: TransalatableString;
+    style: SymbolProperties;
+    venue_id: Id;
+};
+type KioskFeature = ImdfFeature<KioskGeometry, KioskProperties>;
+type LevelGeometry = Polygon | MultiPolygon;
+type LevelProperties = EntityTimestamps & {
+    alt_name: string | null;
+    display_point: Point;
+    name: TransalatableString;
+    ordinal: number;
+    properties: unknown;
+    venue_id: Id;
+};
+type LevelFeature = ImdfFeature<LevelGeometry, LevelProperties>;
+type OccupantGeometry = null;
+type OccupantProperties = EntityTimestamps & {
+    anchor_id: Id;
+    category: string;
+    cover_image: Media | null;
+    description: TransalatableString;
+    featured_image: Media | null;
+    gallery: Media[] | null;
+    group_ids: Id[];
+    hours: string;
+    is_featured: boolean;
+    is_landmark: boolean;
+    is_maintenance: boolean;
+    keywords: string[];
+    kiosk_id: Id | null;
+    local_category_ids: Id[];
+    logo: Media | null;
+    maintenance_end_date: string | null;
+    maintenance_start_date: string | null;
+    name: TransalatableString;
+    phone: string | null;
+    privilege_ids: Id[];
+    promotion_ids: Id[];
+    render_priority: number;
+    render_type: string;
+    room_no: string | null;
+    short_name: string | null;
+    start_date: string;
+    style: SymbolProperties | null;
+    temp_anchor_id: Id | null;
+    temp_kiosk_id: Id | null;
+    temp_unit_id: Id | null;
+    unit_id: Id | null;
+    venue_id: Id;
+    kiosk_ids: Id[];
+    unit_ids: Id[];
+    website_link: string | null;
+};
+type OccupantFeature = ImdfFeature<OccupantGeometry, OccupantProperties>;
+type OpeningGeometry = LineString;
+type OpeningProperties = EntityTimestamps & {
+    alt_name: string;
+    category: string;
+    door: {
+        type: string;
+    };
+    level_id: Id;
+    name: TransalatableString;
+    style: SymbolProperties;
+    venue_id: Id;
+};
+type OpeningFeature = ImdfFeature<OpeningGeometry, OpeningProperties>;
+type RelationshipGeometry = Geometry | null;
+type RelationshipProperties = EntityTimestamps & {
+    category: string;
+    destination: {
+        id: Id;
+        feature_type: FeatureType;
+    };
+    direction: string;
+    hours: string | null;
+    intermediary: {
+        id: Id;
+        feature_type: FeatureType;
+    }[];
+    locale: string;
+    name: TransalatableString;
+    origin: {
+        id: Id;
+        feature_type: FeatureType;
+    };
+};
+type RelationshipFeature = ImdfFeature<RelationshipGeometry, RelationshipProperties>;
+type SectionGeometry = Polygon | MultiPolygon;
+type SectionProperties = EntityTimestamps & {
+    venue_id: Id;
+    level_id: Id;
+    correlation_id: Id | null;
+    category: string;
+    ordinal: number;
+    imdf_category: string;
+    [k: string]: any;
+};
+type SectionFeature = ImdfFeature<SectionGeometry, SectionProperties>;
+type UnitGeometry = Polygon | MultiPolygon;
+type UnitProperties = EntityTimestamps & {
+    alt_name: string | null;
+    category: string;
+    is_landmark: boolean;
+    level_id: Id;
+    locale: string;
+    model3d: Model3d[];
+    name: TransalatableString;
+    style: SymbolProperties;
+    venue_id: Id;
+};
+type UnitFeature = ImdfFeature<UnitGeometry, UnitProperties>;
+type VenueGeometry = Polygon | MultiPolygon;
+type VenueProperties = EntityTimestamps & {
+    address: string;
+    address_id: Id | null;
+    country: string;
+    display_point: Point;
+    hours: string;
+    imdf_category: string;
+    locale: string;
+    locality: string;
+    logo: Media | null;
+    logo_simple: Media | null;
+    model3d: Model3d[];
+    name: TransalatableString;
+    phone: string;
+    postal_code: string;
+    province: string;
+    reference: string;
+    style: SymbolProperties | null;
+    supported_locales: string[];
+    theme_color: string;
+    zoom: string | null;
+};
+type VenueFeature = ImdfFeature<VenueGeometry, VenueProperties>;
+/**
+ * Non-IMDF
+ *********************** */
+type TaxonomyGeometry = null;
+type TaxonomyProperties = EntityTimestamps & {
+    description: string;
+    icon_image: string;
+    icon_path: string;
+    is_featured: boolean;
+    local_id: string;
+    locale: string;
+    name: TransalatableString;
+    order: number;
+    parent_id: Id | null;
+    reference: string;
+    taxonomy: string;
+    venue_id: Id | null;
+};
+type TaxonomyFeature = ImdfFeature<TaxonomyGeometry, TaxonomyProperties>;
+type EventGeometry = Polygon;
+type EventProperties = {
+    name: string;
+    ordinal: number;
+    venue_id: Id;
+    angle: number;
+    fontSize: number;
+};
+type EventFeature = ImdfFeature<EventGeometry, EventProperties>;
+type PromotionProperties = {
+    name: TransalatableString;
+    category: string;
+    cover_image: Media;
+    daily_end_time: string;
+    daily_start_time: string;
+    description: TransalatableString;
+    end_date: string;
+    feature_id: string | null;
+    gallery: Media[];
+    is_featured: boolean;
+    local_category_ids: string[];
+    locale: string;
+    publishedAt: string;
+    start_date: string;
+    updatedAt: string;
+    venue_id: Id;
+    website_link: string | null;
+};
+type PromotionFeature = ImdfFeature<null, PromotionProperties>;
+type PrivilegeGeometry = null;
+type PrivilegeProperties = {
+    createdAt: string;
+    description: TransalatableString;
+    locale: string;
+    occupant_id: Id;
+    publishedAt: string;
+    updatedAt: string;
+    venue_id: Id;
+};
+type PrivilegeFeature = ImdfFeature<PrivilegeGeometry, PrivilegeProperties>;
+type LabelGeometry = {
+    geometry_type: string;
+    cooordinates: Position[][];
+};
+type LabelProperties = {
+    name: string;
+    ordinal: number;
+    venue_id: Id;
+    angle: number;
+    fontSize: number;
+};
+type LabelFeature = {
+    type: "Feature";
+    geometry: LabelGeometry;
+    id: Id;
+    properties: LabelProperties;
+};
+type ElementGeometry = null;
+type ElementProperties = EntityTimestamps & {
+    geometries: Array<{
+        type: string;
+        id: Id;
+        geometry: Exclude<Geometry, GeometryCollection>;
+        options: Record<string, unknown>;
+        properties: {
+            additionalField: string;
+            name: string | null;
+            image: Media | null;
+            ordinal: number;
+        };
+    }>;
+    locale: string;
+    name: TransalatableString;
+};
+type ElementFeature = ImdfFeature<ElementGeometry, ElementProperties>;
+/**
+ * Sponsored Content
+ */
+type SponsoredContentLegacyType = "HOMEPAGE_SPOTLIGHT" | "SCREENSAVER" | "SUGGESTED_BRAND" | "SEARCH_RESULT" | "POPUP_BANNER" | "FOOTER_BANNER" | "RECOMMENDED_EVENT" | "RECOMMENDED_PROMOTION" | "RECOMMENDED_DIRECTORY";
+type SponsoredContentPlacementType = "HOMEPAGE_SPOTLIGHT" | "SEARCH_SUGGESTION" | "SEARCH_RESULT" | "LIST_TOPITEM" | "POPUP_BANNER" | "FOOTER_BANNER";
+type SponsoredContentAttributes = {
+    venue_id: string;
+    project_id: string;
+    name: {
+        en: string;
+    };
+    type: SponsoredContentLegacyType;
+    placement_type: SponsoredContentPlacementType;
+    start_date: string;
+    end_date: string;
+    daily_start_time: string;
+    daily_end_time: string;
+    order: number;
+    url: string | null;
+    feature_id: string | null;
+    createdAt: string;
+    updatedAt: string;
+    publishedAt: string;
+    media?: Media;
+    locale: string;
+};
+type SponsoredContentStrapiV4ApiResponse = {
+    id: string;
+    attributes: SponsoredContentAttributes;
+};
+/** Parsed for internal use */
+type SponsoredContentFeature = SponsoredContentAttributes & {
+    id: string;
+};
+type Page = {
+    id: Id;
+    attributes: Record<string, unknown>;
+};
+type FeatureResponseMap = {
+    address: ImdfFeature;
+    amenity: AmenityFeature;
+    anchor: AnchorFeature;
+    building: ImdfFeature;
+    detail: DetailFeature;
+    fixture: FixtureFeature;
+    footprint: ImdfFeature;
+    geofence: ImdfFeature;
+    kiosk: KioskFeature;
+    level: LevelFeature;
+    occupant: OccupantFeature;
+    opening: OpeningFeature;
+    relationship: RelationshipFeature;
+    section: SectionFeature;
+    unit: UnitFeature;
+    venue: VenueFeature;
+    taxonomy: TaxonomyFeature;
+    privilege: PrivilegeFeature;
+    event: EventFeature;
+    promotion: PromotionFeature;
+    label: LabelFeature;
+    element: ElementFeature;
+    "sponsored-content": SponsoredContentFeature;
+    page: Page;
+};
+type FeatureType = keyof FeatureResponseMap;
+type PolygonalFeature = UnitFeature | KioskFeature | LevelFeature | SectionFeature;
+
+type AmenityFeaturePopulated = AmenityFeature & {
+    properties: AmenityFeature["properties"] & {
+        /**
+         * [IMDF] Unit(s) the Amenity is associated with
+         */
+        units: UnitFeaturePopulated[];
+        /**
+         * [venue.in.th] Venue that kiosk is in
+         */
+        venue: VenueFeaturePopulated;
+        /**
+         * [Derived] From units[0] --> level's ordinal
+         * This is added during feature enrichment and not part of the original IMDF dataset.
+         */
+        ordinal: number;
+        /**
+         * [Derived] From units[0] --> level's name
+         * This is added during feature enrichment and not part of the original IMDF dataset.
+         */
+        level_name: string;
+        /**
+         * [Derived] The section this amenity is on.
+         * This is added during feature enrichment and not part of the original IMDF dataset.
+         */
+        section?: SectionFeaturePopulated;
+        /**
+         * [Experimental | Derived] The kiosk this amenity is on.
+         * This is added during feature enrichment and not part of the original IMDF dataset.
+         */
+        _experimental_kiosk?: KioskFeaturePopulated;
+    };
+};
+type AnchorFeaturePopulated = AnchorFeature & {
+    properties: AnchorFeature["properties"] & {
+        /**
+         * [IMDF] The unit this anchor is on.
+         */
+        unit: UnitFeaturePopulated;
+        /**
+         * [IMDF] Level that kiosk is on
+         */
+        level: LevelFeaturePopulated;
+        /**
+         * [Derived] The section this anchor is on.
+         * This is added during feature enrichment and not part of the original IMDF dataset.
+         */
+        section?: SectionFeaturePopulated;
+    };
+};
+type KioskFeaturePopulated = KioskFeature & {
+    properties: KioskFeature["properties"] & {
+        /**
+         * [IMDF] An Occupant MUST be positioned (via Anchor) within a Kiosk that models a space that is leased to a business entity
+         */
+        anchor: AnchorFeaturePopulated;
+        /**
+         * [IMDF] Level that kiosk is on
+         */
+        level: LevelFeaturePopulated;
+        /**
+         * [venue.in.th] Venue that kiosk is in
+         */
+        venue: VenueFeaturePopulated;
+        /**
+         * [Derived] The unit this kiosk is on, usually a walkway.
+         * This is added during feature enrichment and not part of the original IMDF dataset.
+         */
+        unit: UnitFeaturePopulated;
+        /**
+         * [Derived] The section this kiosk is in
+         * This is added during feature enrichment and not part of the original IMDF dataset.
+         */
+        section?: SectionFeaturePopulated;
+    };
+};
+type LevelFeaturePopulated = LevelFeature & {
+    properties: LevelFeature["properties"] & {
+        /**
+         * [venue.in.th] Venue that level is in
+         */
+        venue: VenueFeaturePopulated;
+    };
+};
+type OccupantFeaturePopulated = OccupantFeature & {
+    properties: OccupantFeature["properties"] & {
+        /**
+         * [IMDF] Occupant's position
+         */
+        anchor: AnchorFeaturePopulated;
+        /**
+         * [venue.in.th] Occupant's category
+         */
+        local_categories: TaxonomyFeaturePopulated[];
+        /**
+         * [venue.in.th] Bind correlation between units on an occupant,
+         * which will be used for highlighting in the floor plan and
+         * displaying location details later.
+         */
+        units: UnitFeaturePopulated[];
+        /**
+         * [venue.in.th] Bind correlation between kiosks on an occupant,
+         * which will be used for highlighting in the floor plan and
+         * displaying location details later.
+         */
+        kiosks: KioskFeaturePopulated[];
+        /**
+         * [venue.in.th] Venue that level is in
+         */
+        venue: VenueFeaturePopulated;
+        /**
+         * [venue.in.th] Occupant's promotions
+         */
+        promotions: PromotionFeature[];
+        /**
+         * [venue.in.th] Occupant's privileges
+         */
+        privileges: PrivilegeFeature[];
+    };
+};
+type SectionFeaturePopulated = SectionFeature & {
+    properties: SectionFeature["properties"] & {
+        /**
+         * [IMDF] Level that section is on
+         */
+        level: LevelFeaturePopulated;
+        /**
+         * [venue.in.th] Venue that level is in
+         */
+        venue: VenueFeaturePopulated;
+        /**
+         * [Derived] Level's ordinal that unit is on
+         */
+        ordinal: number;
+    };
+};
+type UnitFeaturePopulated = UnitFeature & {
+    properties: UnitFeature["properties"] & {
+        /**
+         * [IMDF] Level that unit is on
+         */
+        level: LevelFeaturePopulated;
+        /**
+         * [venue.in.th] Venue that level is in
+         */
+        venue: VenueFeaturePopulated;
+        /**
+         * [Derived] Level's ordinal that unit is on
+         */
+        ordinal: number;
+        /**
+         * [Derived] Secion that unit is in
+         */
+        section?: SectionFeaturePopulated;
+    };
+};
+type VenueFeaturePopulated = VenueFeature;
+type TaxonomyFeaturePopulated = TaxonomyFeature & {
+    properties: TaxonomyFeature["properties"] & {
+        venue: VenueFeaturePopulated;
+    };
+};
+type FeaturePopulatedResponseMap = {
+    address: ImdfFeature;
+    amenity: AmenityFeaturePopulated;
+    anchor: AnchorFeaturePopulated;
+    building: ImdfFeature;
+    detail: DetailFeature;
+    fixture: FixtureFeature;
+    footprint: ImdfFeature;
+    geofence: ImdfFeature;
+    kiosk: KioskFeaturePopulated;
+    level: LevelFeaturePopulated;
+    occupant: OccupantFeaturePopulated;
+    opening: OpeningFeature;
+    relationship: RelationshipFeature;
+    section: SectionFeaturePopulated;
+    unit: UnitFeaturePopulated;
+    venue: VenueFeaturePopulated;
+    taxonomy: TaxonomyFeaturePopulated;
+    privilege: PrivilegeFeature;
+    event: EventFeature;
+    promotion: PromotionFeature;
+    label: LabelFeature;
+    element: ImdfFeature;
+    "sponsored-content": SponsoredContentFeature;
+    page: Page;
+};
+type PopulatableFeatureType = keyof FeaturePopulatedResponseMap;
+
+interface VenueClientOptions {
+    projectId: string;
+    apiKey: string;
+    baseUrl?: string;
+    queryClient?: QueryClient;
+}
+interface FindParams {
+    populate?: boolean;
+}
+interface FilterParams {
+    populate?: boolean;
+}
+interface PopulatedParams {
+    populate: true;
+}
+interface FeatureQueryOptions {
+    refetchInterval?: number;
+    staleTime?: number;
+    cacheTime?: number;
+    enabled?: boolean;
+    retry?: boolean | number;
+}
+type InternalFindById = <T extends FeatureType>(id: Id) => Promise<FeatureResponseMap[T]>;
+type InternalFilterByType = <T extends FeatureType>(featureType: T) => Promise<FeatureResponseMap[T][]>;
+interface VenueDataClient {
+    projectId: string;
+    queryClient: QueryClient;
+    registerObserver: (featureType: FeatureType, refetchInterval: number) => QueryObserver;
+    destroyObservers: () => void;
+    createFilterByTypeQueryOptions: <T extends FeatureType = FeatureType>(featureType: T, params: FilterParams, options: FeatureQueryOptions) => EnsureQueryDataOptions<FeatureResponseMap[T][] | FeaturePopulatedResponseMap[T][]>;
+    createFindByIdQueryOptions: <T extends FeatureType = FeatureType>(featureType: T, id: string, params: FindParams, options: FeatureQueryOptions) => EnsureQueryDataOptions<FeatureResponseMap[T] | FeaturePopulatedResponseMap[T]>;
+    filterByType: <T extends FeatureType>(featureType: T, params?: FilterParams) => Promise<FeatureResponseMap[T][] | FeaturePopulatedResponseMap[T][]>;
+    findById: <T extends FeatureType>(featureType: T, id: string, params?: FindParams) => Promise<FeatureResponseMap[T] | FeaturePopulatedResponseMap[T]>;
+}
+
+declare const DEFAULT_BASE_URL = "https://service.venue.in.th/api";
+declare const IMDF_FEATURE_TYPES: FeatureType[];
+declare const NONIMDF_FEATURE_TYPES: FeatureType[];
+declare const GEOJSON_FEATURE_TYPES: FeatureType[];
+declare const ALL_FEATURE_TYPES: FeatureType[];
+declare const defaultFeatureQueryOptionsMap: Record<FeatureType, FeatureQueryOptions>;
+
+declare function fetchFeature<T extends FeatureType = FeatureType>(projectId: string, apiKey: string, featureType: FeatureType, baseUrl?: string): Promise<FeatureResponseMap[T][]>;
+declare const safeFetchFeature: <T extends FeatureType = FeatureType>(projectId: string, apiKey: string, featureType: FeatureType, baseUrl?: string) => Promise<FeatureResponseMap[T][]>;
+
+declare const getDataClient: (options: VenueClientOptions) => VenueDataClient;
+
+/** 2D */
+type TypeRenderOptions<TOptionsType> = {
+    default: TOptionsType;
+    byCategory?: Record<string, TOptionsType>;
+};
+type Element2DRendererOptions = {
+    unit?: TypeRenderOptions<maptalks.PolygonOptionsType>;
+    kiosk?: TypeRenderOptions<maptalks.PolygonOptionsType>;
+    door?: TypeRenderOptions<maptalks.LineStringOptionsType>;
+    occupant?: TypeRenderOptions<maptalks.UIMarkerOptionsType>;
+};
+/** 3D */
+type CreateExtrudePolygonOptionType = ExtrudePolygonOptionType & {
+    color?: string;
+    offset?: number;
+};
+type Element3DRendererOptions = {
+    unit?: TypeRenderOptions<CreateExtrudePolygonOptionType>;
+    kiosk?: TypeRenderOptions<CreateExtrudePolygonOptionType>;
+};
+/** RendererManager */
+type RendererManagerOptions = {
+    type: "2D";
+    elements: Element2DRendererOptions;
+} | {
+    type: "3D";
+    elements: Element3DRendererOptions;
+};
+
+declare class RendererManager {
+    #private;
+    options: RendererManagerOptions;
+    /** Elements: Responsible for converting feature info elements and add to map */
+    private elementRenderer;
+    private elementsMap;
+    private elementsByOrdinal;
+    constructor(map: maptalks.Map, options: RendererManagerOptions);
+    set dataClient(value: any);
+    changeLevelByOrdinal(targetOrdinal: null | number | number[]): void;
+    createMarker(coordinate: Position, ordinal: number, label: string): void;
+}
+
+interface IndoorMapOptions {
+    center?: [number, number];
+    defaultZoom?: number;
+    pixelRatio?: number;
+    locale?: string;
+    onMapReady?: () => void;
+    onMapLoading?: () => void;
+    dataClient: VenueDataClient;
+    renderer?: RendererManagerOptions;
+}
+type AmenityHighlightMode = "2DMarker";
+type SymbolSet = string | null;
+interface IHighlightOptions {
+    symbolSet?: SymbolSet;
+}
+interface ISetHighlight2DElementIdsOptions {
+    symbolSet?: SymbolSet;
+    defaultMarker?: boolean;
+}
+interface ISetHighlightElementIdsOptions {
+    highlight3DOptions?: IHighlightOptions;
+    highlight2DOptions?: ISetHighlight2DElementIdsOptions;
+}
+interface IMapExtrudeConfig {
+    height: number;
+    category: string;
+}
+interface ILightConfig {
+    ambientLight: IMapLightConfig;
+    directionalLight: IMapLightConfig;
+}
+interface IMapLightConfig {
+    color: string;
+    position?: number[];
+    intensity: number;
+}
+interface IExtrudeConfig {
+    kiosk: IMapExtrudeConfig[];
+    unit: IMapExtrudeConfig[];
+}
+interface IShortestPathConfig {
+    resolution: number;
+}
+interface IAllVenuesViewConfig {
+    zoom?: number;
+    pitch?: number;
+    center?: Coordinate;
+    bearing?: number;
+}
+interface IMapAnimation {
+    [k: string]: {
+        enable?: boolean;
+        speed?: number;
+    };
+}
+interface IUnitDistanceModifier {
+    [k: string]: number;
+}
+type IGraphOptions = {
+    baseDistance?: number;
+    multiplier?: number;
+};
+type IVerticalGraphOptions = IGraphOptions & {
+    scaleDistanceByLevel?: boolean;
+};
+interface IGraphFeatureOptions {
+    traversal?: IUnitDistanceModifier;
+    escalator?: IGraphOptions;
+    ramp?: IGraphOptions;
+    elevator?: IGraphOptions;
+    stairs?: IVerticalGraphOptions;
+}
+interface IMapConfig {
+    amenity_highlight_mode?: AmenityHighlightMode;
+    default_zoom?: number;
+    max_zoom?: number;
+    min_zoom?: number;
+    kiosk_pixel_ratio?: number;
+    mobile_pixel_ratio?: number;
+    extrude?: IExtrudeConfig;
+    light?: ILightConfig;
+    shortest_path?: IShortestPathConfig;
+    text_marker_type?: "marker" | "ui-marker";
+    extent_features_scale_factor?: number;
+    extent_scale_map_view_factor?: number;
+    all_venues_view?: IAllVenuesViewConfig;
+    animations?: IMapAnimation[];
+    prepare_steps?: IGraphFeatureOptions;
+}
+
+interface CameraManagerOptions {
+    defaultCenter: [number, number];
+    defaultZoom: number;
+}
+declare class CameraManager {
+    #private;
+    map: Map;
+    constructor(map: Map, { defaultCenter, defaultZoom }: CameraManagerOptions);
+    set defaultBearing(value: number);
+    set defaultPitch(value: number);
+    set defaultCenter(value: [number, number]);
+    set defaultZoom(value: number);
+    get defaultCenter(): [number, number];
+    get defaultZoom(): number;
+    get defaultBearing(): number;
+    get defaultPitch(): number;
+    getBearing: () => number;
+    getPitch: () => number;
+    getZoom: () => number;
+    setBearing: (bearing: any) => Map;
+    /** Public methods */
+    flyTo: (center: any, options?: MapAnimationOptionsType & MapViewType) => void;
+    flyToAndZoomIn: (centerPoint: any, options?: MapAnimationOptionsType & MapViewType) => void;
+}
+
+declare class IndoorMap {
+    #private;
+    map: Map | null;
+    cameraManager: CameraManager;
+    rendererManager: RendererManager;
+    showVenueObject: boolean;
+    threeLayer: ThreeLayer | null;
+    onMapReady: () => void;
+    onMapLoading: () => void;
+    constructor(elementId: any, options: IndoorMapOptions);
+    set dataClient(value: any);
+    /**
+     * Events
+     */
+    handleMapClick: HandlerFn;
+    handleMapTouchEnd: HandlerFn;
+    /**
+     * Getters & Setters
+     */
+    set defaultBearing(value: number);
+    set defaultPitch(value: number);
+    set defaultCenter(value: [number, number]);
+    set defaultZoom(value: number);
+    get defaultBearing(): number;
+    get defaultPitch(): number;
+    get defaultCenter(): [number, number];
+    get defaultZoom(): number;
+    get elementsLoaded(): boolean;
+    get pixelRatio(): number;
+    get locale(): string;
+    set mapTheme(value: any);
+    get venues(): any[];
+    set detectVenueInView(value: any);
+    get ordinals(): any[];
+    set ordinals(value: any[]);
+    set billboards(value: any);
+    set mapConfig(value: IMapConfig);
+    set mapDecorations(value: any);
+    set maxZoom(value: number);
+    set minZoom(value: number);
+    set groundLabels(value: any);
+    set pixelRatio(value: number);
+    set onClickElement(func: any);
+    set locale(value: string);
+    handleClickElement: (e: EventParams) => void;
+    setCenter(center: Coordinate, padding?: MapPaddingType): void;
+    /**
+     * Change Level & animate to path / geometry / view / etc.
+     * ================================== */
+    changeLevelByOrdinal(ordinal: number | number[]): void;
+    getFeatureExtent: (feature: any, scaleFactor?: number) => Extent;
+    getExtentCenter: (extent: Extent) => maptalks.PositionType;
+    getExtentZoom: (extent: Extent, options?: {
+        isFraction?: boolean;
+        padding?: MapPaddingType;
+    }) => number;
+    findVenueInView: () => {
+        venueId: string;
+        distance: number;
+    };
+    flyTo: (center: any, options: any) => void;
+    getLineStringBearing: (feature: any) => number;
+    addAnimations(animation: {
+        id: string;
+        callback: () => void;
+    }): void;
+    removeAnimationById(id: string): void;
+    clearAnimations(): void;
+    /**
+     * Hilighting Elements
+     * ========================================= */
+    setHighlightElementIds(targetElementIds: any, options?: ISetHighlightElementIdsOptions): geojson.FeatureCollection<geojson.Geometry, {
+        [name: string]: any;
+    }>;
+    setHighlight2DElementIds(targetElementIds: any, options?: {}): geojson.FeatureCollection<geojson.Geometry, {
+        [name: string]: any;
+    }>;
+    clearHighlightElements(): void;
+    setHighlightedObject(targetObjectIds: any, options?: {}): void;
+    clearHighlightObject(): void;
+    /**
+     * User Location
+     ****************************/
+    addUserLocation(value: any): void;
+    updateUserLocationSymbolByLocale(locale: string): void;
+    removeUserLocation(): void;
+    showUserLocationMarker(): void;
+    hideUserLocationMarker(): void;
+    addLastUserLocation(value: any): void;
+    removeLastUserLocation(): void;
+    hideLastUserLocationMarker(): void;
+    /**
+     * END of User Location
+     ****************************/
+    showGeometryByElementId: (elementId: any) => void;
+    hideGeometryByElementId: (elementId: any) => void;
+    setSpriteMarkersOpacity: (opacity?: number) => void;
+    setFeatureObject3DsOpacity: (opacity?: number) => void;
+    disableLayersFadingOnZoom: () => void;
+    enableLayersFadingOnZoom: () => void;
+    /**
+     * Navigation
+     ****************************/
+    combineNearbyLineStrings(lineStrings: Feature<LineString, GeoJsonProperties>[], options?: {
+        properties?: GeoJsonProperties;
+        distance?: number;
+    }): any[];
+    createNavigationGeometries: (stepGeometries: any, destinationFeature: any) => void;
+    createOverviewStepPathByOrdinal: (stepGeometries: any, viewingOrdinal: any) => any;
+    clearNavigationGeometries(): void;
+    /**
+     * END of Navigation
+     ****************************/
+    /**
+     * hide/show venue 3dmodel
+     **/
+    hideVenueObjects: () => void;
+    showVenueObjects: () => void;
+    /**
+     * Other functions
+     */
+    enableClick: () => Map | maptalks.ClassOptions;
+    disableClick: () => Map | maptalks.ClassOptions;
+    freeze: () => Map | maptalks.ClassOptions;
+    unfreeze: () => Map | maptalks.ClassOptions;
+    /**
+     * render (frame)
+     */
+    getTargetViewCenter: (targetView: any, options?: {
+        offset: {
+            top: number;
+            left: number;
+            right: number;
+            bottom: number;
+        };
+    }) => Coordinate;
+    setMaxExtent(extent: Extent): Map;
+    render(): void;
+}
+
+declare class Billboard extends BaseObject {
+    constructor(coordinate: any, options: any, src: any, layer: any, properties: any);
+    properties: any;
+    setLineHeight(altitude: any): void;
+    #private;
+}
+
+declare class GroundLabel extends BaseObject {
+    #private;
+    constructor(bound: any, options: any, layer: any);
+    set bearing(value: any);
+    get angle(): number;
+    get currentAngle(): number;
+    get text(): string;
+    get offsetX(): number;
+    get offsetY(): number;
+    get offset(): {
+        x: number;
+        y: number;
+    };
+    set offsetX(value: number);
+    set offsetY(value: number);
+    set angle(newAngle: number);
+    setOffset(offsetX: any, offsetY: any): void;
+    addOffset(deltaX: any, deltaY: any): void;
+    resetOffset(): void;
+    moveToPosition(targetX: any, targetY: any): void;
+    updateText(newText: any, options?: Record<string, unknown>): void;
+}
+
+interface IOptions {
+    scale: number;
+    altitude: number;
+    alphaTest?: number;
+    highlight?: {
+        options: {
+            altitude?: number;
+            scale?: number;
+        };
+        material?: SpriteMaterial;
+    };
+}
+declare class SpriteMarker extends BaseObject {
+    #private;
+    constructor(coordinate: any, options: IOptions, material: SpriteMaterial, layer: ThreeLayer, properties: object);
+    setSymbol(material: SpriteMaterial): this;
+    setScale(scaleX: number, scaleY?: number, scaleZ?: number): this;
+    getSymbol(): SpriteMaterial;
+    highlight(): this;
+    removeHighlight(): this;
+}
+
+declare class NavigationPath extends BaseObject {
+    constructor(feature: any, layer: any, properties: any, options: any, lineOptions?: {
+        color: string;
+        opacity: number;
+    }, outlineOption?: {
+        color: string;
+        opacity: number;
+    });
+    _animation(): void;
+}
+
+declare function getExtrudeConfigByFeature(baseExtrudeConfig: any, feature?: any): any | undefined;
+declare function createSpriteMaterialByLabelSymbol(labelSymbol?: any[]): SpriteMaterial;
+declare function createStyledUIMarkerElement({ style, textContent, className, }: {
+    style: any;
+    textContent: any;
+    className: any;
+}): string;
+declare function styledFeatureGenerator(mapTheme: any): {
+    getElementSymbol: (key: any) => any;
+    getHilighPolygonalSymbol: (type: any) => any;
+    getHighlightMarkerSymbol: () => any;
+    createVenue: (feature: any) => any;
+    createLevel: (feature: any) => any;
+    createUnit: (feature: any) => any;
+    createMarker: (feature: any) => Marker;
+    createOriginMarker: (feature: any) => Marker;
+    createDestinationPinMarker: (feature: any, mapConfig: any) => Marker;
+    createDestinationLogoMarker: (feature: any, mapConfig?: {}) => Marker;
+    createUserLocationMarker: (feature: any) => Marker;
+    createLastUserLocationMarker: (feature: any) => Marker;
+    createHighlightOccupantMarker: (feature: any, mapConfig: any) => Marker;
+    createHighlight2DAmenityMarkerFrom3DMarker: (feature: any, mapConfig: any) => Marker;
+    createKiosk: (feature: any) => any;
+    createSection: (feature: any) => any;
+    createOccupant: (feature: any, location: any, mapConfig: any) => ui.UIMarker | Marker;
+    createOpening: (feature: any) => LineString$1;
+    createFixture: (feature: any) => any;
+    createLineStringFromGeometries: (geometries: any) => LineString$1;
+    create3DStepPath: (feature: any, threeLayer: any, option?: {}) => NavigationPath;
+    createDecoration: (decoration: any, options: any) => Polygon$1 | MultiPolygon$1 | LineString$1 | MultiLineString;
+    /** Three JS */
+    create3DFootprint: (feature: any, threeLayer: any, options: any) => Promise<any[]>;
+    create3DGroundLabel: (label: any, threeLayer: any) => GroundLabel;
+    createOccupantGroundLabel: (feature: any, location: any, mapConfig: any, threeLayer: any) => GroundLabel;
+    create3DBillboard: (billboard: any, threeLayer: any) => Billboard;
+    create3DAmenityMarker: (feature: any, threeLayer: any, config: any) => SpriteMarker;
+    create3DOccupantAmenityMarker: (feature: any, threeLayer: any, config: any) => SpriteMarker;
+    create3DOpeningMarker: (feature: any, threeLayer: any, config: any) => SpriteMarker;
+    create3DUnit: (unit: any, threeLayer: any) => Promise<any[]>;
+    create3DKiosk: (kiosk: any, threeLayer: any) => Promise<any[]>;
+    createVenue3DModel: (venue: any, threeLayer: any) => Promise<any[]>;
+    create3DFixture: (fixture: any, threeLayer: any) => Promise<any[]>;
+    createExtrudedUnit: (unit: any, threeLayer: any, options: any) => any;
+    createExtrudedKiosk: (kiosk: any, threeLayer: any, options: any) => any;
+    createExtrudedLevel: (level: any, threeLayer: any, options: any) => any;
+    createAmbientLight: (config: any) => AmbientLight;
+    createDirectionalLight: (config: any) => DirectionalLight;
+};
+declare function getLocationByAmenity(feature: any): any;
+declare function getLocationByOccupant(feature: any): any;
+declare function getLocationIdByFeature(feature: any): any;
+declare function getFeatureByLocationId(id: any, features?: any[]): any;
+declare function isClickableFeature(feature: any): any;
+declare function getLocationByFeature(feature: any): any;
+declare function getRelatedLocationsByOccupant(feature: any): any[];
+declare function getRelatedLocationsByAmenity(feature: any): any;
+declare function getRelatedLocationIdsByFeature(feature: any): any;
+declare function getRelatedLocationsByFeature(feature: any): any;
+declare function getOrdinalByLocationId(locationId: any, feature: any): any;
+
+interface ICoordinate {
+    x: number;
+    y: number;
+    z?: number;
+}
+type GetBearingBetweenPoints = (origin: ICoordinate, destination: ICoordinate) => number;
+type GetSuitablyValueBetweenBearings = (newBearing: number, currentBearing: number) => number;
+declare const getBearingBetweenPoints: GetBearingBetweenPoints;
+declare const getSuitablyValueBetweenBearings: GetSuitablyValueBetweenBearings;
+
+declare const getCenterFromGeometry: (geometry?: Polygon | MultiPolygon | Point | LineString) => number[] | null;
+declare const createPolygonFromLineString: (geometry: any) => geojson.Position[][];
+
+declare const ALWAYS_VISIBLE_FEATURE_TYPES: string[];
+declare const BASE_LAYER_NAME = "base";
+declare const POI_MARKER_LAYER_NAME = "poi";
+declare const MARKER_LAYER_NAME = "marker";
+declare const HIGHLIGHT_LAYER_NAME = "highlight";
+declare const USER_LOCATION_LAYER_NAME = "user_location";
+declare const ORIGIN_MARKER_ID = "master-origin-marker";
+declare const DESTINATION_MARKER_ID = "master-destination-marker";
+declare const USER_LOCATION_ELEMENT_ID = "user_location";
+declare const LAST_USER_LOCATION_ELEMENT_ID_PREFIX = "last_user_location-";
+declare const LOCALE_SYMBOL_KEY = "locale_symbol";
+declare const DEFAULT_LOCALE = "en";
+declare const DEFAULT_HIGHLIGHT_OPTIONS: IHighlightOptions;
+declare const DEFAULT_SET_HIGHLIGHT_2DELEMENT_IDS_OPTIONS: ISetHighlight2DElementIdsOptions;
+declare const LAYERS: string[];
+declare const LAYER_OPTIONS: {
+    base: {
+        forceRenderOnMoving: boolean;
+        forceRenderOnRotating: boolean;
+        forceRenderOnZooming: boolean;
+        enableAltitude: boolean;
+    };
+    poi: {
+        forceRenderOnMoving: boolean;
+        forceRenderOnRotating: boolean;
+        forceRenderOnZooming: boolean;
+        zIndex: number;
+        collision: boolean;
+        collisionDelay: number;
+        enableAltitude: boolean;
+    };
+    marker: {
+        enableAltitude: boolean;
+    };
+    highlight: {
+        zIndex: number;
+        enableAltitude: boolean;
+    };
+    user_location: {
+        zIndex: number;
+        enableAltitude: boolean;
+    };
+};
+declare const LAYER_FEATURE_TYPE_OBJ: {
+    venue: string;
+    level: string;
+    unit: string;
+    fixture: string;
+    kiosk: string;
+    opening: string;
+    section: string;
+    footprint: string;
+    amenity: string;
+    occupant: string;
+    geolocation: string;
+    "origin-marker": string;
+    "destination-marker": string;
+    decoration: string;
+};
+/** Custom Venue Platform Events. Prefix with "venue:" to avoid collision */
+declare const VENUE_EVENTS: {
+    VENUE_MOVEINTOVIEW: string;
+};
+
+export { ALL_FEATURE_TYPES, ALWAYS_VISIBLE_FEATURE_TYPES, type AmenityFeature, type AmenityFeaturePopulated, type AmenityGeometry, type AmenityProperties, type AnchorFeature, type AnchorFeaturePopulated, type AnchorGeometry, type AnchorProperties, BASE_LAYER_NAME, DEFAULT_BASE_URL, DEFAULT_HIGHLIGHT_OPTIONS, DEFAULT_LOCALE, DEFAULT_SET_HIGHLIGHT_2DELEMENT_IDS_OPTIONS, DESTINATION_MARKER_ID, type DetailFeature, type DetailGeometry, type DetailProperties, type ElementFeature, type ElementGeometry, type ElementProperties, type EventFeature, type EventGeometry, type EventProperties, type FeaturePopulatedResponseMap, type FeatureQueryOptions, type FeatureResponseMap, type FeatureType, type FilterParams, type FindParams, type FixtureFeature, type FixtureGeometry, type FixtureProperties, GEOJSON_FEATURE_TYPES, HIGHLIGHT_LAYER_NAME, IMDF_FEATURE_TYPES, type Id, type ImdfFeature, IndoorMap, type InternalFilterByType, type InternalFindById, type KioskFeature, type KioskFeaturePopulated, type KioskGeometry, type KioskProperties, LAST_USER_LOCATION_ELEMENT_ID_PREFIX, LAYERS, LAYER_FEATURE_TYPE_OBJ, LAYER_OPTIONS, LOCALE_SYMBOL_KEY, type LabelFeature, type LabelGeometry, type LabelProperties, type LevelFeature, type LevelFeaturePopulated, type LevelGeometry, type LevelProperties, MARKER_LAYER_NAME, type Media, type MediaFile, type Model3d, NONIMDF_FEATURE_TYPES, ORIGIN_MARKER_ID, type OccupantFeature, type OccupantFeaturePopulated, type OccupantGeometry, type OccupantProperties, type OpeningFeature, type OpeningGeometry, type OpeningProperties, POI_MARKER_LAYER_NAME, type Page, type PolygonalFeature, type PopulatableFeatureType, type PopulatedParams, type PrivilegeFeature, type PrivilegeGeometry, type PrivilegeProperties, type PromotionFeature, type PromotionProperties, type RelationshipFeature, type RelationshipGeometry, type RelationshipProperties, type SectionFeature, type SectionFeaturePopulated, type SectionGeometry, type SectionProperties, type SponsoredContentFeature, type SponsoredContentLegacyType, type SponsoredContentPlacementType, type SponsoredContentStrapiV4ApiResponse, type TaxonomyFeature, type TaxonomyFeaturePopulated, type TaxonomyGeometry, type TaxonomyProperties, USER_LOCATION_ELEMENT_ID, USER_LOCATION_LAYER_NAME, type UnitFeature, type UnitFeaturePopulated, type UnitGeometry, type UnitProperties, VENUE_EVENTS, type VenueClientOptions, type VenueDataClient, type VenueFeature, type VenueFeaturePopulated, type VenueGeometry, type VenueProperties, createPolygonFromLineString, createSpriteMaterialByLabelSymbol, createStyledUIMarkerElement, defaultFeatureQueryOptionsMap, fetchFeature, getBearingBetweenPoints, getCenterFromGeometry, getDataClient, getExtrudeConfigByFeature, getFeatureByLocationId, getLocationByAmenity, getLocationByFeature, getLocationByOccupant, getLocationIdByFeature, getOrdinalByLocationId, getRelatedLocationIdsByFeature, getRelatedLocationsByAmenity, getRelatedLocationsByFeature, getRelatedLocationsByOccupant, getSuitablyValueBetweenBearings, isClickableFeature, safeFetchFeature, styledFeatureGenerator };