@earthview/core 0.1.1 → 0.2.0

package/dist/index.d.ts

@@ -2,8 +2,7 @@ import { default as default_2 } from 'ol/layer/Vector';
 import { default as default_3 } from 'ol/source/Vector';
 import { default as default_4 } from 'ol/layer/Heatmap';
 import { default as default_5 } from 'ol/source/Cluster';
-import { default as default_6 } from 'ol/layer/Tile';
-import { default as default_7 } from 'ol/source/XYZ';
+import { Feature } from 'ol';
 
 export declare interface AreaMeasurementData {
     id: string;
@@ -68,6 +67,7 @@ export declare class BarChartLayer extends BaseLayer {
     private getHeight;
     private getColor;
     setData(data: BarChartData[]): void;
+    getData(): BarChartData[];
     updateData(data: BarChartData[]): void;
 }
 
@@ -114,7 +114,8 @@ export declare enum BasemapTypeEnum {
     AMAP_STREETS = "amap-streets",
     AMAP_SATELLITE = "amap-satellite",
     GOOGLE_STREETS = "google-streets",
-    GOOGLE_SATELLITE = "google-satellite"
+    GOOGLE_SATELLITE = "google-satellite",
+    CUSTOMIZE = "customize"
 }
 
 export declare function bd09ToWgs84(lng: number, lat: number): [number, number];
@@ -136,6 +137,7 @@ export declare interface CircleDrawData {
     fillColor?: number[];
     outlineColor?: number[];
     outlineWidth?: number;
+    outlineStyle?: "solid" | "dashed";
 }
 
 export declare class CircleDrawLayer extends BaseLayer {
@@ -145,18 +147,22 @@ export declare class CircleDrawLayer extends BaseLayer {
     private defaultFillColor;
     private defaultOutlineColor;
     private defaultOutlineWidth;
+    private defaultOutlineStyle;
     private onDrawCompleteCallback;
     private onEditCompleteCallback;
     private editingFeature;
     private mapView;
+    private t;
     constructor(id: string, name: string, options?: {
         defaultFillColor?: number[];
         defaultOutlineColor?: number[];
         defaultOutlineWidth?: number;
+        defaultOutlineStyle?: "solid" | "dashed";
         visible?: boolean;
         opacity?: number;
         zIndex?: number;
-    });
+    }, t?: Translations);
+    setTranslations(t: Translations): void;
     private createStyle;
     setView(view: any): void;
     createLayer(map: any): default_2<default_3>;
@@ -201,6 +207,8 @@ export declare class CircleLayer extends BaseLayer {
     updateData(data: {
         circles?: CircleData[];
     }): void;
+    getAllCircles(): CircleData[];
+    getCircle(id: string): CircleData | undefined;
 }
 
 export declare interface ClusterData {
@@ -228,6 +236,7 @@ export declare class ClusterLayer extends BaseLayer {
     updateData(data: ClusterData[]): void;
     getLayer(): default_2<default_5> | null;
     destroy(): void;
+    getData(): ClusterData[];
 }
 
 /**
@@ -240,31 +249,6 @@ export declare enum CoordinateSystemTypeEnum {
     WEB_MERCATOR = "web_mercator"
 }
 
-export declare class CustomTileLayer extends BaseLayer {
-    private tileLayer;
-    private urlTemplate;
-    private subDomains;
-    private attribution;
-    private minZoom;
-    private maxZoom;
-    constructor(id: string, name: string, options: {
-        urlTemplate: string;
-        subDomains?: string[];
-        attribution?: string;
-        minZoom?: number;
-        maxZoom?: number;
-        visible?: boolean;
-        opacity?: number;
-        zIndex?: number;
-    });
-    createLayer(map: any): default_6<default_7>;
-    updateData(data: {
-        urlTemplate: string;
-    }): void;
-    getLayer(): default_6<default_7> | null;
-    destroy(): void;
-}
-
 export declare interface DistanceMeasurementData {
     id: string;
     points: MeasurementPoint[];
@@ -299,7 +283,7 @@ export declare class DistanceMeasurementLayer extends BaseLayer {
     updateData(data: any): void;
 }
 
-export declare class EarthViewCore {
+export declare class EarthView {
     private mapManager;
     private layerManager;
     private uiManager;
@@ -318,6 +302,7 @@ export declare class EarthViewCore {
     private drawingStatusDiv;
     private measureStatusDiv;
     private container;
+    private isOwnContainer;
     private theme;
     private t;
     private locale;
@@ -338,13 +323,61 @@ export declare class EarthViewCore {
     private currentColor;
     private currentStrokeWidth;
     private currentStrokeStyle;
+    private currentSize;
     private currentScale;
     private isLoading;
     private isChangingBasemap;
     private drawingStatusText;
     private measureStatusText;
+    private freehandDrawLayer;
+    private ellipseDrawLayer;
+    private markerDrawLayer;
+    private textDrawLayer;
+    private arrowDrawLayer;
+    private freehandDrawTool;
+    private ellipseDrawTool;
+    private markerDrawTool;
+    private textDrawTool;
+    private arrowDrawTool;
+    private eventManager;
+    private selectedFreehandId;
+    private selectedEllipseId;
+    private selectedMarkerId;
+    private selectedTextId;
+    private selectedArrowId;
+    private lineDrawLayer;
+    private bezierDrawLayer;
+    private sectorDrawLayer;
+    private lineDrawTool;
+    private bezierDrawTool;
+    private sectorDrawTool;
+    private selectedLineId;
+    private selectedBezierId;
+    private selectedSectorId;
+    private pointCoordinatePickLayer;
+    private lineCoordinatePickLayer;
+    private polygonCoordinatePickLayer;
+    private pointCoordinateListPanel;
+    private currentPointCoordinates;
+    private currentLineCoordinates;
+    private currentPolygonCoordinates;
+    private imageDrawLayer;
+    private imageDrawTool;
+    private selectedImageId;
+    private selectedPointPickId;
+    private selectedLinePickId;
+    private selectedPolygonPickId;
     constructor(options: EarthViewOptions);
+    private initEventManager;
+    private resolveContainer;
+    private createAutoContainer;
     private initUI;
+    private updateCoordinateListPanel;
+    private showToast;
+    startPointCoordinatePick(): void;
+    startLineCoordinatePick(): void;
+    startPolygonCoordinatePick(): void;
+    private showCoordinateList;
     private handleTogglePopup;
     private createStatusIndicators;
     private initLayers;
@@ -361,6 +394,15 @@ export declare class EarthViewCore {
     private stopAllEditing;
     private showFloatingToolbarForCircle;
     private showFloatingToolbarForRectangle;
+    private showFloatingToolbarForFreehand;
+    private showFloatingToolbarForLine;
+    private showFloatingToolbarForBezier;
+    private showFloatingToolbarForSector;
+    private showFloatingToolbarForEllipse;
+    private showFloatingToolbarForMarker;
+    startDrawImage(): void;
+    private showFloatingToolbarForArrow;
+    private showGenericFloatingToolbar;
     private showFloatingToolbarForTriangle;
     private showMeasurementToolbarForFeature;
     private hideFloatingToolbar;
@@ -377,16 +419,24 @@ export declare class EarthViewCore {
     setCenter(center: [number, number], cs?: CoordinateSystemTypeEnum): void;
     setZoom(zoom: number): void;
     setBasemap(basemap: BasemapTypeEnum): void;
-    getBasemap(): BasemapTypeEnum;
+    getBasemap(): BasemapTypeEnum | null;
     setTheme(theme: "light" | "dark"): void;
     getTheme(): "light" | "dark";
     setLocale(locale: Locale): void;
     getContainer(): HTMLElement;
     getLayerManager(): LayerManager;
     getMap(): any;
-    addMarkerLayer(id: string, name: string, options?: any): MarkerLayer;
     removeLayer(id: string): void;
     setLayerVisibility(id: string, visible: boolean): void;
+    startDrawFreehand(): void;
+    startDrawFreehandPolygon(): void;
+    startDrawEllipse(): void;
+    startDrawMarker(): void;
+    startDrawText(): void;
+    startDrawArrow(): void;
+    startDrawLine(): void;
+    startDrawBezier(): void;
+    startDrawSector(): void;
     startMeasureDistance(): void;
     startMeasureArea(): void;
     clearAllMeasurements(): void;
@@ -394,18 +444,29 @@ export declare class EarthViewCore {
     zoomIn(): void;
     zoomOut(): void;
     locateUser(): void;
+    private getPointDataForPanel;
+    private getLineDataForPanel;
+    private getPolygonDataForPanel;
+    private locateToPoint;
+    private locateToLine;
+    setBasemapByUrl(url: string): void;
+    private locateToPolygon;
+    clearAllCoordinatePicks(): void;
     destroy(): void;
 }
 
 export declare interface EarthViewOptions {
-    container: HTMLElement;
+    container?: HTMLElement;
+    containerSelector?: string;
+    id?: string;
+    parent?: HTMLElement;
+    parentSelector?: string;
     basemap?: BasemapTypeEnum;
+    baseMapUrl?: string;
     center?: [number, number];
     zoom?: number;
     coordinateSystem?: CoordinateSystemTypeEnum;
-    minZoom?: number;
-    maxZoom?: number;
-    onLoad?: (core: any) => void;
+    onLoad?: (core: EarthView) => void;
     onMoveEnd?: (center: [number, number], zoom: number) => void;
     onMapClick?: (event: {
         longitude: number;
@@ -413,7 +474,7 @@ export declare interface EarthViewOptions {
     }) => void;
     onCircleDrawn?: (data: CircleDrawData) => void;
     theme?: "light" | "dark";
-    i18n?: "en" | "zh";
+    i18n?: Locale;
     enableDrawing?: boolean;
 }
 
@@ -435,12 +496,14 @@ export declare class GeoJSONLayer extends BaseLayer {
         url?: string;
         geojson?: any;
     }): void;
+    getAllFeatures(): Feature[];
     getLayer(): default_2<default_3> | null;
 }
 
 export declare const getTranslation: (locale: Locale) => Translations;
 
 export declare interface HeatmapData {
+    id: string;
     longitude: number;
     latitude: number;
     value?: number;
@@ -461,6 +524,7 @@ export declare class HeatmapLayer extends BaseLayer {
     setData(data: HeatmapData[]): void;
     updateData(data: HeatmapData[]): void;
     getLayer(): default_4 | null;
+    getData(): HeatmapData[];
 }
 
 declare interface ILayer {
@@ -501,7 +565,6 @@ export declare class LayerManager implements ILayerManager {
     constructor(map: any);
     addLayer(layer: BaseLayer, index?: number): void;
     private getZIndexForLayer;
-    private getLayerOrderIndex;
     removeLayer(id: string): void;
     getLayer(id: string): BaseLayer | undefined;
     getAllLayers(): BaseLayer[];
@@ -530,40 +593,174 @@ export declare enum LayerTypeEnum {
     RECTANGLE_DRAW = "rectangle-draw",
     TRIANGLE_DRAW = "triangle-draw",
     DISTANCE_MEASUREMENT = "distance-measurement",
-    AREA_MEASUREMENT = "area-measurement"
+    AREA_MEASUREMENT = "area-measurement",
+    FREEHAND_DRAW = "freehand-draw",
+    ELLIPSE_DRAW = "ellipse-draw",
+    MARKER_DRAW = "marker-draw",
+    TEXT_DRAW = "text-draw",
+    IMAGE_DRAW = "image-draw",
+    ARROW_DRAW = "arrow-draw",
+    LINE_DRAW = "line-draw",
+    BEZIER_DRAW = "bezier-draw",
+    SECTOR_DRAW = "sector-draw",
+    POINT_COORDINATE_PICK = "point-coordinate-pick",
+    LINE_COORDINATE_PICK = "line-coordinate-pick",
+    POLYGON_COORDINATE_PICK = "polygon-coordinate-pick"
 }
 
 export declare type Locale = "en" | "zh";
 
-export declare interface MarkerData {
-    id: string;
-    longitude: number;
-    latitude: number;
-    color?: number[];
-    size?: number;
-    title?: string;
-    popupContent?: string;
-}
-
 export declare class MarkerLayer extends BaseLayer {
+    private moveHandler;
     private features;
+    private markersData;
+    private animationFrames;
     private defaultColor;
     private defaultSize;
-    constructor(id: string, name: string, options?: {
-        defaultColor?: number[];
-        defaultSize?: number;
+    private popupWidth;
+    private coverImageHeight;
+    private view;
+    private currentPopup;
+    private currentFeature;
+    private currentHoverTimeout;
+    private needsUpdate;
+    private animationFrameId;
+    private postRenderHandler;
+    private updateFrame;
+    constructor(id: string, name: string, options?: MarkerLayerOptions & {
         visible?: boolean;
         opacity?: number;
         zIndex?: number;
     });
+    setView(map: any): void;
+    private scheduleUpdate;
     createLayer(map: any): default_2<default_3>;
-    addMarker(data: MarkerData): void;
+    private attachEvents;
+    private createPointStyle;
+    private startAnimation;
+    /**
+     * Create scaled style for pulse animation
+     */
+    private createScaledStyle;
+    /**
+     * Create blended style for flashing animation
+     */
+    private createBlendedStyle;
+    /**
+     * Create opacity style for breathing animation
+     */
+    private createOpacityStyle;
+    /**
+     * Create glow style for light animation
+     */
+    private createGlowStyle;
+    /**
+     * Stop animation for a marker
+     */
+    private stopAnimation;
+    private createHtmlStyle;
+    addMarker(data: MarkerLayerData): Promise<void>;
     removeMarker(id: string): void;
-    updateMarkerPosition(id: string, longitude: number, latitude: number): void;
-    getAllMarkers(): MarkerData[];
+    updateMarker(id: string, data: Partial<MarkerLayerData>): Promise<void>;
+    private showPopup;
+    private hidePopup;
+    clearAllMarkers(): void;
+    getAllMarkers(): MarkerLayerData[];
+    getMarker(id: string): MarkerLayerData | undefined;
     updateData(data: {
-        markers?: MarkerData[];
+        markers: MarkerLayerData[];
     }): void;
+    private updatePopupPosition;
+    destroy(): void;
+}
+
+export declare enum MarkerLayerAnimationTypeEnum {
+    PULSE = "pulse",
+    FLASHING = "flashing",
+    BREATHING = "breathing",
+    LIGHT = "light"
+}
+
+export declare interface MarkerLayerData {
+    id: string;
+    name?: string;
+    longitude: number;
+    latitude: number;
+    bubbleBoxTitle?: string;
+    bubbleBoxDescription?: string;
+    bubbleBoxCoverImage?: string;
+    pointColor?: string;
+    pointType?: MarkerLayerPointTypeEnum;
+    pointSize?: number;
+    pointText?: string;
+    pointAnimationType?: MarkerLayerAnimationTypeEnum;
+    pointHtml?: string;
+    pointHtmlWidth?: number;
+    pointHtmlHeight?: number;
+    onClick?: (data: MarkerLayerData, event: any) => void;
+    onContextMenu?: (data: MarkerLayerData, event: any) => void;
+    onHover?: (data: MarkerLayerData, event: any) => void;
+    timestamp?: number;
+}
+
+declare interface MarkerLayerOptions {
+    defaultColor?: number[];
+    defaultSize?: number;
+    popupWidth?: number;
+    coverImageHeight?: number;
+}
+
+export declare enum MarkerLayerPointTypeEnum {
+    SQUARE = "square",
+    CIRCLE = "circle",
+    TRIANGLE = "triangle",
+    PENTAGRAM = "pentagram",
+    TEXT = "text",
+    DIAMOND = "diamond",
+    CROSS = "cross",
+    X_SHAPE = "x_shape",
+    HEXAGON = "hexagon",
+    FLAG = "flag",
+    HOUSE = "house",
+    ARROW = "arrow",
+    TENT = "tent",// Tent - Camp, temporary post
+    BUNKER = "bunker",// Bunker - Fortification, fire point
+    LANDMINE = "landmine",// Landmine - Minefield, explosives
+    TANK = "tank",// Tank - Armored unit, heavy equipment
+    PLANE = "plane",// Plane - Airport, airstrip, aviation facility
+    SHIP = "ship",// Ship - Port, landing point, naval facility
+    RADAR = "radar",// Radar - Monitoring station, early warning point
+    MISSILE = "missile",// Missile - Missile site, launch point
+    FIRE_HYDRANT = "fire_hydrant",// Fire Hydrant - Fire facility, fire point
+    FIRST_AID = "first_aid",// First Aid - Medical supply point
+    WATER_TOWER = "water_tower",// Water Tower - Water source, reservoir
+    GENERATOR = "generator",// Generator - Power facility, backup power
+    MEGAPHONE = "megaphone",// Megaphone - Broadcast point, alert point
+    STREET_LAMP = "street_lamp",// Street Lamp - Lighting facility, emergency light
+    PARKING = "parking",// Parking - Parking lot, parking area
+    GAS_STATION = "gas_station",// Gas Station - Gas station, charging station
+    TUNNEL = "tunnel",// Tunnel - Tunnel entrance, culvert
+    BRIDGE = "bridge",// Bridge - Bridge, elevated road
+    TRAFFIC_LIGHT = "traffic_light",// Traffic Light - Traffic signal point
+    CAMERA = "camera",// Camera - Monitoring point, speed camera
+    TOILET = "toilet",// Toilet - Public restroom
+    TRASH_CAN = "trash_can",// Trash Can - Waste collection point
+    BUS_STOP = "bus_stop",// Bus Stop - Bus station
+    SUBWAY = "subway",// Subway - Subway entrance
+    SCHOOL = "school",// School - School, educational institution
+    HOSPITAL = "hospital",// Hospital - Hospital, clinic (distinct from cross)
+    TREE = "tree",// Tree - Forest, green area
+    WATER_SOURCE = "water_source",// Water Source - River, lake, well
+    MOUNTAIN = "mountain",// Mountain - Peak, high point
+    MINE = "mine",// Mine - Mining point, quarry
+    HEART = "heart",// Heart - Important attention point, donation spot
+    STAR = "star",// Star - Commendation point, excellent spot
+    CLOUD = "cloud",// Cloud - Cloud service node, weather observation point
+    GEAR = "gear",// Gear - Industrial facility, factory
+    LIGHTNING = "lightning",// Lightning - Power facility, hazard warning
+    PIN = "pin",// Pin - General marker point, favorite point
+    COMPASS = "compass",// Compass - Direction reference, navigation point
+    ANCHOR = "anchor"
 }
 
 export declare interface MeasurementPoint {
@@ -599,6 +796,8 @@ export declare class PolygonLayer extends BaseLayer {
     updateData(data: {
         polygons?: PolygonData[];
     }): void;
+    getAllPolygons(): PolygonData[];
+    getPolygon(id: string): PolygonData | undefined;
 }
 
 export declare interface PolylineData {
@@ -626,60 +825,8 @@ export declare class PolylineLayer extends BaseLayer {
     updateData(data: {
         polylines?: PolylineData[];
     }): void;
-}
-
-export declare interface PopupMarkerData {
-    id: string;
-    longitude: number;
-    latitude: number;
-    title?: string;
-    description?: string;
-    coverImage?: string;
-    color?: number[];
-    size?: number;
-}
-
-export declare class PopupMarkerLayer extends BaseLayer {
-    private moveHandler;
-    private features;
-    private defaultColor;
-    private defaultSize;
-    private popupWidth;
-    private coverImageHeight;
-    private view;
-    private currentPopup;
-    private currentFeature;
-    private needsUpdate;
-    private animationFrameId;
-    private postRenderHandler;
-    private updateFrame;
-    constructor(id: string, name: string, options?: PopupMarkerLayerOptions & {
-        visible?: boolean;
-        opacity?: number;
-        zIndex?: number;
-    });
-    setView(map: any): void;
-    private scheduleUpdate;
-    createLayer(map: any): default_2<default_3>;
-    private attachClickEvent;
-    addMarker(data: PopupMarkerData): void;
-    removeMarker(id: string): void;
-    private showPopup;
-    private hidePopup;
-    clearAllMarkers(): void;
-    getAllMarkers(): PopupMarkerData[];
-    updateData(data: {
-        markers: PopupMarkerData[];
-    }): void;
-    private updatePopupPosition;
-    destroy(): void;
-}
-
-declare interface PopupMarkerLayerOptions {
-    defaultColor?: number[];
-    defaultSize?: number;
-    popupWidth?: number;
-    coverImageHeight?: number;
+    getAllPolylines(): PolylineData[];
+    getPolyline(id: string): PolylineData | undefined;
 }
 
 export declare interface TileLayerConfig {
@@ -693,6 +840,22 @@ export declare interface TileLayerConfig {
 export declare function toWGS84(lng: number, lat: number, fromSystem: CoordinateSystemTypeEnum): [number, number];
 
 export declare interface Translations {
+    pleaseEnterText: string;
+    longitude: string;
+    latitude: string;
+    confirm: string;
+    addImage: string;
+    imageUrl: string;
+    uploadImage: string;
+    width: string;
+    height: string;
+    opacity: string;
+    drawImage: string;
+    drawCoordinatePick: string;
+    coordinatePick: string;
+    coordinateList: string;
+    noCoordinates: string;
+    clearAll: string;
     loading: string;
     changingBasemap: string;
     layers: string;
@@ -762,6 +925,132 @@ export declare interface Translations {
     editShape: string;
     editingRectangle: string;
     editingTriangle: string;
+    circleDrawLayer: string;
+    rectangleDrawLayer: string;
+    triangleDrawLayer: string;
+    distanceMeasurementLayer: string;
+    areaMeasurementLayer: string;
+    drawFreehandLine: string;
+    drawFreehandPolygon: string;
+    drawEllipse: string;
+    drawMarker: string;
+    drawText: string;
+    drawArrow: string;
+    drawLine: string;
+    drawBezier: string;
+    drawSector: string;
+    pointData: string;
+    lineData: string;
+    polygonData: string;
+    coordinateData: string;
+    details: string;
+    copyCoordinates: string;
+    locateOnMap: string;
+    startPoint: string;
+    endPoint: string;
+    vertexCount: string;
+    createdTime: string;
+    noDataAvailable: string;
+    pleaseUseCoordinatePickTool: string;
+    coordinatesCopied: string;
+    locatedToPoint: string;
+    locatedToLine: string;
+    locatedToPolygon: string;
+    allCoordinatesCleared: string;
+    noCoordinateData: string;
+    copyAllPointCoordinates: string;
+    pointPickSuccess: string;
+    linePickSuccess: string;
+    polygonPickSuccess: string;
+    drawingStatusCancelHint: string;
+    editingText: string;
+    fontSize: string;
+    color: string;
+    bold: string;
+    italic: string;
+    imagePreview: string;
+    noImage: string;
+    imageLoadFailed: string;
+    image: string;
+    cancelDrawing: string;
+    drawingRectangle: string;
+    drawingTriangle: string;
+    drawingFreehand: string;
+    drawingFreehandPolygon: string;
+    drawingEllipse: string;
+    addingMarker: string;
+    addingText: string;
+    drawingArrow: string;
+    drawingLine: string;
+    drawingBezier: string;
+    drawingSector: string;
+    drawing: string;
+    pressEscToCancel: string;
+    clickMapToPickPoint: string;
+    clickMapToDrawLine: string;
+    clickMapToDrawPolygon: string;
+    doubleClickToFinishPick: string;
+    editText: string;
+    strokeWidth: string;
+    strokeStyle: string;
+    dragToMove: string;
+    noImagePreview: string;
+    uploadFromComputer: string;
+    enterImageUrl: string;
+    deleteImage: string;
+    cancelEdit: string;
+    save: string;
+    ok: string;
+    lineTool: string;
+    arrowTool: string;
+    bezierTool: string;
+    ellipseTool: string;
+    rectangleTool: string;
+    triangleTool: string;
+    sectorTool: string;
+    freehandTool: string;
+    freehandPolygonTool: string;
+    markerTool: string;
+    textTool: string;
+    imageTool: string;
+    points: string;
+    pointsCount: string;
+    featureNotFound: string;
+    cannotGetMapTarget: string;
+    cannotGetPixelFromCoordinate: string;
+    bezierFeatureNotFound: string;
+    noSourceAvailable: string;
+    dataLayers: string;
+    drawLayers: string;
+    toolLayers: string;
+    freehandDrawLayer: string;
+    ellipseDrawLayer: string;
+    markerDrawLayer: string;
+    textDrawLayer: string;
+    imageDrawLayer: string;
+    arrowDrawLayer: string;
+    lineDrawLayer: string;
+    bezierDrawLayer: string;
+    sectorDrawLayer: string;
+    pointPickLayer: string;
+    linePickLayer: string;
+    polygonPickLayer: string;
+    featureType: string;
+    properties: string;
+    linePick: {
+        default_name: string;
+        label_prefix: string;
+        highlight_text: string;
+    };
+    pointPick: {
+        default_name: string;
+        label_text: string;
+    };
+    polygonPick: {
+        default_name: string;
+        label_prefix: string;
+        highlight_text: string;
+    };
 }
 
 export { }