terra-draw 0.0.1-alpha.2 → 0.0.1-alpha.20

package/dist/modes/circle/circle.mode.d.ts

@@ -1,27 +1,48 @@
-import { TerraDrawMouseEvent, TerraDrawAdapterStyling, TerraDrawKeyboardEvent } from "../../common";
+import { TerraDrawMouseEvent, TerraDrawAdapterStyling, TerraDrawKeyboardEvent, HexColor } from "../../common";
+import { GeoJSONStoreFeatures } from "../../store/store";
 import { TerraDrawBaseDrawMode } from "../base.mode";
-declare type TerraDrawCircleModeKeyEvents = {
-    cancel: KeyboardEvent["key"];
+type TerraDrawCircleModeKeyEvents = {
+    cancel: KeyboardEvent["key"] | null;
+    finish: KeyboardEvent["key"] | null;
 };
-export declare class TerraDrawCircleMode extends TerraDrawBaseDrawMode {
+type FreehandPolygonStyling = {
+    fillColor: HexColor;
+    outlineColor: HexColor;
+    outlineWidth: number;
+    fillOpacity: number;
+};
+export declare class TerraDrawCircleMode extends TerraDrawBaseDrawMode<FreehandPolygonStyling> {
     mode: string;
     private center;
     private clickCount;
     private currentCircleId;
     private keyEvents;
     constructor(options?: {
-        styling?: Partial<TerraDrawAdapterStyling>;
-        keyEvents?: TerraDrawCircleModeKeyEvents;
+        styles?: Partial<FreehandPolygonStyling>;
+        keyEvents?: TerraDrawCircleModeKeyEvents | null;
     });
+    private close;
+    /** @internal */
     start(): void;
+    /** @internal */
     stop(): void;
+    /** @internal */
     onClick(event: TerraDrawMouseEvent): void;
+    /** @internal */
     onMouseMove(event: TerraDrawMouseEvent): void;
+    /** @internal */
     onKeyDown(): void;
+    /** @internal */
     onKeyUp(event: TerraDrawKeyboardEvent): void;
+    /** @internal */
     onDragStart(): void;
+    /** @internal */
     onDrag(): void;
+    /** @internal */
     onDragEnd(): void;
+    /** @internal */
     cleanUp(): void;
+    /** @internal */
+    styleFeature(feature: GeoJSONStoreFeatures): TerraDrawAdapterStyling;
 }
 export {};

package/dist/modes/freehand/freehand.mode.d.ts

@@ -1,29 +1,54 @@
-import { TerraDrawMouseEvent, TerraDrawAdapterStyling, TerraDrawKeyboardEvent } from "../../common";
+import { TerraDrawMouseEvent, TerraDrawAdapterStyling, TerraDrawKeyboardEvent, HexColor } from "../../common";
 import { TerraDrawBaseDrawMode } from "../base.mode";
-declare type TerraDrawFreehandModeKeyEvents = {
-    cancel: KeyboardEvent["key"];
+import { GeoJSONStoreFeatures } from "../../store/store";
+type TerraDrawFreehandModeKeyEvents = {
+    cancel: KeyboardEvent["key"] | null;
+    finish: KeyboardEvent["key"] | null;
 };
-export declare class TerraDrawFreehandMode extends TerraDrawBaseDrawMode {
+type FreehandPolygonStyling = {
+    fillColor: HexColor;
+    outlineColor: HexColor;
+    outlineWidth: number;
+    fillOpacity: number;
+    closingPointColor: HexColor;
+    closingPointWidth: number;
+    closingPointOutlineColor: HexColor;
+    closingPointOutlineWidth: number;
+};
+export declare class TerraDrawFreehandMode extends TerraDrawBaseDrawMode<FreehandPolygonStyling> {
     mode: string;
     private startingClick;
     private currentId;
-    private skip;
-    private everyNthMouseEvent;
+    private closingPointId;
+    private minDistance;
     private keyEvents;
     constructor(options?: {
-        styling?: Partial<TerraDrawAdapterStyling>;
-        everyNthMouseEvent?: number;
-        keyEvents?: TerraDrawFreehandModeKeyEvents;
+        styles?: Partial<FreehandPolygonStyling>;
+        minDistance?: number;
+        keyEvents?: TerraDrawFreehandModeKeyEvents | null;
     });
+    private close;
+    /** @internal */
     start(): void;
+    /** @internal */
     stop(): void;
+    /** @internal */
     onMouseMove(event: TerraDrawMouseEvent): void;
+    /** @internal */
     onClick(event: TerraDrawMouseEvent): void;
+    /** @internal */
     onKeyDown(): void;
+    /** @internal */
     onKeyUp(event: TerraDrawKeyboardEvent): void;
+    /** @internal */
     onDragStart(): void;
+    /** @internal */
     onDrag(): void;
+    /** @internal */
     onDragEnd(): void;
+    /** @internal */
     cleanUp(): void;
+    /** @internal */
+    styleFeature(feature: GeoJSONStoreFeatures): TerraDrawAdapterStyling;
 }
 export {};

package/dist/modes/great-circle-snapping.behavior.d.ts

@@ -0,0 +1,13 @@
+import { BehaviorConfig, TerraDrawModeBehavior } from "./base.behavior";
+import { TerraDrawMouseEvent } from "../common";
+import { Position } from "geojson";
+import { ClickBoundingBoxBehavior } from "./click-bounding-box.behavior";
+import { PixelDistanceBehavior } from "./pixel-distance.behavior";
+export declare class GreatCircleSnappingBehavior extends TerraDrawModeBehavior {
+    readonly config: BehaviorConfig;
+    private readonly pixelDistance;
+    private readonly clickBoundingBox;
+    constructor(config: BehaviorConfig, pixelDistance: PixelDistanceBehavior, clickBoundingBox: ClickBoundingBoxBehavior);
+    getSnappableCoordinate: (event: TerraDrawMouseEvent, currentFeatureId?: string) => Position | undefined;
+    private getSnappableEnds;
+}

package/dist/modes/greatcircle/great-circle.mode.d.ts

@@ -0,0 +1,57 @@
+import { TerraDrawMouseEvent, TerraDrawAdapterStyling, TerraDrawKeyboardEvent, HexColor } from "../../common";
+import { TerraDrawBaseDrawMode } from "../base.mode";
+import { BehaviorConfig } from "../base.behavior";
+import { GeoJSONStoreFeatures } from "../../store/store";
+type TerraDrawGreateCircleModeKeyEvents = {
+    cancel: KeyboardEvent["key"] | null;
+    finish: KeyboardEvent["key"] | null;
+};
+type GreateCircleStyling = {
+    lineStringWidth: number;
+    lineStringColor: HexColor;
+    closingPointColor: HexColor;
+    closingPointWidth: number;
+    closingPointOutlineColor: HexColor;
+    closingPointOutlineWidth: number;
+};
+export declare class TerraDrawGreatCircleMode extends TerraDrawBaseDrawMode<GreateCircleStyling> {
+    mode: string;
+    private currentCoordinate;
+    private currentId;
+    private closingPointId;
+    private keyEvents;
+    private snappingEnabled;
+    private snapping;
+    constructor(options?: {
+        snapping?: boolean;
+        pointerDistance?: number;
+        styles?: Partial<GreateCircleStyling>;
+        keyEvents?: TerraDrawGreateCircleModeKeyEvents | null;
+    });
+    private close;
+    /** @internal */
+    registerBehaviors(config: BehaviorConfig): void;
+    /** @internal */
+    start(): void;
+    /** @internal */
+    stop(): void;
+    /** @internal */
+    onMouseMove(event: TerraDrawMouseEvent): void;
+    /** @internal */
+    onClick(event: TerraDrawMouseEvent): void;
+    /** @internal */
+    onKeyDown(): void;
+    /** @internal */
+    onKeyUp(event: TerraDrawKeyboardEvent): void;
+    /** @internal */
+    onDragStart(): void;
+    /** @internal */
+    onDrag(): void;
+    /** @internal */
+    onDragEnd(): void;
+    /** @internal */
+    cleanUp(): void;
+    /** @internal */
+    styleFeature(feature: GeoJSONStoreFeatures): TerraDrawAdapterStyling;
+}
+export {};

package/dist/modes/linestring/linestring.mode.d.ts

@@ -1,34 +1,60 @@
-import { TerraDrawMouseEvent, TerraDrawAdapterStyling, TerraDrawKeyboardEvent } from "../../common";
+import { TerraDrawMouseEvent, TerraDrawAdapterStyling, TerraDrawKeyboardEvent, HexColor } from "../../common";
 import { TerraDrawBaseDrawMode } from "../base.mode";
 import { BehaviorConfig } from "../base.behavior";
-declare type TerraDrawLineStringModeKeyEvents = {
-    cancel: KeyboardEvent["key"];
+import { GeoJSONStoreFeatures } from "../../store/store";
+type TerraDrawLineStringModeKeyEvents = {
+    cancel: KeyboardEvent["key"] | null;
+    finish: KeyboardEvent["key"] | null;
 };
-export declare class TerraDrawLineStringMode extends TerraDrawBaseDrawMode {
+type LineStringStyling = {
+    lineStringWidth: number;
+    lineStringColor: HexColor;
+    closingPointColor: HexColor;
+    closingPointWidth: number;
+    closingPointOutlineColor: HexColor;
+    closingPointOutlineWidth: number;
+};
+export declare class TerraDrawLineStringMode extends TerraDrawBaseDrawMode<LineStringStyling> {
     mode: string;
     private currentCoordinate;
     private currentId;
+    private closingPointId;
     private allowSelfIntersections;
     private keyEvents;
     private snappingEnabled;
+    private mouseMove;
     private snapping;
     constructor(options?: {
         snapping?: boolean;
         allowSelfIntersections?: boolean;
         pointerDistance?: number;
-        styling?: Partial<TerraDrawAdapterStyling>;
-        keyEvents?: TerraDrawLineStringModeKeyEvents;
+        styles?: Partial<LineStringStyling>;
+        keyEvents?: TerraDrawLineStringModeKeyEvents | null;
     });
+    private close;
+    /** @internal */
     registerBehaviors(config: BehaviorConfig): void;
+    /** @internal */
     start(): void;
+    /** @internal */
     stop(): void;
+    /** @internal */
     onMouseMove(event: TerraDrawMouseEvent): void;
+    /** @internal */
     onClick(event: TerraDrawMouseEvent): void;
+    /** @internal */
     onKeyDown(): void;
+    /** @internal */
     onKeyUp(event: TerraDrawKeyboardEvent): void;
+    /** @internal */
     onDragStart(): void;
+    /** @internal */
     onDrag(): void;
+    /** @internal */
     onDragEnd(): void;
+    /** @internal */
     cleanUp(): void;
+    /** @internal */
+    styleFeature(feature: GeoJSONStoreFeatures): TerraDrawAdapterStyling;
 }
 export {};

package/dist/modes/point/point.mode.d.ts

@@ -1,18 +1,38 @@
-import { TerraDrawMouseEvent, TerraDrawAdapterStyling } from "../../common";
+import { TerraDrawMouseEvent, TerraDrawAdapterStyling, HexColor } from "../../common";
+import { GeoJSONStoreFeatures } from "../../store/store";
 import { TerraDrawBaseDrawMode } from "../base.mode";
-export declare class TerraDrawPointMode extends TerraDrawBaseDrawMode {
+type PointModeStyling = {
+    pointWidth: number;
+    pointColor: HexColor;
+    pointOutlineColor: HexColor;
+    pointOutlineWidth: number;
+};
+export declare class TerraDrawPointMode extends TerraDrawBaseDrawMode<PointModeStyling> {
     mode: string;
     constructor(options?: {
-        styling?: Partial<TerraDrawAdapterStyling>;
+        styles?: Partial<PointModeStyling>;
     });
+    /** @internal */
     start(): void;
+    /** @internal */
     stop(): void;
+    /** @internal */
     onClick(event: TerraDrawMouseEvent): void;
+    /** @internal */
     onMouseMove(): void;
+    /** @internal */
     onKeyDown(): void;
+    /** @internal */
     onKeyUp(): void;
+    /** @internal */
     cleanUp(): void;
+    /** @internal */
     onDragStart(): void;
+    /** @internal */
     onDrag(): void;
+    /** @internal */
     onDragEnd(): void;
+    /** @internal */
+    styleFeature(feature: GeoJSONStoreFeatures): TerraDrawAdapterStyling;
 }
+export {};

package/dist/modes/polygon/behaviors/closing-points.behavior.d.ts

@@ -0,0 +1,19 @@
+import { Position } from "geojson";
+import { BehaviorConfig, TerraDrawModeBehavior } from "../../base.behavior";
+import { TerraDrawMouseEvent } from "../../../common";
+import { PixelDistanceBehavior } from "../../pixel-distance.behavior";
+export declare class ClosingPointsBehavior extends TerraDrawModeBehavior {
+    readonly config: BehaviorConfig;
+    private readonly pixelDistance;
+    constructor(config: BehaviorConfig, pixelDistance: PixelDistanceBehavior);
+    private _startEndPoints;
+    get ids(): string[];
+    set ids(_: string[]);
+    create(selectedCoords: Position[], mode: string): void;
+    delete(): void;
+    update(updatedCoordinates: Position[]): void;
+    isClosingPoint(event: TerraDrawMouseEvent): {
+        isClosing: boolean;
+        isPreviousClosing: boolean;
+    };
+}

package/dist/modes/polygon/polygon.mode.d.ts

@@ -1,37 +1,63 @@
-import { TerraDrawMouseEvent, TerraDrawAdapterStyling, TerraDrawKeyboardEvent } from "../../common";
+import { TerraDrawMouseEvent, TerraDrawAdapterStyling, TerraDrawKeyboardEvent, HexColor } from "../../common";
 import { TerraDrawBaseDrawMode } from "../base.mode";
 import { BehaviorConfig } from "../base.behavior";
-declare type TerraDrawPolygonModeKeyEvents = {
-    cancel: KeyboardEvent["key"];
+import { GeoJSONStoreFeatures } from "../../store/store";
+type TerraDrawPolygonModeKeyEvents = {
+    cancel?: KeyboardEvent["key"] | null;
+    finish?: KeyboardEvent["key"] | null;
 };
-export declare class TerraDrawPolygonMode extends TerraDrawBaseDrawMode {
+type PolygonStyling = {
+    fillColor: HexColor;
+    outlineColor: HexColor;
+    outlineWidth: number;
+    fillOpacity: number;
+    closingPointWidth: number;
+    closingPointColor: HexColor;
+    closingPointOutlineWidth: number;
+    closingPointOutlineColor: HexColor;
+};
+export declare class TerraDrawPolygonMode extends TerraDrawBaseDrawMode<PolygonStyling> {
     mode: string;
     private currentCoordinate;
     private currentId;
     private allowSelfIntersections;
     private keyEvents;
     private snappingEnabled;
-    private isClosed;
     private snapping;
     private pixelDistance;
-    private startEndPoint;
+    private closingPoints;
+    private mouseMove;
     constructor(options?: {
         allowSelfIntersections?: boolean;
         snapping?: boolean;
-        styling?: Partial<TerraDrawAdapterStyling>;
         pointerDistance?: number;
-        keyEvents?: TerraDrawPolygonModeKeyEvents;
+        styles?: Partial<PolygonStyling>;
+        keyEvents?: TerraDrawPolygonModeKeyEvents | null;
     });
+    private close;
+    /** @internal */
     registerBehaviors(config: BehaviorConfig): void;
+    /** @internal */
     start(): void;
+    /** @internal */
     stop(): void;
+    /** @internal */
     onMouseMove(event: TerraDrawMouseEvent): void;
+    /** @internal */
     onClick(event: TerraDrawMouseEvent): void;
+    /** @internal */
     onKeyUp(event: TerraDrawKeyboardEvent): void;
+    /** @internal */
     onKeyDown(): void;
+    /** @internal */
     onDragStart(): void;
+    /** @internal */
     onDrag(): void;
+    /** @internal */
     onDragEnd(): void;
+    /** @internal */
     cleanUp(): void;
+    /** @internal */
+    styleFeature(feature: GeoJSONStoreFeatures): TerraDrawAdapterStyling;
 }
 export {};

package/dist/modes/rectangle/rectangle.mode.d.ts

@@ -0,0 +1,48 @@
+import { TerraDrawMouseEvent, TerraDrawAdapterStyling, TerraDrawKeyboardEvent, HexColor } from "../../common";
+import { GeoJSONStoreFeatures } from "../../store/store";
+import { TerraDrawBaseDrawMode } from "../base.mode";
+type TerraDrawRectangleModeKeyEvents = {
+    cancel: KeyboardEvent["key"] | null;
+    finish: KeyboardEvent["key"] | null;
+};
+type FreehandPolygonStyling = {
+    fillColor: HexColor;
+    outlineColor: HexColor;
+    outlineWidth: number;
+    fillOpacity: number;
+};
+export declare class TerraDrawRectangleMode extends TerraDrawBaseDrawMode<FreehandPolygonStyling> {
+    mode: string;
+    private center;
+    private clickCount;
+    private currentRectangleId;
+    private keyEvents;
+    constructor(options?: {
+        styles?: Partial<FreehandPolygonStyling>;
+        keyEvents?: TerraDrawRectangleModeKeyEvents | null;
+    });
+    private close;
+    /** @internal */
+    start(): void;
+    /** @internal */
+    stop(): void;
+    /** @internal */
+    onClick(event: TerraDrawMouseEvent): void;
+    /** @internal */
+    onMouseMove(event: TerraDrawMouseEvent): void;
+    /** @internal */
+    onKeyDown(): void;
+    /** @internal */
+    onKeyUp(event: TerraDrawKeyboardEvent): void;
+    /** @internal */
+    onDragStart(): void;
+    /** @internal */
+    onDrag(): void;
+    /** @internal */
+    onDragEnd(): void;
+    /** @internal */
+    cleanUp(): void;
+    /** @internal */
+    styleFeature(feature: GeoJSONStoreFeatures): TerraDrawAdapterStyling;
+}
+export {};

package/dist/modes/render/render.mode.d.ts

@@ -0,0 +1,34 @@
+import { TerraDrawAdapterStyling } from "../../common";
+import { TerraDrawBaseDrawMode } from "../base.mode";
+import { BehaviorConfig } from "../base.behavior";
+type RenderModeStylingExt<T extends TerraDrawAdapterStyling> = {};
+type RenderModeStyling = RenderModeStylingExt<TerraDrawAdapterStyling>;
+export declare class TerraDrawRenderMode extends TerraDrawBaseDrawMode<RenderModeStyling> {
+    mode: string;
+    constructor(options: {
+        styles: Partial<TerraDrawAdapterStyling>;
+    });
+    /** @internal */
+    registerBehaviors(behaviorConfig: BehaviorConfig): void;
+    /** @internal */
+    start(): void;
+    /** @internal */
+    stop(): void;
+    /** @internal */
+    onKeyUp(): void;
+    /** @internal */
+    onKeyDown(): void;
+    /** @internal */
+    onClick(): void;
+    /** @internal */
+    onDragStart(): void;
+    /** @internal */
+    onDrag(): void;
+    /** @internal */
+    onDragEnd(): void;
+    /** @internal */
+    onMouseMove(): void;
+    /** @internal */
+    styleFeature(): TerraDrawAdapterStyling;
+}
+export {};

package/dist/modes/select/select.mode.d.ts

@@ -1,13 +1,14 @@
-import { TerraDrawMouseEvent, TerraDrawKeyboardEvent } from "../../common";
+import { TerraDrawMouseEvent, TerraDrawKeyboardEvent, HexColor, TerraDrawAdapterStyling } from "../../common";
 import { TerraDrawBaseDrawMode } from "../base.mode";
 import { BehaviorConfig } from "../base.behavior";
-declare type TerraDrawSelectModeKeyEvents = {
-    deselect: KeyboardEvent["key"];
-    delete: KeyboardEvent["key"];
-    rotate: KeyboardEvent["key"];
-    scale: KeyboardEvent["key"];
+import { GeoJSONStoreFeatures } from "../../store/store";
+type TerraDrawSelectModeKeyEvents = {
+    deselect: KeyboardEvent["key"] | null;
+    delete: KeyboardEvent["key"] | null;
+    rotate: KeyboardEvent["key"] | null;
+    scale: KeyboardEvent["key"] | null;
 };
-declare type ModeFlags = {
+type ModeFlags = {
     feature?: {
         draggable?: boolean;
         rotateable?: boolean;
@@ -19,7 +20,20 @@ declare type ModeFlags = {
         };
     };
 };
-export declare class TerraDrawSelectMode extends TerraDrawBaseDrawMode {
+type SelectionStyling = {
+    selectedColor: HexColor;
+    selectedPointOutlineColor: HexColor;
+    selectPointOutlineWidth: number;
+    selectionPointWidth: number;
+    selectionPointColor: HexColor;
+    selectionPointOutlineColor: HexColor;
+    selectionPointOutlineWidth: number;
+    midPointColor: HexColor;
+    midPointOutlineColor: HexColor;
+    midPointWidth: number;
+    midPointOutlineWidth: number;
+};
+export declare class TerraDrawSelectMode extends TerraDrawBaseDrawMode<SelectionStyling> {
     mode: string;
     private dragEventThrottle;
     private dragEventCount;
@@ -36,11 +50,12 @@ export declare class TerraDrawSelectMode extends TerraDrawBaseDrawMode {
     private rotateFeature;
     private scaleFeature;
     constructor(options?: {
+        styles?: Partial<SelectionStyling>;
         pointerDistance?: number;
         flags?: {
             [mode: string]: ModeFlags;
         };
-        keyEvents?: TerraDrawSelectModeKeyEvents;
+        keyEvents?: TerraDrawSelectModeKeyEvents | null;
         dragEventThrottle?: number;
     });
     registerBehaviors(config: BehaviorConfig): void;
@@ -48,15 +63,27 @@ export declare class TerraDrawSelectMode extends TerraDrawBaseDrawMode {
     private deleteSelected;
     private onRightClick;
     private onLeftClick;
+    /** @internal */
     start(): void;
+    /** @internal */
     stop(): void;
+    /** @internal */
     onClick(event: TerraDrawMouseEvent): void;
+    /** @internal */
     onKeyDown(): void;
+    /** @internal */
     onKeyUp(event: TerraDrawKeyboardEvent): void;
+    /** @internal */
     cleanUp(): void;
+    /** @internal */
     onDragStart(event: TerraDrawMouseEvent, setMapDraggability: (enabled: boolean) => void): void;
+    /** @internal */
     onDrag(event: TerraDrawMouseEvent): void;
+    /** @internal */
     onDragEnd(_: TerraDrawMouseEvent, setMapDraggability: (enabled: boolean) => void): void;
+    /** @internal */
     onMouseMove(event: TerraDrawMouseEvent): void;
+    /** @internal */
+    styleFeature(feature: GeoJSONStoreFeatures): TerraDrawAdapterStyling;
 }
 export {};

package/dist/modes/static/static.mode.d.ts

@@ -1,5 +1,8 @@
+import { TerraDrawAdapterStyling } from "../../common";
 import { TerraDrawBaseDrawMode } from "../base.mode";
-export declare class TerraDrawStaticMode extends TerraDrawBaseDrawMode {
+type StaticModeStylingExt<T extends TerraDrawAdapterStyling> = {};
+type StaticModeStyling = StaticModeStylingExt<TerraDrawAdapterStyling>;
+export declare class TerraDrawStaticMode extends TerraDrawBaseDrawMode<StaticModeStyling> {
     mode: string;
     start(): void;
     stop(): void;
@@ -10,4 +13,18 @@ export declare class TerraDrawStaticMode extends TerraDrawBaseDrawMode {
     onDrag(): void;
     onDragEnd(): void;
     onMouseMove(): void;
+    styleFeature(): {
+        pointColor: `#${string}`;
+        pointWidth: number;
+        pointOutlineColor: `#${string}`;
+        pointOutlineWidth: number;
+        polygonFillColor: `#${string}`;
+        polygonFillOpacity: number;
+        polygonOutlineColor: `#${string}`;
+        polygonOutlineWidth: number;
+        lineStringWidth: number;
+        lineStringColor: `#${string}`;
+        zIndex: number;
+    };
 }
+export {};

package/dist/store/spatial-index/quickselect.d.ts

@@ -1,2 +1,2 @@
-export declare type CompareFunction<T> = (a: T, b: T) => number;
+export type CompareFunction<T> = (a: T, b: T) => number;
 export declare function quickselect<T>(arr: T[], k: number, left: number, right: number, compare: CompareFunction<T>): void;

package/dist/store/spatial-index/rbush.d.ts

@@ -1,4 +1,4 @@
-export declare type Node = {
+export type Node = {
     children: Node[];
     height: number;
     leaf: boolean;

package/dist/store/store.d.ts

@@ -1,16 +1,16 @@
 import { Feature, Point, Polygon, LineString } from "geojson";
-declare type JSON = string | number | boolean | null | JSONArray | JSONObject;
+type JSON = string | number | boolean | null | JSONArray | JSONObject;
 export interface JSONObject {
     [member: string]: JSON;
 }
-declare type JSONArray = Array<JSON>;
-declare type DefinedProperties = Record<string, JSON>;
-export declare type GeoJSONStoreGeometries = Polygon | LineString | Point;
-export declare type BBoxPolygon = Feature<Polygon, DefinedProperties>;
-export declare type GeoJSONStoreFeatures = Feature<GeoJSONStoreGeometries, DefinedProperties>;
-export declare type StoreChangeEvents = "delete" | "create" | "update";
-export declare type StoreChangeHandler = (ids: string[], change: StoreChangeEvents) => void;
-export declare type GeoJSONStoreConfig = {
+type JSONArray = Array<JSON>;
+type DefinedProperties = Record<string, JSON>;
+export type GeoJSONStoreGeometries = Polygon | LineString | Point;
+export type BBoxPolygon = Feature<Polygon, DefinedProperties>;
+export type GeoJSONStoreFeatures = Feature<GeoJSONStoreGeometries, DefinedProperties>;
+export type StoreChangeEvents = "delete" | "create" | "update";
+export type StoreChangeHandler = (ids: string[], change: StoreChangeEvents) => void;
+export type GeoJSONStoreConfig = {
     data?: GeoJSONStoreFeatures[];
     tracked?: boolean;
     validateFeature?: (feature: unknown, tracked?: boolean) => void;
@@ -44,5 +44,7 @@ export declare class GeoJSONStore {
     }[]): string[];
     delete(ids: string[]): void;
     copyAll(): GeoJSONStoreFeatures[];
+    clear(): void;
+    size(): number;
 }
 export {};