maplibre-gl-geo-editor 0.2.0 → 0.3.0

package/dist/types/index.d.ts

@@ -1 +1,1421 @@
+import { Feature } from 'geojson';
+import { FeatureCollection } from 'geojson';
+import { GeoJsonProperties } from 'geojson';
+import { Geometry } from 'geojson';
+import { IControl } from 'maplibre-gl';
+import { LineString } from 'geojson';
+import { Map as Map_2 } from 'maplibre-gl';
+import { MapMouseEvent } from 'maplibre-gl';
+import { MapTouchEvent } from 'maplibre-gl';
+import { MultiPolygon } from 'geojson';
+import { Point } from 'geojson';
+import { Polygon } from 'geojson';
+import { Position } from 'geojson';
+import * as turf from '@turf/turf';
+
+/**
+ * Add feature to selection
+ */
+export declare function addToSelection(selection: SelectedFeature[], feature: Feature, layerId?: string): SelectedFeature[];
+
+/**
+ * Advanced edit modes (our implementations)
+ */
+export declare const ADVANCED_EDIT_MODES: EditMode[];
+
+/**
+ * Calculate the bearing between two points in degrees
+ */
+export declare function bearingBetweenPoints(point1: Position, point2: Position): number;
+
+/**
+ * Calculate the area of a polygon in square meters
+ */
+export declare function calculateArea(feature: Feature<Polygon | MultiPolygon>): number;
+
+/**
+ * Calculate the length of a line in kilometers
+ */
+export declare function calculateLength(feature: Feature<LineString>): number;
+
+/**
+ * Calculate the scale factor between two bounding boxes
+ */
+export declare function calculateScaleFactor(originalBBox: [number, number, number, number], newBBox: [number, number, number, number]): number;
+
+/**
+ * Check if features can be merged (union)
+ * At least 2 polygons that overlap or touch
+ */
+export declare function canMergeFeatures(features: Feature[]): {
+    canMerge: boolean;
+    reason?: string;
+};
+
+/**
+ * Check if features can be used for difference operation
+ */
+export declare function canSubtractFeatures(features: Feature[]): {
+    canSubtract: boolean;
+    reason?: string;
+};
+
+/**
+ * Clamp a value between min and max
+ */
+export declare function clamp(value: number, min: number, max: number): number;
+
+/**
+ * Deep clone a feature
+ */
+export declare function cloneFeature<T extends Feature>(feature: T): T;
+
+/**
+ * Check if polygon1 contains polygon2
+ */
+export declare function contains(container: Feature<Polygon | MultiPolygon>, contained: Feature<Polygon | MultiPolygon>): boolean;
+
+/**
+ * Handles copy/paste operations for features
+ */
+export declare class CopyFeature {
+    private options;
+    constructor(options?: CopyOptions);
+    /**
+     * Copy a single feature with optional offset
+     */
+    copy(feature: Feature, offset?: [number, number]): Feature;
+    /**
+     * Copy multiple features maintaining relative positions
+     */
+    copyMultiple(features: Feature[], offset?: [number, number]): Feature[];
+    /**
+     * Copy features to a specific location (centered on the location)
+     */
+    copyToLocation(features: Feature[], targetCenter: [number, number]): Feature[];
+    /**
+     * Update the default offset
+     */
+    setOffset(offset: [number, number]): void;
+    /**
+     * Get the current offset
+     */
+    getOffset(): [number, number];
+}
+
+export declare interface CopyOptions {
+    /** Offset in [lng, lat] degrees for pasted features */
+    offset?: [number, number];
+    /** Generate new IDs for copied features */
+    generateNewIds?: boolean;
+}
+
+/**
+ * Create a feature collection
+ */
+export declare function createFeatureCollection<T extends Feature>(features: T[]): FeatureCollection;
+
+/**
+ * Create a line from coordinates
+ */
+export declare function createLine(coordinates: Position[], properties?: Record<string, unknown>): Feature<LineString>;
+
+/**
+ * Create a point from coordinates
+ */
+export declare function createPoint(coordinates: Position, properties?: Record<string, unknown>): Feature<Point>;
+
+/**
+ * Create a polygon from coordinates
+ */
+export declare function createPolygon(coordinates: Position[][], properties?: Record<string, unknown>): Feature<Polygon>;
+
+/**
+ * CSS class prefix for the plugin
+ */
+export declare const CSS_PREFIX = "geo-editor";
+
+/**
+ * Default draw modes available in the toolbar
+ */
+export declare const DEFAULT_DRAW_MODES: DrawMode[];
+
+/**
+ * Default edit modes available in the toolbar
+ */
+export declare const DEFAULT_EDIT_MODES: EditMode[];
+
+/**
+ * Default file modes
+ */
+export declare const DEFAULT_FILE_MODES: FileMode[];
+
+/**
+ * Default options for GeoEditor
+ */
+export declare const DEFAULT_OPTIONS: GeoEditorOptionsRequired;
+
+/**
+ * Convert degrees to radians
+ */
+export declare function degreesToRadians(degrees: number): number;
+
+/**
+ * Handles polygon difference/subtraction operations
+ */
+export declare class DifferenceFeature {
+    /**
+     * Subtract one or more polygons from a base polygon
+     */
+    difference(base: Feature<Polygon | MultiPolygon>, subtract: Feature<Polygon | MultiPolygon>[], options?: DifferenceOptions): DifferenceResult;
+    /**
+     * Check if subtraction can be performed
+     */
+    canSubtract(base: Feature<Polygon | MultiPolygon>, subtract: Feature<Polygon | MultiPolygon>): {
+        canSubtract: boolean;
+        overlap: boolean;
+        reason?: string;
+    };
+    /**
+     * Get the area that would be removed
+     */
+    getSubtractedArea(base: Feature<Polygon | MultiPolygon>, subtract: Feature<Polygon | MultiPolygon>): number | null;
+    /**
+     * Preview the result without applying
+     */
+    preview(base: Feature<Polygon | MultiPolygon>, subtract: Feature<Polygon | MultiPolygon>[]): Feature<Polygon | MultiPolygon> | null;
+    /**
+     * Create a hole in a polygon at a specific location
+     */
+    createHole(polygon: Feature<Polygon>, hole: Feature<Polygon>): Feature<Polygon | MultiPolygon> | null;
+}
+
+export declare interface DifferenceOptions {
+    /** Properties to use for the result feature */
+    properties?: GeoJsonProperties;
+}
+
+export declare interface DifferenceResult {
+    /** Resulting feature after subtraction */
+    result: Feature<Polygon | MultiPolygon> | null;
+    /** Base feature */
+    base: Feature<Polygon | MultiPolygon>;
+    /** Features that were subtracted */
+    subtracted: Feature<Polygon | MultiPolygon>[];
+    /** Whether the operation was successful */
+    success: boolean;
+    /** Error message if operation failed */
+    error?: string;
+}
+
+/**
+ * Calculate the distance between two points in kilometers
+ */
+export declare function distanceBetweenPoints(point1: Position, point2: Position): number;
+
+/**
+ * Available draw modes.
+ * Note: 'freehand' is implemented as a custom feature (not dependent on Geoman Pro).
+ */
+export declare type DrawMode = 'marker' | 'circle' | 'circle_marker' | 'ellipse' | 'text_marker' | 'line' | 'rectangle' | 'polygon' | 'freehand';
+
+export declare type EditMode = 'drag' | 'change' | 'rotate' | 'cut' | 'delete' | 'select' | 'scale' | 'copy' | 'split' | 'union' | 'difference' | 'simplify' | 'lasso';
+
+/**
+ * Ensure a feature has an ID
+ */
+export declare function ensureFeatureId(feature: Feature): Feature;
+
+export declare type FileMode = 'open' | 'save';
+
+/**
+ * Filter features by geometry type
+ */
+export declare function filterByGeometryType(features: Feature[], types: string[]): Feature[];
+
+/**
+ * Convert SelectedFeature array to Feature array
+ */
+export declare function fromSelectedFeatures(selected: SelectedFeature[]): Feature[];
+
+/**
+ * Generate a unique ID for a feature
+ */
+export declare function generateFeatureId(): string;
+
+/**
+ * GeoEditor - Advanced geometry editing control for MapLibre GL
+ * Extends the free Geoman control with advanced features
+ */
+export declare class GeoEditor implements IControl {
+    private map;
+    private geoman;
+    private container;
+    private options;
+    private state;
+    private copyFeature;
+    private simplifyFeature;
+    private unionFeature;
+    private differenceFeature;
+    private scaleFeature;
+    private lassoFeature;
+    private splitFeature;
+    private freehandFeature;
+    private boundKeyHandler;
+    private boundClickHandler;
+    private boundScaleMouseDown;
+    private boundScaleMouseMove;
+    private boundScaleMouseUp;
+    private isSelectMode;
+    private pendingOperation;
+    private snappingEnabled;
+    private lastCreatedFeature;
+    private lastEditedFeature;
+    private lastDeletedFeature;
+    private lastDeletedFeatureId;
+    private isScaling;
+    private scaleTargetFeature;
+    private scaleTargetGeomanData;
+    private scaleStartFeature;
+    private scaleDragPanEnabled;
+    private isMultiDragging;
+    private multiDragStartPoint;
+    private multiDragOriginalFeatures;
+    private multiDragGeomanData;
+    private multiDragPanEnabled;
+    private boundMultiDragMouseDown;
+    private boundMultiDragMouseMove;
+    private boundMultiDragMouseUp;
+    private toolbar;
+    private fileInput;
+    private propertiesPopup;
+    constructor(options?: GeoEditorOptions);
+    /**
+     * Called when the control is added to the map
+     */
+    onAdd(map: Map_2): HTMLElement;
+    /**
+     * Called when the control is removed from the map
+     */
+    onRemove(): void;
+    /**
+     * Set the Geoman instance for integration
+     */
+    setGeoman(geoman: GeomanInstance): void;
+    /**
+     * Hide the geoman control toolbar
+     */
+    private hideGeomanControl;
+    /**
+     * Setup click handler for feature selection
+     */
+    private setupSelectionHandler;
+    /**
+     * Find a feature at a given point
+     */
+    private findFeatureAtPoint;
+    /**
+     * Find a feature at the mouse event using Geoman's hit test
+     */
+    private findFeatureByMouseEvent;
+    /**
+     * Find geoman data for a feature by searching
+     */
+    private findGeomanDataForFeature;
+    private getGeomanIdFromFeature;
+    private getGeomanFeature;
+    /**
+     * Remove selection handler
+     */
+    private removeSelectionHandler;
+    /**
+     * Setup mouse handlers for scale mode
+     */
+    private setupScaleHandler;
+    /**
+     * Remove scale handlers
+     */
+    private removeScaleHandler;
+    /**
+     * Setup mouse handlers for multi-drag when multiple features are selected
+     */
+    private setupMultiDragHandler;
+    private removeMultiDragHandler;
+    private disableMultiDragPan;
+    private restoreMultiDragPan;
+    private getScaleHandleFromEvent;
+    private disableScaleDragPan;
+    private restoreScaleDragPan;
+    private applyScaledFeature;
+    private bringScaleHandlesToFront;
+    private logSelectedFeatureCollection;
+    private extractFeatureFromEvent;
+    /**
+     * Toggle feature in selection
+     */
+    private toggleFeatureSelection;
+    /**
+     * Enable select mode
+     */
+    enableSelectMode(): void;
+    /**
+     * Disable select mode
+     */
+    disableSelectMode(): void;
+    /**
+     * Get the current state
+     */
+    getState(): GeoEditorState;
+    /**
+     * Get selected features
+     */
+    getSelectedFeatures(): Feature[];
+    getSelectedFeatureCollection(): FeatureCollection;
+    /**
+     * Get all features from the map
+     */
+    getFeatures(): FeatureCollection;
+    getAllFeatureCollection(): FeatureCollection;
+    getLastCreatedFeature(): Feature | null;
+    getLastEditedFeature(): Feature | null;
+    getLastDeletedFeature(): Feature | null;
+    getLastDeletedFeatureId(): string | null;
+    /**
+     * Enable a draw mode
+     */
+    enableDrawMode(mode: DrawMode): void;
+    /**
+     * Enable freehand drawing mode (custom implementation)
+     */
+    private enableFreehandMode;
+    /**
+     * Disable freehand drawing mode
+     */
+    private disableFreehandMode;
+    /**
+     * Enable an edit mode
+     */
+    enableEditMode(mode: EditMode): void;
+    /**
+     * Disable all modes
+     */
+    disableAllModes(): void;
+    /**
+     * Enable an advanced edit mode
+     */
+    private enableAdvancedEditMode;
+    /**
+     * Enable union mode (interactive polygon selection)
+     */
+    private enableUnionMode;
+    /**
+     * Enable difference mode (interactive polygon selection)
+     */
+    private enableDifferenceMode;
+    /**
+     * Execute the pending operation (union/difference)
+     */
+    executePendingOperation(): void;
+    /**
+     * Cancel pending operation
+     */
+    cancelPendingOperation(): void;
+    /**
+     * Setup selection highlight layer
+     */
+    private setupSelectionHighlight;
+    /**
+     * Update selection highlight on the map
+     */
+    private updateSelectionHighlight;
+    /**
+     * Select features
+     */
+    selectFeatures(features: Feature[], geomanDataList?: GeomanFeatureData[]): void;
+    /**
+     * Add feature to selection
+     */
+    addToSelection(feature: Feature, geomanData?: GeomanFeatureData): void;
+    /**
+     * Remove feature from selection
+     */
+    removeFromSelection(featureId: string): void;
+    /**
+     * Clear selection
+     */
+    clearSelection(): void;
+    /**
+     * Show popup with feature properties
+     */
+    private showFeaturePropertiesPopup;
+    /**
+     * Hide feature properties popup
+     */
+    private hideFeaturePropertiesPopup;
+    /**
+     * Format feature properties as HTML table
+     */
+    private formatPropertiesHtml;
+    /**
+     * Escape HTML special characters
+     */
+    private escapeHtml;
+    /**
+     * Enable scale mode
+     */
+    private enableScaleMode;
+    /**
+     * Enable copy mode
+     */
+    private enableCopyMode;
+    /**
+     * Enable split mode
+     */
+    private enableSplitMode;
+    /**
+     * Enable lasso selection mode
+     */
+    private enableLassoMode;
+    /**
+     * Execute union on selected polygons
+     */
+    private executeUnion;
+    /**
+     * Execute difference on selected polygons
+     */
+    private executeDifference;
+    /**
+     * Execute simplify on selected features
+     */
+    private executeSimplify;
+    private getSimplifyResult;
+    /**
+     * Copy selected features to clipboard
+     */
+    copySelectedFeatures(): void;
+    /**
+     * Paste features from clipboard
+     */
+    pasteFeatures(): void;
+    /**
+     * Delete a feature by ID
+     */
+    private deleteFeatureById;
+    /**
+     * Delete selected features
+     */
+    deleteSelectedFeatures(): void;
+    private deleteGeomanFeatureData;
+    private deleteGeomanFeatures;
+    private clearGeomanTemporaryFeatures;
+    private handleSplitResult;
+    private handleUnionResult;
+    private handleDifferenceResult;
+    private applySimplifyResult;
+    private handleLassoResult;
+    /**
+     * Create the toolbar UI
+     */
+    private createToolbar;
+    /**
+     * Create the collapse/expand button
+     */
+    private createCollapseButton;
+    /**
+     * Toggle toolbar collapsed state
+     */
+    toggleCollapse(): void;
+    /**
+     * Check if toolbar is collapsed
+     */
+    isCollapsed(): boolean;
+    /**
+     * Set toolbar collapsed state
+     */
+    setCollapsed(collapsed: boolean): void;
+    /**
+     * Create helper tools group (snapping toggle)
+     */
+    private createHelperToolsGroup;
+    private createResetToolsGroup;
+    /**
+     * Create file tools group (open/save GeoJSON)
+     */
+    private createFileToolsGroup;
+    /**
+     * Setup hidden file input for file dialog
+     */
+    private setupFileInput;
+    /**
+     * Open file dialog to select GeoJSON file
+     */
+    openFileDialog(): void;
+    /**
+     * Handle file selection from file dialog
+     */
+    private handleFileSelect;
+    /**
+     * Load GeoJSON data into the editor
+     * @param geoJson - FeatureCollection or Feature to load
+     * @param filename - Optional filename for logging
+     * @returns Result of the load operation
+     */
+    loadGeoJson(geoJson: FeatureCollection | Feature, filename?: string): GeoJsonLoadResult;
+    /**
+     * Fit the map bounds to show all features in a FeatureCollection
+     */
+    private fitBoundsToFeatures;
+    /**
+     * Check if a bounding box is valid
+     */
+    private isValidBBox;
+    /**
+     * Fit the map to show all current features
+     */
+    fitToAllFeatures(): void;
+    /**
+     * Save current features as GeoJSON file download
+     * @param filename - Optional filename for download
+     * @returns Result of the save operation
+     */
+    saveGeoJson(filename?: string): GeoJsonSaveResult;
+    /**
+     * Toggle snapping on/off (independent of other modes)
+     * Note: Snapping functionality requires Geoman Pro. In the free version,
+     * this toggle tracks state but does not enable actual vertex snapping.
+     */
+    toggleSnapping(): void;
+    /**
+     * Check if snapping is enabled
+     */
+    isSnappingEnabled(): boolean;
+    /**
+     * Set snapping state
+     */
+    setSnapping(enabled: boolean): void;
+    private applySnappingState;
+    /**
+     * Create a tool group
+     */
+    private createToolGroup;
+    /**
+     * Create a tool button
+     */
+    private createToolButton;
+    /**
+     * Update toolbar button states
+     */
+    private updateToolbarState;
+    /**
+     * Get human-readable label for a mode
+     */
+    private getModeLabel;
+    /**
+     * Get SVG icon for a mode
+     */
+    private getModeIcon;
+    private setupKeyboardShortcuts;
+    private removeKeyboardShortcuts;
+    private setupGeomanEvents;
+    private emitEvent;
+}
+
+export declare interface GeoEditorEventMap {
+    'gm:scale': {
+        feature: Feature;
+        scaleFactor: number;
+    };
+    'gm:scalestart': {
+        feature: Feature;
+    };
+    'gm:scaleend': {
+        feature: Feature;
+        scaleFactor: number;
+    };
+    'gm:copy': {
+        features: Feature[];
+    };
+    'gm:paste': {
+        features: Feature[];
+    };
+    'gm:split': SplitResult;
+    'gm:union': UnionResult;
+    'gm:difference': DifferenceResult;
+    'gm:simplify': SimplifyResult;
+    'gm:lassostart': Record<string, never>;
+    'gm:lassoend': LassoResult;
+    'gm:selectionchange': {
+        features: Feature[];
+    };
+    'gm:modechange': {
+        mode: DrawMode | EditMode | null;
+    };
+    'gm:geojsonload': GeoJsonLoadResult;
+    'gm:geojsonsave': GeoJsonSaveResult;
+}
+
+export declare type GeoEditorEventType = keyof GeoEditorEventMap;
+
+export declare interface GeoEditorOptions {
+    /** Position of the control on the map */
+    position?: ToolbarPosition;
+    /** Whether the toolbar starts collapsed */
+    collapsed?: boolean;
+    /** Draw modes to enable */
+    drawModes?: DrawMode[];
+    /** Edit modes to enable */
+    editModes?: EditMode[];
+    /** Helper modes to enable */
+    helperModes?: HelperMode[];
+    /** Toolbar orientation */
+    toolbarOrientation?: ToolbarOrientation;
+    /** Show text labels on toolbar buttons */
+    showLabels?: boolean;
+    /** Default tolerance for line simplification */
+    simplifyTolerance?: number;
+    /** Enable snapping by default */
+    snappingEnabled?: boolean;
+    /** Enable measurements by default */
+    measurementsEnabled?: boolean;
+    /** Hide the geoman control (use GeoEditor toolbar instead) */
+    hideGeomanControl?: boolean;
+    /** Callback when a feature is created */
+    onFeatureCreate?: (feature: Feature) => void;
+    /** Callback when a feature is edited */
+    onFeatureEdit?: (feature: Feature, oldFeature: Feature) => void;
+    /** Callback when a feature is deleted */
+    onFeatureDelete?: (featureId: string) => void;
+    /** Callback when selection changes */
+    onSelectionChange?: (features: Feature[]) => void;
+    /** Callback when mode changes */
+    onModeChange?: (mode: DrawMode | EditMode | null) => void;
+    /** File modes to enable (default: ['open', 'save']) */
+    fileModes?: FileMode[];
+    /** Default filename for saving GeoJSON (default: 'features.geojson') */
+    saveFilename?: string;
+    /** Callback when GeoJSON is loaded */
+    onGeoJsonLoad?: (result: GeoJsonLoadResult) => void;
+    /** Callback when GeoJSON is saved */
+    onGeoJsonSave?: (result: GeoJsonSaveResult) => void;
+    /** Show feature properties in a popup when selected (default: false) */
+    showFeatureProperties?: boolean;
+    /** Auto-fit map bounds when GeoJSON is loaded (default: true) */
+    fitBoundsOnLoad?: boolean;
+    /** Number of columns for button layout in vertical orientation (default: 1) */
+    columns?: number;
+}
+
+declare type GeoEditorOptionsRequired = Required<GeoEditorOptions>;
+
+export declare interface GeoEditorState {
+    /** Currently active draw mode */
+    activeDrawMode: DrawMode | null;
+    /** Currently active edit mode */
+    activeEditMode: EditMode | null;
+    /** Currently selected features */
+    selectedFeatures: SelectedFeature[];
+    /** Whether currently drawing */
+    isDrawing: boolean;
+    /** Whether currently editing */
+    isEditing: boolean;
+    /** Features in clipboard for copy/paste */
+    clipboard: Feature[];
+    /** Whether toolbar is collapsed */
+    collapsed: boolean;
+}
+
+export declare interface GeoJsonLoadResult {
+    /** Successfully loaded features */
+    features: Feature[];
+    /** Number of features loaded */
+    count: number;
+    /** Original filename */
+    filename: string;
+}
+
+export declare interface GeoJsonSaveResult {
+    /** The saved FeatureCollection */
+    featureCollection: FeatureCollection;
+    /** Number of features saved */
+    count: number;
+    /** Filename used for download */
+    filename: string;
+}
+
+declare interface GeomanEventParameters {
+    type: string;
+    feature?: Feature;
+    shape?: string;
+    [key: string]: any;
+}
+
+declare interface GeomanFeatureData {
+    id: string | number;
+    shape: string;
+    geoJson?: Feature;
+    getGeoJson?: () => Feature;
+    updateGeometry?: (geometry: Geometry) => void;
+    updateGeoJsonGeometry?: (geometry: Geometry) => void;
+    temporary?: boolean;
+    delete: () => void;
+}
+
+export declare interface GeomanFeaturesAPI {
+    getAll: () => FeatureCollection;
+    get: (sourceName: string, featureId: string) => GeomanFeatureData | null;
+    forEach: (callback: (feature: GeomanFeatureData) => void) => void;
+    tmpForEach?: (callback: (feature: GeomanFeatureData) => void) => void;
+    has: (sourceName: string, featureId: string) => boolean;
+    delete: (featureData: GeomanFeatureData) => void;
+    deleteAll: () => void;
+    importGeoJson: (geoJson: FeatureCollection, options?: {
+        overwrite?: boolean;
+    }) => {
+        success: number;
+        failed: number;
+    };
+    importGeoJsonFeature: (feature: Feature) => GeomanFeatureData | null;
+    getFeatureByMouseEvent: (options: {
+        event: MapMouseEvent | MapTouchEvent;
+        sourceNames?: string[];
+    }) => GeomanFeatureData | null;
+    getFeaturesByScreenBounds: (options: {
+        bounds: [[number, number], [number, number]];
+        sourceNames?: string[];
+    }) => GeomanFeatureData[];
+}
+
+export declare interface GeomanInstance {
+    enableDraw: (shape: DrawMode) => void;
+    disableDraw: () => void;
+    toggleDraw: (shape: DrawMode) => void;
+    drawEnabled: (shape?: DrawMode) => boolean;
+    enableMode: (modeType: 'draw' | 'edit' | 'helper', mode: string) => void;
+    disableMode: (modeType: 'draw' | 'edit' | 'helper', mode: string) => void;
+    toggleMode: (modeType: 'draw' | 'edit' | 'helper', mode: string) => void;
+    isModeEnabled: (modeType: 'draw' | 'edit' | 'helper', mode: string) => boolean;
+    enableGlobalEditMode: () => void;
+    disableGlobalEditMode: () => void;
+    toggleGlobalEditMode: () => void;
+    globalEditModeEnabled: () => boolean;
+    enableGlobalDragMode: () => void;
+    disableGlobalDragMode: () => void;
+    toggleGlobalDragMode: () => void;
+    globalDragModeEnabled: () => boolean;
+    enableGlobalRotateMode: () => void;
+    disableGlobalRotateMode: () => void;
+    toggleGlobalRotateMode: () => void;
+    globalRotateModeEnabled: () => boolean;
+    enableGlobalCutMode: () => void;
+    disableGlobalCutMode: () => void;
+    toggleGlobalCutMode: () => void;
+    globalCutModeEnabled: () => boolean;
+    enableGlobalRemovalMode: () => void;
+    disableGlobalRemovalMode: () => void;
+    toggleGlobalRemovalMode: () => void;
+    globalRemovalModeEnabled: () => boolean;
+    disableAllModes: () => void;
+    addControls: (controlsElement?: HTMLElement) => Promise<void>;
+    removeControls: () => void;
+    setGlobalEventsListener: (callback?: (parameters: GeomanEventParameters) => void) => void;
+    features: GeomanFeaturesAPI;
+}
+
+/**
+ * Get bounding box of a feature
+ */
+export declare function getBBox(feature: Feature): [number, number, number, number];
+
+/**
+ * Get the bounding box center of a feature
+ */
+export declare function getBBoxCenter(feature: Feature): Position;
+
+/**
+ * Get the bounding box corners as coordinates
+ */
+export declare function getBBoxCorners(feature: Feature): Position[];
+
+/**
+ * Get the midpoints of the bounding box edges
+ */
+export declare function getBBoxMidpoints(feature: Feature): Position[];
+
+/**
+ * Get the center point of a feature
+ */
+export declare function getCenter(feature: Feature): Position;
+
+/**
+ * Get all coordinates from a feature
+ */
+export declare function getCoordAll(feature: Feature): Position[];
+
+/**
+ * Get the feature ID, generating one if it doesn't exist
+ */
+export declare function getFeatureId(feature: Feature): string;
+
+/**
+ * Get only polygon features from a collection
+ */
+export declare function getPolygonFeatures(features: Feature[]): Feature<Polygon>[];
+
+/**
+ * Get vertex count of a feature
+ */
+export declare function getVertexCount(feature: Feature): number;
+
+export declare type HelperMode = 'snapping' | 'measurements';
+
+/**
+ * Check if two features intersect
+ */
+export declare function intersects(feature1: Feature, feature2: Feature): boolean;
+
+/**
+ * Check if a feature is in the selection
+ */
+export declare function isFeatureSelected(feature: Feature, selection: SelectedFeature[]): boolean;
+
+/**
+ * Check if a feature is a line
+ */
+export declare function isLine(feature: Feature): feature is Feature<LineString>;
+
+/**
+ * Check if a feature is a point
+ */
+export declare function isPoint(feature: Feature): feature is Feature<Point>;
+
+/**
+ * Check if a feature is a polygon
+ */
+export declare function isPolygon(feature: Feature): feature is Feature<Polygon>;
+
+/**
+ * Check if selection contains only polygons
+ */
+export declare function isPolygonOnlySelection(features: Feature[]): boolean;
+
+/**
+ * Check if a feature has a valid geometry
+ */
+export declare function isValidGeometry(feature: Feature): boolean;
+
+/**
+ * Check if a feature is within another feature
+ */
+export declare function isWithin(feature: Feature, container: Feature): boolean;
+
+/**
+ * Handles lasso selection of features
+ */
+export declare class LassoFeature {
+    private map;
+    private isDrawing;
+    private points;
+    private options;
+    private onCompleteCallback;
+    private dragPanEnabled;
+    private boxZoomEnabled;
+    private doubleClickZoomEnabled;
+    private handleMouseDown;
+    private handleMouseMove;
+    private handleMouseUp;
+    constructor(options?: LassoOptions);
+    /**
+     * Initialize with map instance
+     */
+    init(map: Map_2): void;
+    /**
+     * Enable lasso selection mode
+     */
+    enable(onComplete?: (result: LassoResult) => void): void;
+    /**
+     * Disable lasso selection mode
+     */
+    disable(): void;
+    /**
+     * Get features within the lasso polygon
+     */
+    selectWithinLasso(lassoPolygon: Feature<Polygon>, features: Feature[]): Feature[];
+    /**
+     * Build polygon from drawn points
+     */
+    buildLassoPolygon(): Feature<Polygon> | null;
+    /**
+     * Set selection mode
+     */
+    setMode(mode: 'contains' | 'intersects'): void;
+    /**
+     * Check if lasso is currently active
+     */
+    isActive(): boolean;
+    /**
+     * Setup map layers for lasso visualization
+     */
+    private setupLassoLayers;
+    /**
+     * Attach mouse event listeners
+     */
+    private attachEventListeners;
+    /**
+     * Remove event listeners
+     */
+    private removeEventListeners;
+    /**
+     * Update the lasso visualization on the map
+     */
+    private updateLassoVisualization;
+    /**
+     * Complete the lasso selection
+     */
+    private completeLasso;
+    /**
+     * Clear the lasso visualization
+     */
+    private clearLasso;
+    private disableMapInteractions;
+    private restoreMapInteractions;
+    /**
+     * Remove lasso layers from the map
+     */
+    removeLayers(): void;
+    /**
+     * Cleanup resources
+     */
+    destroy(): void;
+}
+
+export declare interface LassoOptions {
+    /** Selection mode: 'contains' or 'intersects' */
+    mode?: 'contains' | 'intersects';
+}
+
+export declare interface LassoResult {
+    /** Features selected by the lasso */
+    selected: Feature[];
+    /** The lasso polygon used for selection */
+    lasso: Feature<Polygon>;
+}
+
+/**
+ * Check if two polygons overlap
+ */
+export declare function overlaps(feature1: Feature<Polygon | MultiPolygon>, feature2: Feature<Polygon | MultiPolygon>): boolean;
+
+/**
+ * Convert polygon to line
+ */
+export declare function polygonToLine(polygon: Feature<Polygon | MultiPolygon>): ReturnType<typeof turf.polygonToLine>;
+
+/**
+ * Check if two positions are approximately equal
+ */
+export declare function positionsEqual(pos1: Position, pos2: Position, tolerance?: number): boolean;
+
+/**
+ * Convert radians to degrees
+ */
+export declare function radiansToDegrees(radians: number): number;
+
+/**
+ * Remove feature from selection
+ */
+export declare function removeFromSelection(selection: SelectedFeature[], featureId: string): SelectedFeature[];
+
+/**
+ * Round coordinates to a specified precision
+ */
+export declare function roundCoordinates(coordinates: Position, precision?: number): Position;
+
+/**
+ * Get centroid with fallback for invalid geometries
+ */
+export declare function safeCentroid(feature: Feature): Feature<Point>;
+
+/**
+ * Safe wrapper for turf.clone
+ */
+export declare function safeClone<T extends Feature>(feature: T): T;
+
+/**
+ * Safe wrapper for turf.difference
+ */
+export declare function safeDifference(polygon1: Feature<Polygon | MultiPolygon>, polygon2: Feature<Polygon | MultiPolygon>): Feature<Polygon | MultiPolygon> | null;
+
+/**
+ * Safe wrapper for turf.lineIntersect
+ */
+export declare function safeLineIntersect(line1: Feature<LineString>, line2: Feature<LineString>): FeatureCollection<Point>;
+
+/**
+ * Safe wrapper for turf.lineSplit
+ */
+export declare function safeLineSplit(line: Feature<LineString>, splitter: Feature<LineString>): FeatureCollection<LineString>;
+
+/**
+ * Safe wrapper for turf.transformScale
+ */
+export declare function safeScale(feature: Feature, factor: number, origin?: Position): Feature;
+
+/**
+ * Safe wrapper for turf.simplify
+ */
+export declare function safeSimplify<T extends Feature>(feature: T, options: {
+    tolerance: number;
+    highQuality?: boolean;
+}): T;
+
+/**
+ * Safe wrapper for turf.transformTranslate
+ */
+export declare function safeTranslate(feature: Feature, distance: number, direction: number): Feature;
+
+/**
+ * Safe wrapper for turf.union that handles edge cases
+ */
+export declare function safeUnion(features: Feature<Polygon | MultiPolygon>[]): Feature<Polygon | MultiPolygon> | null;
+
+/**
+ * Handles interactive scaling of features
+ */
+export declare class ScaleFeature {
+    private map;
+    private options;
+    private activeFeature;
+    private originalFeature;
+    private handles;
+    private activeHandle;
+    private startPoint;
+    private onScaleCallback;
+    constructor(options?: ScaleOptions);
+    /**
+     * Initialize with map instance
+     */
+    init(map: Map_2): void;
+    /**
+     * Scale a feature by a given factor
+     */
+    scale(feature: Feature, factor: number, origin?: Position): Feature;
+    /**
+     * Scale feature by dragging from a specific handle
+     */
+    scaleFromHandle(feature: Feature, handlePosition: ScaleHandlePosition, startPoint: Position, currentPoint: Position): Feature;
+    /**
+     * Create scale handles for a feature
+     */
+    createHandles(feature: Feature): ScaleHandle[];
+    /**
+     * Start scaling operation
+     */
+    startScale(feature: Feature, handlePosition: ScaleHandlePosition, startPoint: Position, onScale?: (feature: Feature, factor: number) => void): void;
+    /**
+     * Show scale handles without starting a drag operation
+     */
+    showHandlesForFeature(feature: Feature): void;
+    /**
+     * Update scaling during drag
+     */
+    updateScale(currentPoint: Position): Feature | null;
+    /**
+     * End scaling operation
+     */
+    endScale(): {
+        feature: Feature;
+        factor: number;
+    } | null;
+    /**
+     * Cancel scaling operation
+     */
+    cancelScale(): void;
+    /**
+     * Show scale handles on the map
+     */
+    private showHandles;
+    /**
+     * Update handle positions after scaling
+     */
+    private updateHandlePositions;
+    /**
+     * Hide scale handles from the map
+     */
+    private hideHandles;
+    /**
+     * Calculate distance from a point to the center
+     */
+    private distanceFromCenter;
+    /**
+     * Get the opposite corner for scaling origin
+     */
+    private getOppositeCorner;
+    /**
+     * Get handle at a specific point
+     */
+    getHandleAtPoint(point: Position, tolerance?: number): ScaleHandlePosition | null;
+    /**
+     * Cleanup resources
+     */
+    destroy(): void;
+}
+
+export declare interface ScaleHandle {
+    position: ScaleHandlePosition;
+    coordinates: [number, number];
+}
+
+export declare type ScaleHandlePosition = 'nw' | 'n' | 'ne' | 'e' | 'se' | 's' | 'sw' | 'w';
+
+export declare interface ScaleOptions {
+    /** Maintain aspect ratio during scaling */
+    maintainAspectRatio?: boolean;
+    /** Scale from center of feature */
+    scaleFromCenter?: boolean;
+    /** Minimum scale factor */
+    minScale?: number;
+    /** Maximum scale factor */
+    maxScale?: number;
+}
+
+export declare interface SelectedFeature {
+    id: string;
+    feature: Feature;
+    layerId: string;
+    /** Reference to geoman feature data for deletion */
+    geomanData?: GeomanFeatureData;
+}
+
+/**
+ * Filter features that are within a lasso polygon
+ */
+export declare function selectFeaturesWithinLasso(features: Feature[], lasso: Feature<Polygon>, mode?: 'contains' | 'intersects'): Feature[];
+
+/**
+ * Handles line/polygon simplification using Douglas-Peucker algorithm
+ */
+export declare class SimplifyFeature {
+    private defaultOptions;
+    constructor(options?: Partial<SimplifyOptions>);
+    /**
+     * Simplify a geometry using Douglas-Peucker algorithm
+     */
+    simplify<T extends Feature>(feature: T, options?: Partial<SimplifyOptions>): T;
+    /**
+     * Simplify and return detailed result with statistics
+     */
+    simplifyWithStats(feature: Feature, options?: Partial<SimplifyOptions>): SimplifyResult;
+    /**
+     * Get simplification statistics without applying
+     */
+    getSimplificationStats(feature: Feature, tolerance: number): {
+        before: number;
+        after: number;
+        reduction: number;
+    };
+    /**
+     * Preview simplification at different tolerance levels
+     */
+    previewTolerances(feature: Feature, tolerances: number[]): Map<number, SimplifyResult>;
+    /**
+     * Get suggested tolerance values based on feature complexity
+     */
+    getSuggestedTolerances(feature: Feature): number[];
+    /**
+     * Find optimal tolerance for a target vertex reduction
+     */
+    findOptimalTolerance(feature: Feature, targetReduction: number): {
+        tolerance: number;
+        result: SimplifyResult;
+    };
+    /**
+     * Set default tolerance
+     */
+    setDefaultTolerance(tolerance: number): void;
+    /**
+     * Get default tolerance
+     */
+    getDefaultTolerance(): number;
+}
+
+export declare interface SimplifyOptions {
+    /** Tolerance for simplification (in degrees) */
+    tolerance: number;
+    /** Use high quality simplification */
+    highQuality?: boolean;
+    /** Mutate original feature */
+    mutate?: boolean;
+}
+
+export declare interface SimplifyResult {
+    /** Simplified feature */
+    result: Feature;
+    /** Original feature */
+    original: Feature;
+    /** Number of vertices before */
+    verticesBefore: number;
+    /** Number of vertices after */
+    verticesAfter: number;
+    /** Reduction percentage */
+    reductionPercent: number;
+}
+
+/**
+ * Handles splitting of polygons and lines
+ */
+export declare class SplitFeature {
+    private map;
+    private isDrawing;
+    private splitLinePoints;
+    private targetFeature;
+    private onCompleteCallback;
+    private handleClick;
+    private handleMouseMove;
+    private handleDblClick;
+    constructor();
+    /**
+     * Initialize with map instance
+     */
+    init(map: Map_2): void;
+    /**
+     * Split a polygon with a line
+     */
+    splitPolygon(polygon: Feature<Polygon>, splitter: Feature<LineString>, _options?: SplitOptions): SplitResult;
+    /**
+     * Split a line with a point or another line
+     */
+    splitLine(line: Feature<LineString>, splitter: Feature<LineString>): SplitResult;
+    /**
+     * Start interactive split mode
+     */
+    startSplit(feature: Feature<Polygon | LineString>, onComplete: (result: SplitResult) => void): void;
+    /**
+     * Cancel the split operation
+     */
+    cancelSplit(): void;
+    /**
+     * Check if split mode is active
+     */
+    isActive(): boolean;
+    /**
+     * Perform the actual polygon split
+     */
+    private performPolygonSplit;
+    /**
+     * Clip a line to a bounding box
+     */
+    private clipLineToBbox;
+    /**
+     * Setup layers for split line visualization
+     */
+    private setupSplitLineLayers;
+    /**
+     * Attach event listeners for drawing the split line
+     */
+    private attachEventListeners;
+    /**
+     * Remove event listeners
+     */
+    private removeEventListeners;
+    /**
+     * Update the split line visualization
+     */
+    private updateSplitLineVisualization;
+    /**
+     * Complete the split operation
+     */
+    private completeSplit;
+    /**
+     * Cleanup after split operation
+     */
+    private cleanup;
+    /**
+     * Clear the split line visualization
+     */
+    private clearSplitLine;
+    /**
+     * Remove split line layers from the map
+     */
+    removeLayers(): void;
+    /**
+     * Cleanup resources
+     */
+    destroy(): void;
+}
+
+export declare interface SplitOptions {
+    /** Keep the original feature after splitting */
+    keepOriginal?: boolean;
+}
+
+export declare interface SplitResult {
+    /** Original feature that was split */
+    original: Feature<Polygon | LineString>;
+    /** Resulting parts after splitting */
+    parts: Feature[];
+    /** Whether the operation was successful */
+    success: boolean;
+    /** Error message if operation failed */
+    error?: string;
+}
+
+/**
+ * Toggle feature in selection
+ */
+export declare function toggleInSelection(selection: SelectedFeature[], feature: Feature, layerId?: string): SelectedFeature[];
+
+export declare type ToolbarOrientation = 'vertical' | 'horizontal';
+
+export declare type ToolbarPosition = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+
+/**
+ * Convert Feature array to SelectedFeature array
+ */
+export declare function toSelectedFeatures(features: Feature[], layerId?: string): SelectedFeature[];
+
+/**
+ * Handles polygon union/merge operations
+ */
+export declare class UnionFeature {
+    /**
+     * Merge multiple polygons into one
+     */
+    union(features: Feature<Polygon | MultiPolygon>[], options?: UnionOptions): UnionResult;
+    /**
+     * Check if polygons can be merged
+     */
+    canMerge(features: Feature<Polygon | MultiPolygon>[]): {
+        canMerge: boolean;
+        reason?: string;
+    };
+    /**
+     * Check if any polygons overlap
+     */
+    hasOverlap(features: Feature<Polygon | MultiPolygon>[]): boolean;
+    /**
+     * Get the combined area of all polygons
+     */
+    getCombinedArea(features: Feature<Polygon | MultiPolygon>[]): number;
+    /**
+     * Get the area of the union result
+     */
+    getUnionArea(features: Feature<Polygon | MultiPolygon>[]): number | null;
+}
+
+export declare interface UnionOptions {
+    /** Properties to use for the merged feature */
+    properties?: GeoJsonProperties;
+}
+
+export declare interface UnionResult {
+    /** Resulting merged feature */
+    result: Feature<Polygon | MultiPolygon> | null;
+    /** Original features that were merged */
+    originals: Feature<Polygon | MultiPolygon>[];
+    /** Whether the operation was successful */
+    success: boolean;
+    /** Error message if operation failed */
+    error?: string;
+}
+
 export { }